Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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

Fontes