CKTIS / Java
CountDownLatch em Java: construtor, await e countDown
Usa um contador de utilização única para dar o sinal de partida ou esperar por um número fixo de sinais. Aprende as duas sobrecargas de await, as regras de interrupção e a visibilidade das escritas.
Versão: Java SE 21
Sintaxe
Java SE 21 — java.util.concurrent.CountDownLatch
public CountDownLatch(int count)
public void await() throws InterruptedException
public boolean await(long timeout, TimeUnit unit) throws InterruptedException
public void countDown()Em Java SE 21, java.util.concurrent.CountDownLatch é um mecanismo de sincronização de utilização única. O construtor CountDownLatch(int) define o número de sinais, não o número de threads: uma thread pode assinalar vários eventos. Com 0, a passagem começa aberta; um valor negativo lança IllegalArgumentException. CountDownLatch.countDown reduz um contador positivo em uma unidade sem esperar pelos outros sinais. A transição para zero liberta todas as threads em espera sem determinar a ordem em que retomam a execução. A zero, as chamadas seguintes a countDown() não têm efeito. O contador não pode ser reposto; usa uma nova instância para outro ciclo.
CountDownLatch.await tem duas sobrecargas. await() tem tipo de retorno void e espera sem limite de tempo se o contador for positivo. await(long timeout, TimeUnit unit) devolve true se o contador estiver ou chegar a zero, ou false se o prazo terminar antes. Um prazo igual ou inferior a zero verifica o estado sem esperar. Ambas as sobrecargas lançam InterruptedException e limpam o estado de interrupção se estiver ativo à entrada ou se a thread for interrompida enquanto espera. Caso contrário, a zero, retornam de imediato.
O par CountDownLatch.await/countDown garante a visibilidade dos dados. As ações anteriores a um countDown() que reduz o contador estão numa relação happens-before com as ações de outra thread após um retorno bem-sucedido de await() ou após obter true da variante com prazo na mesma instância. Um resultado false não dá essa garantia. Este mecanismo não garante exclusão mútua.
Usa um contador separado para cada condição. start = 1 autoriza o arranque comum; done = 3 recolhe três sinais de conclusão. Para dois grupos, define immediateReady = 2 e deferredReady = 4. Cada participante sinaliza uma vez que está pronto no seu grupo, e o primeiro grupo só pode avançar quando o coordenador abrir a passagem separada releaseImmediate = 1. Quando os dois contadores de prontidão chegam a zero, sabes, sem Thread.sleep, que houve pelo menos dois sinais do primeiro grupo e pelo menos quatro do segundo, mas não que as threads já estejam bloqueadas. Com um sinal por participante, só se garantem exatamente dois e quatro sinais se os grupos tiverem, por definição independente dos contadores, dois e quatro participantes, respetivamente. Para coordenar a ocupação de um recurso, usa dois contadores com 1: um confirma a aquisição, o outro dá o sinal para libertar o recurso.
Se faltar um sinal, uma thread pode ficar à espera indefinidamente. Se contares tentativas concluídas, incluindo as que falharam, chama countDown() em finally e comunica as falhas em separado. Zero confirma a receção dos sinais necessários, não o sucesso do trabalho.
Exemplos
import java.util.Arrays;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class LatchDemo {
public static void main(String[] args) throws InterruptedException {
int[] results = new int[3];
int[] input = new int[1];
CountDownLatch start = new CountDownLatch(1);
CountDownLatch done = new CountDownLatch(3);
for (int i = 0; i < results.length; i++) {
int slot = i;
new Thread(() -> {
try {
start.await();
results[slot] = input[0] + slot;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
done.countDown();
}
}).start();
}
System.out.println("Start open: " + start.await(0, TimeUnit.SECONDS));
input[0] = 10;
start.countDown();
done.await();
System.out.println("Results: " + Arrays.toString(results));
done.countDown();
System.out.println("Done open: " + done.await(0, TimeUnit.SECONDS));
}
}Resultado
Start open: false Results: [10, 11, 12] Done open: true
Só `main` escreve na consola. Primeiro verifica que a passagem está fechada, depois escreve `10` e abre `start`. Cada thread escreve na sua própria posição do array. Depois de `done.await()`, essas escritas são visíveis para `main`; a chamada extra a `done.countDown()` não volta a fechar a passagem.
Lições relacionadas
- Java · Lição 34 · Avançado · Versão: 2
- Java · Lição 36 · Avançado · Versão: 2
- Java · Lição 58 · Intermédio · Versão: 2