CKTIS / Java
Condition: wachten en signaleren in Java
Wacht in een lus op een toestandswijziging, gebruik het resterende tijdsbudget in nanoseconden opnieuw en kies of je één of alle wachtende threads wekt.
Versie: Java SE 21
Syntax
Java SE 21 — java.util.concurrent.locks.Condition
Condition changed = lock.newCondition();
// Condition method declarations:
void await() throws InterruptedException;
long awaitNanos(long nanosTimeout) throws InterruptedException;
void signal();
void signalAll();
// Distinct timed overload of await:
boolean await(long time, TimeUnit unit) throws InterruptedException;Maak een Condition met lock.newCondition(). Bij ReentrantLock moet de aanroepende thread voor elk van deze vier methoden het bijbehorende slot vasthouden. Een aanroep zonder het slot leidt tot een IllegalMonitorStateException, maar in JDK 21 controleren await() en awaitNanos(long) eerst de interruptstatus van de aanroepende thread. Als die al is ingesteld, gooien ze in plaats daarvan een InterruptedException. Controleer en wijzig de gedeelde toestand onder hetzelfde slot en roep unlock() aan in finally.
Condition.await() wacht zonder tijdslimiet. De methode geeft het bijbehorende slot atomair vrij en verkrijgt het opnieuw voordat ze terugkeert. Wacht in een while-lus zolang de toestand niet aan je voorwaarde voldoet: een thread kan zonder signaal wakker worden, of een andere thread kan de toestand wijzigen voordat je het slot terugkrijgt. await() en awaitNanos(long) kunnen InterruptedException gooien; daarbij wordt de interruptstatus gewist.
Condition.awaitNanos(long) neemt een tijdsbudget in nanoseconden en geeft na het opnieuw verkrijgen van het slot een schatting van de resterende nanoseconden terug. Controleer in de lus eerst de gedeelde toestand. Voldoet die nog niet aan je voorwaarde, stop dan met wachten bij remaining <= 0L; gebruik anders remaining = changed.awaitNanos(remaining). Zet het budget niet terug op de beginwaarde. De overload await(long, TimeUnit) geeft een boolean terug, geen restbudget.
Bij ReentrantLock geeft ook een ononderbroken aanroep van awaitNanos(0L) het slot volledig vrij, verkrijgt het opnieuw en herstelt het oorspronkelijke aantal keren dat de thread het slot had verkregen. Er is geen positief wachtbudget, maar het slot opnieuw verkrijgen kan tijd kosten. De uitkomst is niet positief; neem niet aan dat ze precies nul is.
Werk eerst de gedeelde toestand bij. Condition.signal() selecteert dan hoogstens één wachtende thread; Condition.signalAll() wekt iedereen die op dezelfde Condition wacht, ook met awaitNanos. Geen van beide geeft het slot meteen door of bewaart een signaal voor toekomstige wachtenden. Elke gewekte thread moet het slot opnieuw verkrijgen en de toestand opnieuw controleren. Gebruik signal() als het voldoende is om één willekeurige wachtende te wekken, en signalAll() als meerdere verder kunnen of als je niet weet welke verder kan.
Voorbeelden
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
private static final ReentrantLock lock = new ReentrantLock();
private static final Condition arrived = lock.newCondition();
private static final Condition gate = lock.newCondition();
private static int ready;
private static int passed;
private static boolean open;
private static void waitAtGate() {
lock.lock();
try {
ready++;
arrived.signal();
while (!open) {
gate.await();
}
passed++;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
Thread first = new Thread(Main::waitAtGate);
Thread second = new Thread(Main::waitAtGate);
lock.lock();
try {
lock.lock();
try {
long remaining = gate.awaitNanos(0L);
System.out.println("budget exhausted: " + (remaining <= 0L));
System.out.println("hold count: " + lock.getHoldCount());
} finally {
lock.unlock();
}
first.start();
second.start();
while (ready < 2) {
arrived.await();
}
open = true;
gate.signalAll();
System.out.println("gate opened");
} finally {
lock.unlock();
}
first.join();
second.join();
System.out.println("workers passed: " + passed);
}
}Resultaat
budget exhausted: true hold count: 2 gate opened workers passed: 2
De eerste test toont alleen de uitkomst van de tekenvergelijking en dat het aantal verkrijgingen op 2 is hersteld. Elke werkthread meldt zich met `arrived.signal()`. De hoofdthread opent vervolgens het hek en roept `gate.signalAll()` aan. De volgorde van de threads verandert de uitvoer niet.
Gerelateerde lessen
- Java · Les 30 · Gevorderd · Versie: 2
- Java · Les 54 · Gemiddeld · Versie: 2