วิธีการ newCachedThreadPool

พูลเธรดอีกประเภทหนึ่งคือ "แคช" พูลเธรดดังกล่าวใช้กันทั่วไปเช่นเดียวกับเธรดแบบคงที่

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

ความหมายของ "จำนวนที่เหมาะสม" ค่อนข้างกว้าง แต่คุณควรทราบว่ากลุ่มดังกล่าวไม่เหมาะสำหรับทุกงาน ตัวอย่างเช่น สมมติว่าเราต้องการสร้างงานหนึ่งล้านงาน แม้ว่าแต่ละครั้งจะใช้เวลาเพียงเล็กน้อย แต่เราจะยังคงใช้ทรัพยากรในปริมาณที่ไม่สมเหตุสมผลและทำให้ประสิทธิภาพการทำงานลดลง เราควรหลีกเลี่ยงกลุ่มดังกล่าวเมื่อไม่สามารถคาดการณ์เวลาดำเนินการได้ เช่น กับงาน I/O

ภายใต้ประทุน ตัวสร้าง ThreadPoolExecutorถูกเรียกโดยมีอาร์กิวเมนต์ต่อไปนี้:

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
      new SynchronousQueue<Runnable>());
}

ค่าต่อไปนี้จะถูกส่งผ่านไปยังตัวสร้างเป็นอาร์กิวเมนต์:

และเราสามารถผ่านการใช้งานThreadFactoryในแบบเดียวกันได้

พูดคุยเกี่ยวกับ SynchronousQueue

แนวคิดพื้นฐานของการถ่ายโอนแบบซิงโครนัสนั้นค่อนข้างเรียบง่ายและสวนทางกับสัญชาตญาณ (นั่นคือสัญชาตญาณหรือสามัญสำนึกบอกคุณว่ามันผิด): คุณสามารถเพิ่มองค์ประกอบลงในคิวได้ก็ต่อเมื่อเธรดอื่นได้รับองค์ประกอบที่ ในเวลาเดียวกัน. กล่าวอีกนัยหนึ่งคิวแบบซิงโครนัสไม่สามารถมีงานอยู่ในนั้น เนื่องจากทันทีที่งานใหม่มาถึง เธรดที่ดำเนินการได้เลือกงานแล้ว

เมื่องานใหม่เข้าสู่คิว หากมีเธรดว่างที่ใช้งานอยู่ในพูล ก็จะรับงานนั้น หากเธรดทั้งหมดไม่ว่าง เธรดใหม่จะถูกสร้างขึ้น

พูลแคชเริ่มต้นด้วยเธรดศูนย์และสามารถขยายเป็นเธรดInteger.MAX_VALUE โดยพื้นฐานแล้ว ขนาดของพูลเธรดแคชจะถูกจำกัดโดยทรัพยากรระบบเท่านั้น

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

มาดูกันว่าได้ผลจริงอย่างไร เราจะสร้างคลาสงานที่จำลองคำขอของผู้ใช้:

public class Task implements Runnable {
   int taskNumber;

   public Task(int taskNumber) {
       this.taskNumber = taskNumber;
   }

   @Override
   public void run() {
       System.out.println("Processed user request #" + taskNumber + " on thread " + Thread.currentThread().getName());
   }
}

ใน เมธอด หลักเราสร้างnewCachedThreadPoolแล้วเพิ่ม 3 งานสำหรับการดำเนินการ ที่นี่เราพิมพ์สถานะบริการของเรา(1) .

ต่อไป เราหยุดชั่วคราวเป็นเวลา 30 วินาที เริ่มงานอื่น และแสดงสถานะ(2) .

หลังจากนั้น เราหยุดเธรดหลักของเราชั่วคราวเป็นเวลา 70 วินาที พิมพ์สถานะ( 3)จากนั้นเพิ่มงาน 3 งานอีกครั้ง และพิมพ์สถานะอีกครั้ง(4)

ในสถานที่ที่เราแสดงสถานะทันทีหลังจากเพิ่มงาน อันดับแรก เราจะเพิ่มโหมดสลีป 1 วินาที สำหรับเอาต์พุตที่เป็นปัจจุบัน

ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
            executorService.submit(new Task(i));
        }

        TimeUnit.SECONDS.sleep(1);
            System.out.println(executorService);	//(1)

        TimeUnit.SECONDS.sleep(30);

        executorService.submit(new Task(3));
        TimeUnit.SECONDS.sleep(1);
            System.out.println(executorService);	//(2)

        TimeUnit.SECONDS.sleep(70);

            System.out.println(executorService);	//(3)

        for (int i = 4; i < 7; i++) {
            executorService.submit(new Task(i));
        }

        TimeUnit.SECONDS.sleep(1);
            System.out.println(executorService);	//(4)
        executorService.shutdown();

และนี่คือผลลัพธ์:

มาดูกันทีละขั้นตอน:

ตอนนี้คุณคุ้นเคยกับตรรกะของบริการตัวดำเนินการประเภทอื่นแล้ว

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