metode newCachedThreadPool

Jinis liyane blumbang thread "cached". Kolam benang kaya biasane digunakake minangka sing tetep.

Kaya sing dituduhake kanthi jeneng, blumbang benang iki nyimpen benang. Utas sing ora digunakake tetep urip sajrone wektu winates supaya bisa nggunakake maneh benang kasebut kanggo nindakake tugas anyar. Kolam Utas kuwi paling apik kanggo nalika kita duwe sawetara cukup karya cahya.

Makna "sawetara jumlah sing cukup" cukup jembar, nanging sampeyan kudu ngerti manawa blumbang kasebut ora cocog kanggo saben tugas. Contone, umpamane kita pengin nggawe jutaan tugas. Sanajan saben njupuk wektu sing sithik, kita isih bakal nggunakake sumber daya sing ora wajar lan ngrusak kinerja. Kita uga kudu ngindhari pools kasebut nalika wektu eksekusi ora bisa ditebak, contone, karo tugas I / O.

Ing hood, konstruktor ThreadPoolExecutor diarani kanthi argumen ing ngisor iki:

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

Nilai ing ngisor iki diterusake menyang konstruktor minangka argumen:

Lan kita bisa ngliwati implementasine ThreadFactory kanthi cara sing padha.

Ayo dadi pirembagan bab SynchronousQueue

Ide dhasar saka transfer sinkron cukup prasaja nanging kontra-intuisi (yaiku, intuisi utawa akal sehat ngandhani yen iku salah): sampeyan bisa nambah unsur menyang antrian yen lan mung yen thread liyane nampa unsur ing Sanalika. Ing tembung liyane, antrian sinkron ora bisa duwe tugas, amarga sanalika tugas anyar teka, utas pelaksana wis njupuk tugas .

Nalika tugas anyar lumebu ing antrian, yen ana free Utas aktif ing blumbang, banjur njupuk munggah tugas. Yen kabeh utas sibuk, banjur thread anyar digawe.

Kolam sing di-cache diwiwiti kanthi nol benang lan bisa tuwuh dadi benang Integer.MAX_VALUE . Ateges, ukuran blumbang thread cache mung diwatesi dening sumber daya sistem.

Kanggo ngirit sumber daya sistem, kumpulan benang sing di-cache mbusak benang sing ora aktif sajrone semenit.

Ayo ndeleng cara kerjane ing praktik. Kita bakal nggawe kelas tugas sing nggawe model panyuwunan pangguna:

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

Ing cara utama , kita nggawe newCachedThreadPool banjur nambah 3 tugas kanggo eksekusi. Ing kene kita nyithak status layanan kita (1) .

Sabanjure, kita ngaso 30 detik, miwiti tugas liyane, lan nampilake status (2) .

Sawisé iku, kita ngaso thread utama kita kanggo 70 detik, print status (3) , banjur maneh nambah 3 tugas, lan maneh print status (4) .

Ing panggonan ngendi kita nampilake status sanalika sawise nambah tugas, kita pisanan nambah turu 1 detik kanggo output up-to-date.

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

Lan iki asile:

Ayo pindhah liwat saben langkah:

Inggih, saiki sampeyan wis ngerti logika saka jinis layanan eksekutor liyane.

Kanthi analogi karo metode liyane saka kelas utilitas Executors , metode newCachedThreadPool uga nduweni versi sing overloaded sing njupuk obyek ThreadFactory minangka argumen.