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

CKTIS / Java

CyclicBarrier — sincronização cíclica de threads

CyclicBarrier sincroniza um número fixo de participantes nos limites de fases sucessivas. A chamada a await() espera pelos restantes; uma ação opcional combina os resultados antes de começar a fase seguinte.

Versão: Java SE 21; repository runtime, production runtime not attested

Sintaxe

new CyclicBarrier(int parties)
new CyclicBarrier(int parties, Runnable barrierAction)
int await() throws InterruptedException, BrokenBarrierException
int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException

CyclicBarrier, de java.util.concurrent, é um ponto de sincronização reutilizável. Ao contrário de CountDownLatch, que só pode ser usado uma vez, suporta ciclos sucessivos. O seu construtor exige parties >= 1.

CyclicBarrier.await() espera por todos os participantes e devolve um índice de chegada: o último recebe 0. A última thread executa a ação opcional antes de libertar as restantes. As escritas anteriores a await() são visíveis para a ação, e as ações desta são visíveis depois de os participantes regressarem com sucesso.

Uma interrupção ou o fim do tempo limite quebra a barreira: o participante afetado recebe InterruptedException ou TimeoutException, enquanto os restantes participantes em espera recebem normalmente BrokenBarrierException. reset() também interrompe a espera; a recuperação exige coordenação. Garanta que todos os participantes podem ser executados para evitar uma espera indefinida.

O exemplo utiliza duas threads e dois ciclos. Cada thread escreve no seu próprio elemento do array; a ação apresenta a soma. Âmbito: Java SE 21; o ambiente de execução de produção não foi atestado.

Exemplos

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class BarrierDemo {
    public static void main(String[] args) throws InterruptedException {
        int[] values = new int[2];
        CyclicBarrier barrier = new CyclicBarrier(2,
                () -> System.out.println(values[0] + values[1]));

        Thread[] workers = new Thread[2];
        for (int i = 0; i < workers.length; i++) {
            final int index = i;
            workers[i] = new Thread(() -> {
                try {
                    for (int phase = 1; phase <= 2; phase++) {
                        values[index] = (index + 1) * phase;
                        barrier.await();
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (BrokenBarrierException e) {
                    throw new IllegalStateException(e);
                }
            });
            workers[i].start();
        }
        for (Thread worker : workers) {
            worker.join();
        }
    }
}

Resultado

3
6

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes