Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Executors.newFixedThreadPool — pool di thread a dimensione fissa

Un pool di dimensione 3 può gestire al massimo tre attività per volta, senza che debbano iniziare nello stesso istante. Quando tutti i thread sono occupati, le altre attività attendono in coda.

Versione: Java SE 21

Sintassi

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

// Static methods declared by Executors:
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)

// Example call:
ExecutorService pool = Executors.newFixedThreadPool(3);

Executors.newFixedThreadPool è un metodo factory statico della classe java.util.concurrent.Executors. Restituisce un ExecutorService che riutilizza i thread di lavoro per più attività. Con Executors.newFixedThreadPool(3) possono essere in corso al massimo tre attività per volta. È un limite massimo, non una garanzia che inizino nello stesso istante, vengano eseguite fisicamente in parallelo o terminino nell’ordine di invio.

Quando tutti i thread di lavoro sono occupati, le altre attività attendono in una coda condivisa senza un limite di capacità prefissato. La dimensione del pool limita i thread, non le attività in attesa. Se le attività continuano ad arrivare più rapidamente di quanto il pool riesca a completarle, la coda può occupare sempre più memoria. Per limitare le attività in attesa, usa un ThreadPoolExecutor con una coda a capacità limitata e una politica di rifiuto scelta esplicitamente.

L’overload con il solo int nThreads usa la factory predefinita, che crea thread non daemon. L’overload con ThreadFactory usa la factory fornita per creare thread quando servono. Entrambi generano IllegalArgumentException se nThreads <= 0; il secondo genera anche NullPointerException se la factory è null. Se un thread termina per un errore prima della chiusura, il pool lo sostituisce se necessario per eseguire le attività successive.

Chiudi il pool quando non serve più: i thread creati dalla factory predefinita possono tenere in vita la JVM. shutdown() non accetta nuove attività, lascia eseguire quelle già inviate e non attende la terminazione. In Java SE 21, il try-with-resources chiama close(), che avvia la chiusura e attende la terminazione dell’executor.

Esempi

import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FixedPoolDemo {
    public static void main(String[] args)
            throws InterruptedException, ExecutionException {
        CountDownLatch started = new CountDownLatch(3);
        CountDownLatch release = new CountDownLatch(1);

        try (ExecutorService pool = Executors.newFixedThreadPool(3)) {
            Callable<Void> holdWorker = () -> {
                started.countDown();
                release.await();
                return null;
            };

            Future<Integer> fourth;
            try {
                for (int i = 0; i < 3; i++) {
                    pool.submit(holdWorker);
                }
                started.await();
                fourth = pool.submit(() -> 4);
                System.out.println("Fourth task done before release: " + fourth.isDone());
            } finally {
                release.countDown();
            }
            System.out.println("Fourth task result: " + fourth.get());
        }
    }
}

Risultato

Fourth task done before release: false
Fourth task result: 4

Ognuna delle prime tre attività occupa un thread e non può terminare prima dello sblocco. Perciò, `isDone()` restituisce `false` per la quarta. Dopo lo sblocco, `get()` attende se necessario il risultato `4`. L’esempio mostra che le attività si sovrappongono, non che inizino nello stesso istante.

Lezioni correlate

  • Java · Lezione 50 · Intermedio · Versione: 2

Fonti