Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Pool di thread fissi, capacità della coda e arresto ordinato

Crea due pool con due thread ciascuno, confronta i limiti delle code e raccogli i risultati prima di chiamare `shutdown()` su entrambi.

Versione: Java SE 21

Sintassi

In java.util.concurrent:
public static ExecutorService Executors.newFixedThreadPool(int nThreads)
public static ExecutorService Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
void ExecutorService.shutdown()
public void ThreadPoolExecutor.shutdown()

Bounded-queue alternative:
new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy())

In Java SE 21, il metodo statico Executors.newFixedThreadPool(2) di java.util.concurrent restituisce un ExecutorService che riutilizza i thread di lavoro. Al massimo due thread elaborano attività contemporaneamente. Quando entrambi sono occupati, le altre attività aspettano in una coda condivisa senza un limite di capacità configurato. Limitare i thread non limita quindi il numero di attività in attesa. Se le attività arrivano più rapidamente di quanto il pool riesca a completarle, la coda può crescere e occupare più memoria.

L'overload Executors.newFixedThreadPool(nThreads, threadFactory) usa la ThreadFactory fornita per creare i thread, ma non limita la coda. Entrambi gli overload lanciano IllegalArgumentException per nThreads <= 0; il secondo lancia NullPointerException se la factory è null.

Per limitare l'accumulo, configura un ThreadPoolExecutor con dimensione di base e massima pari a 2 e una ArrayBlockingQueue<>(2). In questa configurazione fino a due attività possono essere eseguite dai thread del pool e fino ad altre due possono attendere in coda. Se il pool non può accettare un'attività perché entrambi i thread sono occupati e la coda è piena, AbortPolicy lancia RejectedExecutionException invece di aspettare che si liberi un posto. Rifiuta anche le attività inviate dopo l'avvio dell'arresto.

ExecutorService.shutdown() definisce il contratto di arresto ordinato e ThreadPoolExecutor.shutdown() lo implementa: le attività già accettate possono essere eseguite, quelle nuove vengono rifiutate e la chiamata non attende il completamento. Ripeterla non ha ulteriori effetti. Se un gestore della sicurezza attivo nega l'autorizzazione, è possibile ricevere una SecurityException. Nel flusso normale, raccogli tutti i risultati necessari con Future.get() prima di arrestare entrambi i pool in finally, che viene eseguito anche in caso di errore. get() attende una singola attività se necessario; per attendere con un limite di tempo la terminazione dell'intero pool dopo shutdown(), usa awaitTermination().

Esempi

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class PoolDemo {
    public static void main(String[] args)
            throws InterruptedException, ExecutionException {
        ExecutorService fixed = Executors.newFixedThreadPool(2);
        ThreadPoolExecutor bounded = new ThreadPoolExecutor(
                2, 2, 0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy());

        try {
            Future<Integer> first = fixed.submit(() -> 2);
            Future<Integer> second = fixed.submit(() -> 3);
            Future<Integer> third = bounded.submit(() -> 5);
            Future<Integer> fourth = bounded.submit(() -> 7);

            int fixedSum = first.get() + second.get();
            int boundedSum = third.get() + fourth.get();
            System.out.println("fixed=" + fixedSum + ", bounded=" + boundedSum);
        } finally {
            try {
                fixed.shutdown();
            } finally {
                bounded.shutdown();
            }
        }
    }
}

Risultato

fixed=5, bounded=12

Il programma invia due attività a ciascun pool e, nel flusso normale, raccoglie tutti e quattro i risultati prima dell'arresto. L'ordine di stampa non dipende dalla pianificazione dei thread. L'esempio non forza né il riempimento della coda né il rifiuto di un'attività.

Lezioni correlate

  • Java · Lezione 42 · Avanzato · Versione: 2

Fonti