Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

CyclicBarrier — sincronizzazione ciclica dei thread

CyclicBarrier sincronizza un numero fisso di partecipanti ai confini di fasi successive. La chiamata a await() attende gli altri; un’azione facoltativa combina i risultati prima che inizi la fase successiva.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

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 di java.util.concurrent è un punto di sincronizzazione riutilizzabile. A differenza di CountDownLatch, utilizzabile una sola volta, supporta cicli successivi. Il suo costruttore richiede parties >= 1.

CyclicBarrier.await() attende tutti i partecipanti e restituisce un indice di arrivo: l’ultimo riceve 0. L’ultimo thread esegue l’azione facoltativa prima di rilasciare gli altri. Le scritture precedenti a await() sono visibili all’azione; le azioni di quest’ultima sono visibili dopo il ritorno riuscito dei partecipanti.

Un’interruzione o il superamento del limite di tempo interrompe la barriera: il partecipante interessato riceve InterruptedException o TimeoutException, mentre gli altri partecipanti in attesa ricevono normalmente BrokenBarrierException. Anche reset() interrompe l’attesa; il ripristino richiede coordinamento. Assicurati che tutti i partecipanti possano essere eseguiti per evitare un’attesa indefinita.

L’esempio usa due thread e due cicli. Ogni thread scrive nel proprio elemento dell’array; l’azione stampa la somma. Ambito: Java SE 21; l’ambiente di esecuzione in produzione non è stato attestato.

Esempi

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();
        }
    }
}

Risultato

3
6

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti