CKTIS / Java
ThreadPoolExecutor: pool limitato e CallerRunsPolicy
ThreadPoolExecutor gestisce un pool di thread e una coda di attività. Scopri quando crea thread o accoda il lavoro, come ThreadPoolExecutor.CallerRunsPolicy gestisce il sovraccarico e come shutdown() e awaitTermination() consentono una terminazione ordinata.
Versione: Java SE 21; repository runtime, production runtime not attested
Sintassi
new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new ThreadPoolExecutor.CallerRunsPolicy());
executor.execute(task);
executor.shutdown();
executor.awaitTermination(timeout, unit);ThreadPoolExecutor esegue le attività usando thread raccolti in un pool. Quando viene inviata un’attività, crea un thread se il numero di worker è inferiore a corePoolSize; altrimenti prova ad accodarla. Se la coda è piena, può creare thread fino al limite maximumPoolSize, quindi applica la politica di rifiuto. Una coda senza limiti normalmente impedisce al pool di crescere oltre corePoolSize e può accumulare un arretrato senza limite.
ThreadPoolExecutor.CallerRunsPolicy esegue in modo sincrono un’attività rifiutata nel thread che chiama execute, a meno che l’executor non sia stato arrestato. Questo rallenta chi produce le attività, ma può bloccare, per esempio, un thread che gestisce richieste. Il limite del pool non include queste esecuzioni nel thread chiamante. Dopo l’arresto, questa politica scarta l’attività senza segnalarlo, invece di lanciare un’eccezione; non ne garantisce quindi l’esecuzione.
ThreadPoolExecutor.shutdown avvia un arresto ordinato: le attività già accettate vengono eseguite, ma non ne vengono accettate di nuove. Il metodo non attende il completamento; a questo serve awaitTermination, di cui va controllato il risultato. shutdownNow() tenta soltanto di interrompere i thread, perciò le attività devono reagire alle interruzioni. L’esempio usa un meccanismo di sincronizzazione invece di ritardi per provocare il sovraccarico. Ambito: Java SE 21; l’ambiente di esecuzione del repository non è attestato, così come non è attestato quello di produzione.
Esempi
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class Main {
public static void main(String[] args) throws InterruptedException {
CountDownLatch release = new CountDownLatch(1);
AtomicInteger completed = new AtomicInteger();
Thread caller = Thread.currentThread();
ThreadPoolExecutor executor = new ThreadPoolExecutor(
1, 1, 0L, TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(1),
new ThreadPoolExecutor.CallerRunsPolicy());
try {
executor.execute(() -> {
try {
release.await();
completed.incrementAndGet();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
executor.execute(() -> completed.incrementAndGet());
executor.execute(() -> {
System.out.println("caller thread: "
+ (Thread.currentThread() == caller));
completed.incrementAndGet();
});
} finally {
release.countDown();
executor.shutdown();
}
try {
if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
executor.shutdownNow();
throw new IllegalStateException("Termination timed out");
}
} catch (InterruptedException e) {
executor.shutdownNow();
Thread.currentThread().interrupt();
throw e;
}
System.out.println("completed: " + completed.get());
}
}Risultato
caller thread: true completed: 3
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.