CKTIS / Java
Pools de threads fixos, capacidade da fila e encerramento ordenado
Cria dois pools com duas threads cada, compara os limites das filas e recolhe os resultados antes de chamar `shutdown()` nos dois pools.
Versão: Java SE 21
Sintaxe
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())Em Java SE 21, o método estático Executors.newFixedThreadPool(2) de java.util.concurrent devolve um ExecutorService que reutiliza threads de trabalho. No máximo duas threads executam tarefas em simultâneo. Quando ambas estão ocupadas, as tarefas adicionais aguardam numa fila partilhada sem limite de capacidade configurado. Limitar as threads não limita, portanto, a acumulação de tarefas em espera. Se as tarefas chegarem mais depressa do que o pool as conclui, a fila pode crescer e ocupar mais memória.
A sobrecarga Executors.newFixedThreadPool(nThreads, threadFactory) usa a ThreadFactory fornecida para criar threads, mas não limita a fila. Ambas as sobrecargas lançam IllegalArgumentException se nThreads <= 0; a segunda lança NullPointerException se a fábrica for null.
Para limitar a acumulação, configura um ThreadPoolExecutor com tamanho base e tamanho máximo iguais a 2 e uma ArrayBlockingQueue<>(2). Nesta configuração, até duas tarefas podem ser executadas pelas threads do pool e até outras duas podem aguardar na fila. Se o pool não conseguir aceitar uma tarefa porque ambas as threads estão ocupadas e a fila está cheia, AbortPolicy lança RejectedExecutionException em vez de esperar por espaço. Também rejeita tarefas submetidas depois de iniciado o encerramento.
ExecutorService.shutdown() define o contrato de encerramento ordenado e ThreadPoolExecutor.shutdown() implementa-o: as tarefas já aceites podem ser executadas, as novas são rejeitadas e a chamada não espera pela conclusão. Repetir a chamada não tem efeito adicional. Se um gestor de segurança ativo negar a permissão, pode ocorrer uma SecurityException. No fluxo normal, recolhe todos os resultados necessários com Future.get() antes de encerrar ambos os pools em finally, que também é executado se houver uma falha. get() espera por uma tarefa específica, se necessário; para aguardar com um limite de tempo pela terminação de todo o pool após shutdown(), usa awaitTermination().
Exemplos
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();
}
}
}
}Resultado
fixed=5, bounded=12
O programa submete duas tarefas a cada pool e, no fluxo normal, recolhe os quatro resultados antes do encerramento. Apresenta apenas as duas somas, uma por pool, numa ordem fixa, independentemente do escalonamento das threads. Não força o enchimento da fila nem a rejeição de uma tarefa.
Lições relacionadas
- Java · Lição 42 · Avançado · Versão: 2
Fontes
- 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()