Como criar um pool de threads em Java?

Como criar um pool de threads em Java?

O pool de threads é uma técnica usada para reutilizar threads em vez de criar novas sempre que uma tarefa precisa ser executada. Isso melhora o desempenho, reduz a sobrecarga do sistema e gerencia melhor os recursos do processador.

1. O que é um Pool de Threads?

Um Thread Pool mantém um número fixo de threads prontas para executar tarefas. Quando uma thread finaliza sua execução, ela retorna ao pool para ser reutilizada.

2. Criando um Pool de Threads com Executors

A forma mais simples de criar um pool de threads em Java é usando a classe Executors:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExemplo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            executor.execute(() -> {
                System.out.println("Thread executando: " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

Explicação:

• Criamos um ExecutorService com um pool de 3 threads.
• Submetemos 5 tarefas, que serão executadas pelas threads disponíveis.
• shutdown() é chamado para encerrar o executor após a execução.

3. Tipos de ExecutorService

Podemos criar diferentes tipos de pools de threads:

4. Exemplo de newCachedThreadPool()

ExecutorService executor = Executors.newCachedThreadPool();

Cria um pool dinâmico, adicionando threads conforme necessário e reutilizando as inativas.

5. Finalizando um Executor

• shutdown(): Aguarda a finalização das tarefas antes de encerrar o executor.
• shutdownNow(): Tenta interromper todas as tarefas imediatamente.

executor.shutdown();
if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
    executor.shutdownNow();
}

Conclusão

O uso de pools de threads melhora a eficiência e desempenho das aplicações Java, reduzindo o custo da criação de threads e otimizando a execução de tarefas concorrentes.

Por que o uso de Thread Pools melhora a eficiência de aplicações Java?

Gerenciar múltiplas threads manualmente pode ser um desafio em aplicações de alto desempenho. O uso de pools de threads evita a criação excessiva de threads e melhora a eficiência na execução de tarefas concorrentes. Dependendo do caso, podemos optar por pools fixos (newFixedThreadPool), dinâmicos (newCachedThreadPool) ou agendados (newScheduledThreadPool).

Algumas aplicações:

• Execução paralela de tarefas em aplicações web
• Processamento eficiente de grandes volumes de dados
• Gerenciamento de múltiplas requisições simultâneas em servidores
• Redução do overhead da criação de novas threads

Dicas para quem está começando

• Prefira newFixedThreadPool(n) para controle sobre o número de threads
• Use shutdown() para liberar recursos após o uso
• Evite criar um número excessivo de threads simultâneas
• Use awaitTermination() para aguardar a conclusão das tarefas antes de finalizar o programa

Compartilhe este tutorial