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
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int)
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int, ThreadFactory)
- ExecutorService (Java SE 21 & JDK 21) — shutdown(), submit(), and awaitTermination()
- ThreadPoolExecutor (Java SE 21 & JDK 21) — queuing and task rejection
- ThreadPoolExecutor (Java SE 21 & JDK 21) — shutdown()
- ThreadPoolExecutor.AbortPolicy (Java SE 21 & JDK 21)
- ArrayBlockingQueue (Java SE 21 & JDK 21) — fixed queue capacity
- Future (Java SE 21 & JDK 21) — get()