CKTIS / Java
Condition: Warten und Signalisieren in Java
Warte in einer Schleife auf eine Zustandsänderung, verwende das verbleibende Zeitbudget in Nanosekunden weiter und wecke einen oder alle wartenden Threads.
Version: 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;Erzeuge eine Condition mit lock.newCondition(). Bei ReentrantLock muss der aufrufende Thread für alle vier hier behandelten Methoden die zugehörige Sperre halten. Ein Aufruf ohne Sperre löst eine IllegalMonitorStateException aus, doch in JDK 21 prüfen await() und awaitNanos(long) zuerst den Interrupt-Status des aufrufenden Threads. Ist er bereits gesetzt, lösen sie stattdessen eine InterruptedException aus. Prüfe und ändere den gemeinsamen Zustand unter dieser Sperre und rufe unlock() in finally auf.
Condition.await() wartet ohne Zeitlimit. Die Methode gibt die zugehörige Sperre atomar frei und erwirbt sie vor der Rückkehr erneut. Warte in einer while-Schleife, solange der benötigte Zustand nicht vorliegt: Ein Thread kann ohne Signal aufwachen, oder ein anderer Thread kann den Zustand ändern, bevor du die Sperre wieder hältst. await() und awaitNanos(long) können eine InterruptedException auslösen; dabei wird der Interrupt-Status gelöscht.
Condition.awaitNanos(long) nimmt ein Zeitbudget in Nanosekunden entgegen und liefert nach dem erneuten Sperrerwerb einen Schätzwert für die verbleibenden Nanosekunden. Prüfe in der Schleife zuerst den gemeinsamen Zustand. Ist die Bedingung weiterhin nicht erfüllt, beende das Warten bei remaining <= 0L; andernfalls verwende remaining = changed.awaitNanos(remaining). Setze das ursprüngliche Budget nicht zurück. Die Überladung await(long, TimeUnit) liefert einen boolean, kein Restbudget.
Bei ReentrantLock gibt auch ein nicht unterbrochener Aufruf von awaitNanos(0L) die Sperre vollständig frei, erwirbt sie erneut und stellt den ursprünglichen Haltezähler wieder her. Es gibt kein positives Wartebudget, aber der erneute Sperrerwerb kann dauern. Das Ergebnis ist nicht positiv; es muss nicht genau null sein.
Ändere zuerst den gemeinsamen Zustand. Condition.signal() wählt dann höchstens einen wartenden Thread aus; Condition.signalAll() weckt alle Threads, die auf dieselbe Condition warten, auch mit awaitNanos. Keine der Methoden übergibt sofort die Sperre oder speichert ein Signal für spätere Wartende. Jeder geweckte Thread muss die Sperre erneut erwerben und den Zustand prüfen. Verwende signal(), wenn ein beliebiger Wartender genügt, und signalAll(), wenn mehrere fortfahren können oder unklar ist, welcher fortfahren kann.
Beispiele
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);
}
}Ergebnis
budget exhausted: true hold count: 2 gate opened workers passed: 2
Zuerst gibt das Programm nur das Ergebnis des Vorzeichentests und den wiederhergestellten Haltezähler 2 aus. Jeder Worker meldet seine Ankunft mit `arrived.signal()`. Der Hauptthread öffnet dann das Tor und ruft `gate.signalAll()` auf. Die Reihenfolge der Worker beeinflusst die Ausgabe nicht.
Zugehörige Lektionen
- Java · Lektion 30 · Fortgeschritten · Version: 2
- Java · Lektion 54 · Mittlere Stufe · Version: 2