Utilizando CountDownLatch para Sincronização de Threads em Java
A sincronização de threads é fundamental para garantir que aplicações Java multithreaded sejam seguras e eficientes. Uma das ferramentas proporcionadas pela API de concorrência do Java para auxiliar nesse controle é o CountDownLatch. Este post detalhará o uso e os cenários ideais para implementar o CountDownLatch, acompanhado de exemplos práticos de código.
O que é CountDownLatch?
O CountDownLatch é uma classe de sincronização que permite a uma ou mais threads esperar até que um conjunto de operações sendo executado em outras threads seja completado. Ele é inicializado com um dado número de "contagens" que são decrementadas à medida que as threads completam suas tarefas. Quando a contagem chega a zero, todas as threads que estavam esperando são liberadas para continuar a execução.
Como funciona o CountDownLatch
A principal operação do CountDownLatch é o método countDown(), que é chamado para decrementar a contagem atual, e o método await(), que bloqueia a thread até que a contagem alcance zero. Vamos ver um exemplo prático:
import java.util.concurrent.CountDownLatch;
public class ServiceLoader {
private final CountDownLatch latch;
public ServiceLoader(int count) {
this.latch = new CountDownLatch(count);
}
public void loadService() {
new Thread(() -> {
try {
// Simula o carregamento de serviço
Thread.sleep(1000);
System.out.println("Serviço carregado");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
latch.countDown();
}
}).start();
}
public void awaitServices() throws InterruptedException {
latch.await();
System.out.println("Todos os serviços foram carregados.");
}
public static void main(String[] args) throws InterruptedException {
ServiceLoader loader = new ServiceLoader(3);
loader.loadService();
loader.loadService();
loader.loadService();
loader.awaitServices();
}
}Neste exemplo, três serviços são carregados em paralelo, e o método awaitServices só prosseguirá após todos os serviços estarem carregados.
Aqui está o log da execução:
Serviço carregado
Serviço carregado
Serviço carregado
Todos os serviços foram carregados.Quando usar o CountDownLatch?
O CountDownLatch é ideal em situações onde uma ou mais threads precisam esperar por um conjunto de operações a serem completadas antes de prosseguir. É comum seu uso em:
-
Aplicações que necessitam de inicialização de múltiplos recursos externos antes de prosseguir;
-
Esperar por etapas de preparação em testes concorrentes.
Outras formas de fazer a sincronização
Embora o foco deste post seja o CountDownLatch, é importante saber que o Java fornece outras classes que auxiliam na coordenação entre threads, como Phaser e CyclicBarrier. Para mais detalhes sobre essas ferramentas, você pode consultar os posts Explorando Phaser e Implementando sincronização de threads em Java com CyclicBarrier aqui no blog.
Conclusão
O CountDownLatch é uma ferramenta poderosa para o controle de execução em ambientes multithreaded, permitindo que diversas operações sejam sincronizadas de maneira simples e eficaz. Seu uso facilita o desenvolvimento de aplicações que dependem da conclusão de outras tarefas antes de continuar a execução. Experimente integrar o CountDownLatch em seus projetos para melhorar a robustez e a confiabilidade das suas aplicações Java.
