newFixedThreadPool yöntemi

Executors sınıfının newFixedThreadPool yöntemi , sabit sayıda iş parçacığına sahip bir executorService oluşturur . newSingleThreadExecutor yönteminden farklı olarak , havuzda kaç tane iş parçacığı istediğimizi belirtiyoruz. Kaputun altında, aşağıdaki kod denir:

new ThreadPoolExecutor(nThreads, nThreads,
                                      	0L, TimeUnit.MILLISECONDS,
                                      	new LinkedBlockingQueue());

corePoolSize ( yürütme hizmeti başladığında hazır olacak (başlatılacak) iş parçacığı sayısı ) ve maximumPoolSize ( yürütme hizmetinin oluşturabileceği maksimum iş parçacığı sayısı ) parametreleri aynı değeri alır — newFixedThreadPool(nThreads) öğesine iletilen iş parçacığı sayısı ) . Ve kendi ThreadFactory uygulamamızı tamamen aynı şekilde geçirebiliriz .

Peki, neden böyle bir ExecutorService'e ihtiyacımız olduğunu görelim .

İşte sabit sayıda (n) iş parçacığı olan bir ExecutorService mantığı :

• İşleme görevleri için maksimum n iş parçacığı etkin olacaktır.
• n'den fazla görev gönderilirse, ileti dizileri serbest kalana kadar kuyrukta tutulurlar.
• Eğer thread'lerden biri başarısız olur ve sonlanırsa, onun yerini alacak yeni bir thread oluşturulur.
• Havuz kapatılana kadar havuzdaki herhangi bir iş parçacığı etkindir.

Örnek olarak, havaalanında güvenlikten geçmek için beklediğinizi hayal edin. Güvenlik kontrolünden hemen öncesine kadar herkes aynı sırada durur, yolcular çalışan tüm kontrol noktalarına dağıtılır. Kontrol noktalarından birinde gecikme olması durumunda, ilk kontrol noktası boş olana kadar sıra sadece ikincisi tarafından işlenecektir. Ve eğer bir kontrol noktası tamamen kapanırsa, onun yerine başka bir kontrol noktası açılacak ve yolcuların işlemleri iki kontrol noktasından devam edecek.

Hemen belirtelim ki, koşullar ideal olsa bile - söz verilen n iş parçacığı istikrarlı bir şekilde çalışıyor ve bir hatayla biten iş parçacıkları her zaman değiştiriliyor (sınırlı kaynakların gerçek bir havaalanında elde etmeyi imkansız kıldığı bir şey) - sistemin hala birkaç tane var hoş olmayan özellikler, çünkü sıra iş parçacıklarının görevleri işleyebileceğinden daha hızlı büyüse bile hiçbir koşulda daha fazla iş parçacığı olmayacak.

ExecutorService'in sabit sayıda iş parçacığıyla nasıl çalıştığına dair pratik bir anlayış edinmenizi öneririm . Runnable'ı uygulayan bir sınıf oluşturalım . Bu sınıfın nesneleri, ExecutorService için görevlerimizi temsil eder .

public class Task implements Runnable {
    int taskNumber;
 
    public Task(int taskNumber) {
        this.taskNumber = taskNumber;
    }
 
    @Override
    public void run() {
try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Processed user request #" + taskNumber + " on thread " + Thread.currentThread().getName());
    }
}
    

run() yönteminde , iş yükünü simüle ederek iş parçacığını 2 saniye bloke ederiz ve ardından mevcut görevin numarasını ve görevi yürüten iş parçacığının adını görüntüleriz.

ExecutorService executorService = Executors.newFixedThreadPool(3);
 
        for (int i = 0; i < 30; i++) {
            executorService.execute(new Task(i));
        }
        
        executorService.shutdown();
    

Başlamak için, ana yöntemde bir ExecutorService oluşturuyoruz ve yürütme için 30 görev gönderiyoruz.

Konsol çıktısı, görevlerin önceki görev tarafından serbest bırakıldıktan sonra farklı iş parçacıklarında nasıl yürütüldüğünü bize gösterir.

Şimdi görev sayısını 100'e çıkaracağız ve 100 görev gönderdikten sonra waitTermination(11, SECONDS) yöntemini çağıracağız . Bir sayı ve zaman birimini argüman olarak iletiyoruz. Bu yöntem, ana iş parçacığını 11 saniye süreyle engelleyecektir. Ardından, tüm görevlerin tamamlanmasını beklemeden ExecutorService'i kapanmaya zorlamak için shutdownNow()' u çağıracağız .

ExecutorService executorService = Executors.newFixedThreadPool(3);
 
        for (int i = 0; i < 100; i++) {
            executorService.execute(new Task(i));
        }
 
        executorService.awaitTermination(11, SECONDS);
 
        executorService.shutdownNow();
        System.out.println(executorService);
    

Sonunda, executorService'in durumu hakkında bilgi göstereceğiz .

İşte elde ettiğimiz konsol çıktısı:

Bunu, 3 aktif görevden uyku yöntemleri tarafından atılan 3 InterruptedExceptions takip eder .

Program sona erdiğinde 15 görevin yapıldığını ancak havuzda hala görevlerini yürütmeyi tamamlamayan 3 aktif iş parçacığının olduğunu görebiliriz. Bu üç iş parçacığında interrupt () yöntemi çağrılır, bu da görevin tamamlanacağı anlamına gelir, ancak bizim durumumuzda, uyku yöntemi bir InterruptedException fırlatır . Ayrıca shutdownNow() yöntemi çağrıldıktan sonra görev kuyruğunun temizlendiğini de görüyoruz .

Bu nedenle , havuzda sabit sayıda iş parçacığı olan bir ExecutorService kullanırken , nasıl çalıştığını hatırladığınızdan emin olun. Bu tip, bilinen bir sabit yüke sahip görevler için uygundur.

İşte başka bir ilginç soru: Tek bir iş parçacığı için bir yürütücü kullanmanız gerekiyorsa, hangi yöntemi çağırmalısınız? newSingleThreadExecutor() veya newFixedThreadPool(1) ?

Her iki uygulayıcı da eşdeğer davranışa sahip olacaktır. Tek fark, newSingleThreadExecutor() yönteminin, daha sonra ek iş parçacıkları kullanmak üzere yeniden yapılandırılamayacak bir yürütücü döndürmesidir.