CKTIS / Java
CyclicBarrier — synchronisation cyclique des threads
CyclicBarrier synchronise un nombre fixe de participants aux limites de phases successives. L’appel à await() attend les autres ; une action facultative regroupe les résultats avant le début de la phase suivante.
Version : Java SE 21; repository runtime, production runtime not attested
Syntaxe
new CyclicBarrier(int parties)
new CyclicBarrier(int parties, Runnable barrierAction)
int await() throws InterruptedException, BrokenBarrierException
int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutExceptionCyclicBarrier de java.util.concurrent est un point de synchronisation réutilisable. Contrairement à CountDownLatch, qui ne s’utilise qu’une fois, elle prend en charge des cycles successifs. Son constructeur exige parties >= 1.
CyclicBarrier.await() attend tous les participants et renvoie un indice d’arrivée : le dernier reçoit 0. Le dernier thread exécute l’action facultative avant de libérer les autres. Les écritures effectuées avant await() sont visibles par l’action, et les actions de celle-ci sont visibles après le retour réussi des participants.
Une interruption ou un dépassement du délai rompt la barrière : le participant concerné reçoit InterruptedException ou TimeoutException, tandis que les autres participants en attente reçoivent généralement BrokenBarrierException. reset() interrompt également l’attente ; le rétablissement nécessite une coordination. Veillez à ce que tous les participants puissent s’exécuter afin d’éviter une attente indéfinie.
L’exemple utilise deux threads et deux cycles. Chaque thread écrit dans son propre élément du tableau ; l’action affiche la somme. Périmètre : Java SE 21 ; l’environnement d’exécution en production n’a pas été attesté.
Exemples
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();
}
}
}Résultat
3 6
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.