CKTIS / Java
CyclicBarrier: ação da barreira e método await
Sincroniza um número fixo de threads entre fases, executa uma ação comum antes de avançarem e distingue a espera com limite de tempo da espera sem limite.
Versão: Java SE 21
Sintaxe
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
CyclicBarrier barrier = new CyclicBarrier(parties, barrierAction);
int arrivalIndex = barrier.await();
// Alternative for an arrival with a time limit:
int timedArrivalIndex = barrier.await(timeout, TimeUnit.SECONDS);Em Java SE 21, java.util.concurrent.CyclicBarrier sincroniza um número fixo de threads na transição entre fases. O construtor CyclicBarrier(int,Runnable) recebe o número de participantes e uma ação opcional. Um valor inferior a 1 lança IllegalArgumentException. Passar null ou usar CyclicBarrier(int) significa que não há ação.
O método de instância CyclicBarrier.await, na forma sem argumentos await(), aguarda por todos os participantes sem limite de tempo. A última thread a chegar executa a ação uma vez por ronda, antes de qualquer chamada terminar com sucesso. O resultado do tipo int é o índice de chegada: parties - 1 para a primeira e 0 para a última. O bloco if (barrier.await() == 0) só é executado após a libertação do grupo, pelo que não substitui uma ação que tenha de terminar antes de as outras threads avançarem.
O trabalho anterior a await() precede a ação da barreira segundo a relação happens-before. Por sua vez, a ação precede o trabalho das outras threads depois de a chamada correspondente terminar com sucesso. Após uma ronda bem-sucedida, a mesma barreira fica automaticamente pronta para a seguinte, sem chamar reset().
await(long timeout, TimeUnit unit) limita a espera. Se o prazo expirar, a thread que fez a chamada recebe TimeoutException e a barreira fica quebrada. Se await tratar uma interrupção enquanto a ronda da thread ainda está em curso e a barreira não está quebrada, lança InterruptedException, limpa o indicador de interrupção da thread e quebra a barreira. Se, pelo contrário, a ronda terminar com sucesso e a barreira passar à seguinte antes de a thread em espera tratar a interrupção, await pode devolver o índice de chegada com o indicador de interrupção ativo, repondo-o se necessário. Uma exceção na ação propaga-se à última thread a chegar e também quebra a barreira. As restantes threads em espera recebem normalmente BrokenBarrierException, tal como as chamadas a uma barreira já quebrada. reset() repõe o estado inicial, mas faz falhar as esperas em curso com BrokenBarrierException, pelo que é necessário coordenar a recuperação.
Exemplos
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
public class BarrierPhases {
public static void main(String[] args) throws InterruptedException, ExecutionException {
int parties = 3;
var barrier = new CyclicBarrier(parties,
() -> System.out.println("4: Barrier action"));
Callable<Void> worker = () -> {
System.out.println("Phase 1");
barrier.await();
System.out.println("Phase 2");
return null;
};
try (var pool = Executors.newFixedThreadPool(parties)) {
for (var result : pool.invokeAll(List.of(worker, worker, worker))) {
result.get();
}
}
}
}Resultado
Phase 1 Phase 1 Phase 1 4: Barrier action Phase 2 Phase 2 Phase 2
Três tarefas usam três threads do pool e atravessam a barreira apenas uma vez. `4: Barrier action` é a quarta linha da saída, não um quarto participante. Em cada fase, todas as tarefas escrevem o mesmo texto, pelo que a ordem de execução não altera a saída.
Lições relacionadas
- Java · Lição 34 · Avançado · Versão: 2