CKTIS / Java
Executors.newFixedThreadPool — conjunto de threads de tamanho fixo
Um conjunto de tamanho 3 processa, no máximo, três tarefas em simultâneo, sem garantir que comecem no mesmo instante. Se todas as threads estiverem ocupadas, as tarefas adicionais aguardam numa fila.
Versão: Java SE 21
Sintaxe
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 é um método de fábrica estático da classe java.util.concurrent.Executors. Devolve um ExecutorService que reutiliza as threads de trabalho para várias tarefas. Com Executors.newFixedThreadPool(3), podem estar em curso, no máximo, três tarefas em simultâneo. Este é um limite máximo, não uma garantia de que comecem no mesmo instante, sejam executadas fisicamente em paralelo ou terminem pela ordem de submissão.
Se todas as threads de trabalho estiverem ocupadas, as tarefas adicionais aguardam numa fila partilhada sem limite de capacidade definido. O tamanho do conjunto limita as threads, não o número de tarefas em espera. Se as tarefas continuarem a chegar mais depressa do que o conjunto as termina, a fila pode consumir cada vez mais memória. Para limitar as tarefas em espera, usa um ThreadPoolExecutor com uma fila de capacidade limitada e uma política de rejeição escolhida explicitamente.
A sobrecarga que só recebe int nThreads usa a fábrica predefinida, que cria threads não daemon. A sobrecarga com ThreadFactory usa a fábrica fornecida para criar threads quando necessário. Ambas lançam IllegalArgumentException se nThreads <= 0; a segunda também lança NullPointerException se a fábrica for null. Se uma thread terminar devido a uma falha antes do encerramento, o conjunto substitui-a se for preciso para executar tarefas posteriores.
Encerra o conjunto quando já não precisares dele: as threads criadas pela fábrica predefinida podem manter a JVM ativa. shutdown() deixa de aceitar tarefas novas, permite a execução das já submetidas e não espera pelo fim do executor. Em Java SE 21, o try com recursos chama close(), que inicia o encerramento e espera que o executor termine.
Exemplos
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());
}
}
}Resultado
Fourth task done before release: false Fourth task result: 4
Cada uma das três primeiras tarefas ocupa uma thread e não pode terminar antes do desbloqueio. Por isso, `isDone()` devolve `false` para a quarta tarefa. Após o desbloqueio, `get()` aguarda, se necessário, pelo resultado `4`. O exemplo mostra que as tarefas se sobrepõem no tempo, não que comecem no mesmo instante.
Lições relacionadas
- Java · Lição 50 · Intermédio · Versão: 2
Fontes
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int)
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int, ThreadFactory)
- Executors (Java SE 21 & JDK 21) — defaultThreadFactory()
- ExecutorService (Java SE 21 & JDK 21)
- ThreadPoolExecutor (Java SE 21 & JDK 21) — queuing and resource use
- CountDownLatch (Java SE 21 & JDK 21)
- Future (Java SE 21 & JDK 21)