CKTIS / Java
CountDownLatch in Java: constructor, await en countDown
Gebruik een eenmalige teller om het startsein te geven of op een vast aantal signalen te wachten. Leer de twee varianten van await, de regels voor onderbrekingen en de garantie op zichtbaarheid van gegevens.
Versie: 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 is java.util.concurrent.CountDownLatch een eenmalig synchronisatiemiddel. De constructor CountDownLatch(int) stelt het aantal signalen in, niet het aantal threads: één thread kan meerdere gebeurtenissen melden. Bij 0 is de poort meteen open; een negatieve waarde veroorzaakt IllegalArgumentException. CountDownLatch.countDown verlaagt een positieve teller met één zonder op andere signalen te wachten. Zodra de teller nul bereikt, worden alle wachtende threads vrijgegeven, zonder vaste volgorde van hervatting. Bij nul doen volgende aanroepen van countDown() niets. De teller kan niet worden gereset; gebruik voor een nieuwe ronde een nieuwe instantie.
CountDownLatch.await heeft twee overbelastingen. await() heeft retourtype void en wacht zonder tijdslimiet als de teller positief is. await(long timeout, TimeUnit unit) geeft true terug als de teller nul is of wordt, of false als de wachttijd eerder verstrijkt. Met een tijdslimiet van nul of minder controleer je zonder te wachten. Beide varianten gooien InterruptedException en wissen de interruptstatus als die bij binnenkomst al is ingesteld of de thread tijdens het wachten wordt onderbroken. Anders keren ze bij nul meteen terug.
De combinatie CountDownLatch.await/countDown biedt een zichtbaarheidsgarantie. Acties vóór een countDown() die de teller verlaagt, staan in een happens-before-relatie tot acties in een andere thread na een geslaagde terugkeer uit await() of na true van de variant met tijdslimiet op dezelfde instantie. Een uitkomst false biedt die garantie niet. De poort zorgt niet voor wederzijdse uitsluiting.
Gebruik voor elke voorwaarde een aparte latch. start = 1 geeft de gezamenlijke start vrij; done = 3 verzamelt drie voltooiingssignalen. Stel voor twee groepen immediateReady = 2 en deferredReady = 4 in. Elke deelnemer meldt zich één keer klaar bij de eigen groep, en de eerste groep kan pas verder als de coördinator de aparte poort releaseImmediate = 1 opent. Zodra beide gereedheidstellers nul bereiken, weet je zonder Thread.sleep dat er minstens twee gereedmeldingen uit de eerste groep en minstens vier uit de tweede zijn gekomen, maar niet of de threads al geblokkeerd zijn. Bij één melding per deelnemer zijn precies twee en vier meldingen alleen gegarandeerd als de groepsgroottes los van de tellers zijn vastgelegd op respectievelijk twee en vier deelnemers. Gebruik bij het bezet houden van een resource twee tellers van 1: de ene bevestigt dat de resource in gebruik is, de andere geeft het signaal om die vrij te geven.
Als een signaal ontbreekt, kan een thread onbeperkt blijven wachten. Tel je beëindigde pogingen, ook de mislukte, roep dan countDown() aan in finally en meld fouten apart. Nul bevestigt dat de vereiste signalen zijn aangekomen, niet dat het werk is gelukt.
Voorbeelden
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));
}
}Resultaat
Start open: false Results: [10, 11, 12] Done open: true
Alleen `main` schrijft naar de console. Het controleert eerst de gesloten poort, schrijft dan `10` en opent `start`. Elke worker schrijft naar een eigen plek in de array. Na `done.await()` zijn die schrijfacties zichtbaar voor `main`; de extra `done.countDown()` sluit de poort niet.
Gerelateerde lessen
- Java · Les 34 · Gevorderd · Versie: 2
- Java · Les 36 · Gevorderd · Versie: 2
- Java · Les 58 · Gemiddeld · Versie: 2