newCachedThreadPool yöntemi

Başka bir iş parçacığı havuzu türü "önbelleğe alınmış" tır. Bu tür iş parçacığı havuzları, sabit olanlar kadar yaygın olarak kullanılır.

Adından da anlaşılacağı gibi, bu tür bir iş parçacığı havuzu, iş parçacıklarını önbelleğe alır. Yeni görevleri gerçekleştirmek için bu iş parçacıklarını yeniden kullanmak üzere kullanılmayan iş parçacıklarını sınırlı bir süre için canlı tutar. Böyle bir iş parçacığı havuzu, makul miktarda hafif işimiz olduğunda en iyisidir.

"Makul bir miktar" ifadesinin anlamı oldukça geniştir, ancak böyle bir havuzun her sayıda görev için uygun olmadığını bilmelisiniz. Örneğin, bir milyon görev oluşturmak istediğimizi varsayalım. Her biri çok az zaman alsa bile, yine de makul olmayan miktarda kaynak kullanır ve performansı düşürürüz. Yürütme süresi öngörülemez olduğunda, örneğin G/Ç görevlerinde bu tür havuzlardan da kaçınmalıyız.

Başlık altında, ThreadPoolExecutor yapıcısı aşağıdaki bağımsız değişkenlerle çağrılır:

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

Aşağıdaki değerler yapıcıya bağımsız değişken olarak iletilir:

Ve kendi ThreadFactory uygulamamızı tamamen aynı şekilde geçirebiliriz .

SynchronousQueue hakkında konuşalım

Eşzamanlı aktarımın temel fikri oldukça basittir ve yine de sezgisel değildir (yani, sezgiler veya sağduyu size bunun yanlış olduğunu söyler): bir kuyruğa bir öğe ekleyebilirsiniz, ancak ve ancak başka bir iş parçacığı öğeyi aynı anda alırsa aynı zamanda. Başka bir deyişle, senkronize bir kuyruğun içinde görevler olamaz, çünkü yeni bir görev gelir gelmez, yürüten iş parçacığı görevi çoktan almıştır .

Kuyruğa yeni bir görev girdiğinde, havuzda boş bir aktif iş parçacığı varsa, o zaman görevi alır. Tüm ileti dizileri meşgulse yeni bir ileti dizisi oluşturulur.

Önbelleğe alınmış bir havuz sıfır iş parçacığıyla başlar ve potansiyel olarak Integer.MAX_VALUE iş parçacığına kadar büyüyebilir . Temel olarak, önbelleğe alınmış bir iş parçacığı havuzunun boyutu yalnızca sistem kaynaklarıyla sınırlıdır.

Önbelleğe alınan iş parçacığı havuzları, sistem kaynaklarını korumak için bir dakika boşta kalan iş parçacıklarını kaldırır.

Pratikte nasıl çalıştığını görelim. Bir kullanıcı isteğini modelleyen bir görev sınıfı oluşturacağız:

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

Ana yöntemde , newCachedThreadPool oluşturuyoruz ve ardından yürütme için 3 görev ekliyoruz. Burada hizmetimizin durumunu yazdırıyoruz (1) .

Ardından, 30 saniye duraklıyoruz, başka bir göreve başlıyoruz ve durumu gösteriyoruz (2) .

Bundan sonra ana iş parçacığımızı 70 saniye duraklatıyoruz, durumu yazdırıyoruz (3) , ardından tekrar 3 görev ekliyoruz ve durumu tekrar yazdırıyoruz (4) .

Görev ekledikten hemen sonra durumu gösterdiğimiz yerlerde, güncel çıktı için önce 1 saniye uyku ekliyoruz.

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

Ve işte sonuç:

Adımların her birini gözden geçirelim:

Pekala, artık başka tür bir yürütücü hizmetinin mantığını öğrendiniz.

Executors yardımcı program sınıfının diğer yöntemlerine benzer şekilde , newCachedThreadPool yöntemi ayrıca bir ThreadFactory nesnesini bağımsız değişken olarak alan aşırı yüklenmiş bir sürüme sahiptir .