CKTIS / Java
CyclicBarrier: azione della barriera e metodo await
Sincronizza un numero fisso di thread tra due fasi, esegui un’azione comune prima che proseguano e distingui l’attesa con limite di tempo da quella senza limite.
Versione: Java SE 21
Sintassi
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);In Java SE 21, java.util.concurrent.CyclicBarrier sincronizza un numero fisso di thread al passaggio tra due fasi. Il costruttore CyclicBarrier(int,Runnable) riceve il numero di partecipanti e un’azione facoltativa. Un numero inferiore a 1 causa IllegalArgumentException. Passare null o usare CyclicBarrier(int) significa non impostare alcuna azione.
Il metodo di istanza CyclicBarrier.await, nella forma senza argomenti await(), attende tutti i partecipanti senza un limite di tempo. L’ultimo thread ad arrivare esegue l’azione una volta per ciclo, prima che qualunque chiamata possa terminare normalmente. Il risultato int è l’indice di arrivo: parties - 1 per il primo e 0 per l’ultimo. Il blocco if (barrier.await() == 0) viene eseguito dopo lo sblocco del gruppo, quindi non sostituisce un’azione che deve terminare prima che gli altri thread proseguano.
Il lavoro svolto prima di await() precede l’azione della barriera secondo la relazione happens-before. L’azione precede a sua volta il lavoro degli altri thread dopo il ritorno normale dalla chiamata corrispondente. Dopo un ciclo riuscito, la stessa barriera è pronta per il successivo senza chiamare reset().
await(long timeout, TimeUnit unit) limita l’attesa. Se il tempo scade, il chiamante riceve TimeoutException e la barriera si rompe. Se await gestisce un’interruzione mentre il ciclo del thread è ancora in corso e la barriera non è rotta, lancia InterruptedException, azzera lo stato di interruzione del thread e rompe la barriera. Se invece il ciclo si conclude con successo e la barriera passa al successivo prima che il thread in attesa gestisca l’interruzione, await può restituire l’indice di arrivo con lo stato di interruzione impostato, ripristinandolo se necessario. Un’eccezione nell’azione si propaga all’ultimo arrivato e rompe la barriera. Gli altri thread in attesa ricevono in genere BrokenBarrierException, come le chiamate su una barriera già rotta. reset() ripristina lo stato iniziale, ma fa fallire le attese in corso con BrokenBarrierException: occorre quindi coordinare il ripristino.
Esempi
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();
}
}
}
}Risultato
Phase 1 Phase 1 Phase 1 4: Barrier action Phase 2 Phase 2 Phase 2
Tre attività usano tre thread del pool e attraversano la barriera una sola volta. `4: Barrier action` è la quarta riga dell’output, non un quarto partecipante. In ogni fase le attività stampano lo stesso testo, quindi l’ordine di esecuzione non cambia l’output.
Lezioni correlate
- Java · Lezione 34 · Avanzato · Versione: 2