Metode baruCachedThreadPool

Jenis kumpulan utas lainnya adalah "di-cache". Kumpulan utas seperti itu biasa digunakan sebagai kumpulan tetap.

Seperti yang ditunjukkan oleh namanya, kumpulan utas ini menyimpan utas. Itu membuat utas yang tidak terpakai tetap hidup untuk waktu yang terbatas untuk menggunakan kembali utas tersebut untuk melakukan tugas baru. Kumpulan utas seperti itu paling baik untuk saat kita memiliki pekerjaan ringan dalam jumlah yang wajar.

Arti dari "jumlah yang masuk akal" agak luas, tetapi Anda harus tahu bahwa kumpulan seperti itu tidak cocok untuk setiap jumlah tugas. Misalnya, kita ingin membuat sejuta tugas. Bahkan jika masing-masing membutuhkan waktu yang sangat singkat, kami masih akan menggunakan sumber daya yang tidak masuk akal dan menurunkan kinerja. Kita juga harus menghindari kumpulan seperti itu ketika waktu eksekusi tidak dapat diprediksi, misalnya, dengan tugas I/O.

Di bawah tenda, konstruktor ThreadPoolExecutor dipanggil dengan argumen berikut:

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

Nilai-nilai berikut diteruskan ke konstruktor sebagai argumen:

Dan kita bisa melewati implementasi ThreadFactory kita sendiri dengan cara yang persis sama.

Mari kita bicara tentang SynchronousQueue

Ide dasar transfer sinkron cukup sederhana namun kontra-intuitif (yaitu, intuisi atau akal sehat memberi tahu Anda bahwa itu salah): Anda dapat menambahkan elemen ke antrean jika dan hanya jika utas lain menerima elemen di waktu yang sama. Dengan kata lain, antrean sinkron tidak dapat memiliki tugas di dalamnya, karena segera setelah tugas baru tiba, utas pelaksana telah mengambil tugas tersebut .

Saat tugas baru memasuki antrean, jika ada utas aktif gratis di kumpulan, tugas tersebut akan diambil. Jika semua utas sibuk, maka utas baru dibuat.

Kumpulan cache dimulai dengan nol utas dan berpotensi berkembang menjadi utas Integer.MAX_VALUE . Pada dasarnya, ukuran kumpulan thread yang di-cache hanya dibatasi oleh sumber daya sistem.

Untuk menghemat sumber daya sistem, kumpulan utas yang di-cache menghapus utas yang menganggur selama satu menit.

Mari kita lihat cara kerjanya dalam praktik. Kami akan membuat kelas tugas yang memodelkan permintaan pengguna:

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());
   }
}

Dalam metode utama , kami membuat newCachedThreadPool dan kemudian menambahkan 3 tugas untuk dieksekusi. Di sini kami mencetak status layanan kami (1) .

Selanjutnya, kita jeda selama 30 detik, memulai tugas lain, dan menampilkan status (2) .

Setelah itu, kami menjeda utas utama kami selama 70 detik, mencetak status (3) , lalu menambahkan 3 tugas lagi, dan mencetak lagi status (4) .

Di tempat kami menampilkan status segera setelah menambahkan tugas, pertama-tama kami menambahkan tidur 1 detik untuk keluaran terbaru.

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();

Dan inilah hasilnya:

Mari kita bahas setiap langkahnya:

Nah, sekarang Anda sudah mengenal logika jenis layanan eksekutor lainnya.

Dengan analogi dengan metode lain dari kelas utilitas Pelaksana , metode newCachedThreadPool juga memiliki versi kelebihan muatan yang menggunakan objek ThreadFactory sebagai argumen.