Computer >> คอมพิวเตอร์ >  >> การเขียนโปรแกรม >> Java

ความแตกต่างระหว่างพูลเธรดคงที่และพูลเธรดที่แคช


กรอบงานผู้ดำเนินการได้รับการออกแบบโดยใช้แนวคิดกลุ่มเธรด เธรดพูลเป็นวิธีการนำเธรดที่สร้างไว้แล้วกลับมาใช้ใหม่ แทนที่จะสร้างเธรดใหม่ทุกครั้งเพื่อดำเนินการงานปัจจุบัน

คลาสตัวดำเนินการจัดเตรียมวิธีการจากโรงงานเพื่อสร้างพูลเธรด คลาส ThreadPoolExecutor เป็นการใช้งานพื้นฐานสำหรับ executors ที่ส่งคืนจากวิธีการต่างๆ ของ Executors จากโรงงาน

ซีเนียร์ เลขที่ คีย์ แก้ไขกลุ่มเธรด พูลเธรดที่แคช
1
พื้นฐาน
ตาม Java Doc −
สร้างพูลเธรดที่นำเธรดจำนวนคงที่กลับมาใช้ใหม่โดยดำเนินการจากคิวที่ไม่ จำกัด แบบแบ่งใช้ ณ จุดใด ๆ ที่เธรด nThreads ส่วนใหญ่จะเป็นงานการประมวลผลที่ใช้งานอยู่ หากมีการส่งงานเพิ่มเติมเมื่อเธรดทั้งหมดทำงาน พวกเขาจะรอในคิวจนกว่าเธรดจะพร้อมใช้งาน หากเธรดใดหยุดทำงานเนื่องจากความล้มเหลวระหว่างการดำเนินการก่อนที่จะปิด เธรดใหม่จะเข้ามาแทนที่หากจำเป็นเพื่อดำเนินงานที่ตามมา เธรดในพูลจะมีอยู่จนกว่าจะมีการปิดระบบอย่างชัดแจ้ง
ตาม Java Doc −
สร้างเธรดพูลที่สร้างเธรดใหม่ตามต้องการ แต่จะใช้เธรดที่สร้างไว้ก่อนหน้านี้ซ้ำเมื่อพร้อมใช้งาน โดยทั่วไป พูลเหล่านี้จะปรับปรุงประสิทธิภาพของโปรแกรมที่ทำงานแบบอะซิงโครนัสที่มีอายุสั้นจำนวนมาก การโทรเพื่อดำเนินการจะใช้เธรดที่สร้างไว้ก่อนหน้านี้ซ้ำ หากมี หากไม่มีเธรดที่มีอยู่ เธรดใหม่จะถูกสร้างขึ้นและเพิ่มลงในพูล
2
คิว
ใช้ Blocking Queue


มันใช้ SynchronousQueue
คิว .


3
อายุเธรด
มันจะทำให้เธรดทั้งหมดทำงานจนกว่าจะมีการยกเลิกอย่างชัดเจน
กระทู้ที่ไม่ได้ใช้เป็นเวลาหกสิบวินาทีจะถูกยกเลิกและลบออกจากแคช
4.
ขนาดพูลเธรด
ขนาดของเธรดพูลได้รับการแก้ไขเพื่อไม่ให้ขยาย
เธรดพูลสามารถขยายจากศูนย์เธรดเป็น Integer.MAX_VALUE
5.
ใช้ตัวพิมพ์
เราควรใช้ fixedthreadpool เมื่อเราต้องการจำกัดงานที่เกิดขึ้นพร้อมกัน
สามารถใช้ได้เมื่อคุณมีงานที่คาดเดาได้มากมาย

ตัวอย่างกลุ่มเธรดคงที่

public class Main {
   public static void main(String args[]) throws InterruptedException {
      ExecutorService executors = Executors.newFixedThreadPool(4);
      CountDownLatch latch= new CountDownLatch(2);
      executors.submit(new Service1(latch));
      executors.submit(new Service2(latch));
      latch.await();
      System.out.println("Done");
   }

import java.util.concurrent.CountDownLatch;
public class Service1 implements Runnable {
   CountDownLatch latch;
   public Service1(CountDownLatch latch) {
      super();
      this.latch = latch;
   }
   @Override
   public void run() {
      try {
         Thread.sleep(20000);
      } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
         }
         latch.countDown();
         System.out.println("Services2"+latch.getCount());
      }
   }
   import java.util.concurrent.CountDownLatch;
   public class Service2 implements Runnable {
      CountDownLatch latch;
      public Service2(CountDownLatch latch) {
         super();
         this.latch = latch;
      }
      @Override
      public void run() {
         try {
            Thread.sleep(20000);
         } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
   latch.countDown();
   System.out.println("Services2"+latch.getCount());
   }
}