Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

CountDownLatch en Java : constructeur, await et countDown

Utilisez un compteur à usage unique pour autoriser un départ ou attendre un nombre fixé de signaux. Découvrez les deux surcharges de await, la gestion des interruptions et la visibilité des écritures.

Version : Java SE 21

Syntaxe

Java SE 21 — java.util.concurrent.CountDownLatch
public CountDownLatch(int count)
public void await() throws InterruptedException
public boolean await(long timeout, TimeUnit unit) throws InterruptedException
public void countDown()

Dans Java SE 21, java.util.concurrent.CountDownLatch est un mécanisme de synchronisation à usage unique. Le constructeur CountDownLatch(int) fixe le nombre de signaux, pas le nombre de threads : un même thread peut signaler plusieurs événements. La valeur 0 ouvre le verrou dès sa création ; une valeur négative déclenche IllegalArgumentException. CountDownLatch.countDown décrémente un compteur positif sans attendre les autres signaux. Le passage à zéro libère tous les threads en attente, sans imposer leur ordre de reprise. À zéro, les appels suivants à countDown() sont sans effet. Le compteur ne se réinitialise pas : créez une nouvelle instance pour un autre cycle.

CountDownLatch.await a deux surcharges. await() a pour type de retour void et attend sans limite de temps si le compteur est positif. await(long timeout, TimeUnit unit) renvoie true si le compteur est ou devient nul, ou false si le délai expire avant. Un délai nul ou négatif permet de tester sans attendre. Les deux surcharges lèvent InterruptedException et effacent l'état d'interruption s'il est déjà activé à l'appel ou si le thread est interrompu pendant l'attente. Sinon, à zéro, elles retournent immédiatement.

La paire CountDownLatch.await/countDown garantit la visibilité des données. Les actions précédant un countDown() qui décrémente le compteur sont en relation happens-before avec les actions d'un autre thread après un retour réussi de await() ou après un résultat true de la version temporisée sur la même instance. Un résultat false n'offre pas cette garantie. Ce mécanisme n'assure pas l'exclusion mutuelle.

Utilisez un compteur distinct par condition. start = 1 autorise un départ commun ; done = 3 recueille trois signaux de fin. Pour deux groupes, fixez immediateReady = 2 et deferredReady = 4. Chaque participant signale une fois qu'il est prêt dans son groupe, et le premier groupe ne peut avancer que lorsque le coordinateur ouvre le verrou distinct releaseImmediate = 1. Quand les deux compteurs de préparation atteignent zéro, vous savez sans Thread.sleep qu'au moins deux signaux ont été émis dans le premier groupe et au moins quatre dans le second, mais pas que les threads sont déjà bloqués. À raison d'un signal par participant, les totaux exacts de deux et quatre ne sont garantis que si les effectifs des groupes sont fixés indépendamment des compteurs à deux et quatre participants, respectivement. Pour coordonner l'occupation d'une ressource, utilisez deux compteurs à 1 : l'un confirme l'acquisition, l'autre autorise la libération.

Un signal manquant peut laisser un thread attendre indéfiniment. Si vous comptez les tentatives terminées, échecs compris, appelez countDown() dans finally et signalez les échecs séparément. Zéro confirme la réception des signaux requis, pas la réussite du travail.

Exemples

import java.util.Arrays;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class LatchDemo {
    public static void main(String[] args) throws InterruptedException {
        int[] results = new int[3];
        int[] input = new int[1];
        CountDownLatch start = new CountDownLatch(1);
        CountDownLatch done = new CountDownLatch(3);

        for (int i = 0; i < results.length; i++) {
            int slot = i;
            new Thread(() -> {
                try {
                    start.await();
                    results[slot] = input[0] + slot;
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    done.countDown();
                }
            }).start();
        }

        System.out.println("Start open: " + start.await(0, TimeUnit.SECONDS));
        input[0] = 10;
        start.countDown();
        done.await();
        System.out.println("Results: " + Arrays.toString(results));
        done.countDown();
        System.out.println("Done open: " + done.await(0, TimeUnit.SECONDS));
    }
}

Résultat

Start open: false
Results: [10, 11, 12]
Done open: true

Seul `main` affiche une sortie. Il teste d'abord le verrou fermé, puis écrit `10` et ouvre `start`. Chaque thread écrit dans sa propre case du tableau. Après `done.await()`, ces écritures sont visibles par `main` ; l'appel supplémentaire à `done.countDown()` ne referme pas le verrou.

Leçons associées

  • Java · Leçon 34 · Avancé · Version : 2
  • Java · Leçon 36 · Avancé · Version : 2
  • Java · Leçon 58 · Intermédiaire · Version : 2

Sources