WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

CountDownLatch in Java: Konstruktor, await und countDown

Mit einem einmaligen Zähler gibst du den Start frei oder wartest auf eine feste Anzahl von Signalen. Hier lernst du beide await-Überladungen, die Unterbrechungsregeln und die Sichtbarkeitsgarantie kennen.

Version: Java SE 21

Syntax

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

In Java SE 21 dient java.util.concurrent.CountDownLatch zur einmaligen Synchronisation. Der Konstruktor CountDownLatch(int) legt die Anzahl der Signale fest, nicht die Anzahl der Threads: Ein Thread kann mehrere Ereignisse melden. Mit 0 ist die Schranke sofort offen; ein negativer Wert löst IllegalArgumentException aus. CountDownLatch.countDown verringert einen positiven Zähler um eins, ohne auf andere Signale zu warten. Beim Übergang auf null werden alle wartenden Threads freigegeben, ohne ihre Ausführungsreihenfolge festzulegen. Bei null bleiben weitere Aufrufe von countDown() wirkungslos. Der Zähler lässt sich nicht zurücksetzen; für einen weiteren Durchlauf brauchst du eine neue Instanz.

CountDownLatch.await hat zwei Überladungen. await() hat den Rückgabetyp void und wartet bei positivem Zähler ohne Zeitlimit. await(long timeout, TimeUnit unit) liefert true, wenn der Zähler null ist oder null erreicht, und false, wenn vorher die Wartezeit abläuft. Ein nichtpositives Zeitlimit prüft ohne zu warten. Beide Überladungen werfen InterruptedException und löschen den Unterbrechungsstatus, wenn er beim Aufruf gesetzt ist oder der Thread beim Warten unterbrochen wird. Andernfalls kehren sie bei null sofort zurück.

Das Zusammenspiel von CountDownLatch.await/countDown garantiert Sichtbarkeit. Aktionen vor einem countDown(), das den Zähler verringert, stehen in einer happens-before-Beziehung zu Aktionen eines anderen Threads nach erfolgreicher Rückkehr aus await() oder nach true bei der Variante mit Zeitlimit auf derselben Instanz. false gibt diese Garantie nicht. Die Schranke bietet keinen gegenseitigen Ausschluss.

Verwende für jede Bedingung eine eigene Instanz. start = 1 gibt den gemeinsamen Start frei; done = 3 sammelt drei Abschlusssignale. Setze für zwei Gruppen immediateReady = 2 und deferredReady = 4. Jeder Teilnehmer meldet einmal die Bereitschaft seiner Gruppe, und die erste Gruppe kommt erst weiter, wenn die Koordination die separate Schranke releaseImmediate = 1 öffnet. Sobald beide Bereitschaftszähler null erreicht haben, weißt du ohne Thread.sleep, dass aus der ersten Gruppe mindestens zwei und aus der zweiten mindestens vier Bereitschaftsmeldungen eingegangen sind. Das beweist aber nicht, dass die Threads schon blockiert sind. Bei einer Meldung pro Teilnehmer sind genau zwei beziehungsweise vier Meldungen nur dann garantiert, wenn die Gruppengrößen unabhängig von den Zählerwerten auf zwei beziehungsweise vier festgelegt sind. Beim Belegen einer Ressource dienen zwei Zähler mit 1 getrennt als Bestätigung der Belegung und als Signal zur Freigabe.

Ein fehlendes Signal kann dazu führen, dass ein Thread unbegrenzt wartet. Zählst du beendete Versuche einschließlich Fehlschlägen, rufe countDown() in finally auf und melde Fehler separat. Null bestätigt die erforderlichen Signale, nicht den Erfolg der Arbeit.

Beispiele

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

Ergebnis

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

Nur `main` gibt etwas aus. Es prüft zuerst die geschlossene Schranke, schreibt dann `10` und öffnet `start`. Jeder Worker schreibt an seinen eigenen Array-Index. Nach `done.await()` sieht `main` diese Schreibzugriffe; das zusätzliche `done.countDown()` schließt die Schranke nicht.

Zugehörige Lektionen

  • Java · Lektion 34 · Fortgeschritten · Version: 2
  • Java · Lektion 36 · Fortgeschritten · Version: 2
  • Java · Lektion 58 · Mittlere Stufe · Version: 2

Quellen