O que é um pool de threads?

O grupo de threads (ThreadPool) é um conjunto de threads de trabalho geridos por uma entidade única que recebe tarefas e as distribui entre os threads disponíveis. Em vez de criar um novo thread para cada tarefa, o grupo reutiliza os existentes.

Vantagens principais:

• Redução de custos: Criar e destruir threads é dispendioso em termos de tempo e recursos. O grupo elimina essa necessidade.
• Gestão de recursos: Limita o número máximo de threads a serem executados simultaneamente, evitando o esgotamento dos recursos do sistema.
• Melhoria de desempenho: Gerencia a fila de tarefas, o que pode aumentar a capacidade de processamento das aplicações.
• Facilidade de gestão: Fornece um mecanismo centralizado para executar tarefas assíncronas.

Em Java, para trabalhar com grupos de threads, usa-se o pacote java.util.concurrent. As interfaces e classes principais:

• Executor: Interface para executar tarefas.
• ExecutorService: Extensão de Executor que fornece métodos para gerir o ciclo de vida do grupo e obter resultados das tarefas.
• Executors: Classe auxiliar para criar implementações padrão de ExecutorService, por exemplo:
  • newFixedThreadPool(int nThreads): Grupo com quantidade fixa de threads.
  • newCachedThreadPool(): Grupo que cria threads conforme necessário e reutiliza as inativas.
  • newSingleThreadExecutor(): Grupo com um único thread de trabalho.
  • newScheduledThreadPool(int corePoolSize): Grupo para executar tarefas agendadas.
• ThreadPoolExecutor: Implementação flexível de ExecutorService que permite ajustar mais finamente o comportamento do grupo.

Exemplo de uso de ExecutorService:

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

// Exemplo de tarefa para executar no grupo
class MyTask implements Runnable {
    private final int taskId;

    public MyTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Executando tarefa " + taskId + " pelo thread " + Thread.currentThread().getName());
        try {
            Thread.sleep(100); // Simulação de trabalho
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class ThreadPoolExample {
    public static void main(String[] args) {
        // Criação do grupo com quantidade fixa de threads
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // Envio de tarefas para execução
        for (int i = 0; i < 10; i++) {
            executorService.submit(new MyTask(i));
        }

        // Encerramento correto do grupo após a execução de todas as tarefas
        executorService.shutdown();
    }
}

O ciclo de vida do grupo é gerido pelos métodos shutdown() e shutdownNow() para uma parada correta.