newCachedThreadPool metódus

A szálkészlet másik típusa a "gyorsítótárazott". Az ilyen szálkészleteket ugyanolyan gyakran használják, mint a rögzítetteket.

Ahogy a név is jelzi, ez a fajta szálkészlet gyorsítótárazza a szálakat. Korlátozott ideig életben tartja a fel nem használt szálakat annak érdekében, hogy ezeket a szálakat újra felhasználhassa új feladatok végrehajtására. Egy ilyen szálkészlet akkor a legjobb, ha ésszerű mennyiségű könnyű munkánk van.

A "némi ésszerű összeg" jelentése meglehetősen tág, de tudnia kell, hogy egy ilyen készlet nem alkalmas minden feladatra. Tegyük fel például, hogy millió feladatot szeretnénk létrehozni. Még ha mindegyik nagyon kevés időt vesz is igénybe, akkor is ésszerűtlenül sok erőforrást használunk fel, és rontjuk a teljesítményt. El kell kerülnünk az ilyen készleteket is, ha a végrehajtási idő kiszámíthatatlan, például I/O feladatoknál.

A burkolat alatt a ThreadPoolExecutor konstruktor a következő argumentumokkal kerül meghívásra:

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

A következő értékek kerülnek átadásra a konstruktornak argumentumként:

És pontosan ugyanúgy átadhatjuk a saját ThreadFactory implementációnkat.

Beszéljünk a SynchronousQueue-ról

A szinkron átvitel alapötlete meglehetősen egyszerű, és mégis ellentétes az intuitív (vagyis az intuíció vagy a józan ész azt mondja, hogy ez rossz): akkor és csak akkor vehet fel egy elemet a sorba, ha egy másik szál megkapja az elemet a Ugyanakkor. Más szóval, egy szinkron sorban nem lehetnek feladatok, mert amint új feladat érkezik, a végrehajtó szál már felvette a feladatot .

Amikor egy új feladat belép a sorba, és ha van egy szabad aktív szál a készletben, akkor felveszi a feladatot. Ha az összes szál foglalt, akkor egy új szál jön létre.

A gyorsítótárazott készlet nulla szálal kezdődik, és potenciálisan Integer.MAX_VALUE szálra nőhet . A gyorsítótárazott szálkészlet méretét lényegében csak a rendszererőforrások korlátozzák.

A rendszererőforrások kímélése érdekében a gyorsítótárazott szálkészletek eltávolítják az egy percig tétlen szálakat.

Lássuk, hogyan működik a gyakorlatban. Létrehozunk egy feladatosztályt, amely egy felhasználói kérést modellez:

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

A fő módszerben létrehozzuk a newCachedThreadPool-t , majd hozzáadunk 3 feladatot a végrehajtáshoz. Itt nyomtatjuk ki szolgáltatásunk állapotát (1) .

Ezután 30 másodpercre szünetet tartunk, újabb feladatot indítunk, és megjelenítjük az állapotot (2) .

Ezt követően 70 másodpercre szüneteltetjük főszálunkat, kinyomtatjuk az állapotot (3) , majd ismét hozzáadunk 3 feladatot, és ismét kinyomtatjuk az állapotot (4) .

Azokon a helyeken, ahol a feladat hozzáadása után azonnal megjelenítjük az állapotot, először 1 másodperces alvást adunk hozzá a naprakész kimenet érdekében.

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

És íme az eredmény:

Nézzük végig az egyes lépéseket:

Nos, most már megismerte egy másik típusú végrehajtói szolgáltatás logikáját.

Az Executors segédprogram osztály egyéb módszereivel analóg módon a newCachedThreadPool metódusnak is van egy túlterhelt verziója, amely egy ThreadFactory objektumot vesz argumentumként.