CKTIS / Java
Condition — wachten op een toestand die door een lock wordt beschermd
Met Condition kan een thread wachten op een wijziging van gedeelde toestand die door een Lock wordt beschermd. Leer await, awaitNanos, signal en signalAll kennen, en waarom je de toestand in een lus moet controleren.
Versie: Java SE 21; repository runtime, production runtime not attested
Syntax
Condition changed = lock.newCondition();
changed.await();
long remaining = changed.awaitNanos(nanosTimeout);
changed.signal();
changed.signalAll();Condition stelt een wachtrij voor die bij een Lock hoort, geen booleaanse waarde. Maak deze aan met lock.newCondition(). Eén lock kan meerdere van zulke wachtrijen hebben, bijvoorbeeld voor een lege en een volle buffer.
Condition.await geeft de lock tijdens het wachten atomair vrij en verkrijgt deze opnieuw voordat de methode terugkeert. Controleer de toestand in een while-lus, omdat schijnbare ontwakingen mogelijk zijn. Condition.awaitNanos accepteert nanoseconden en retourneert een schatting van de resterende tijd. Geef die waarde door aan de volgende wachtpoging in plaats van de time-out opnieuw te starten. Een resultaat <= 0 betekent dat er geen tijd meer over is. Beide methoden kunnen InterruptedException gooien en de interruptstatus wissen. Geef de uitzondering door of herstel de status als je deze opvangt.
Condition.signal wekt één wachtende thread, terwijl Condition.signalAll ze allemaal wekt. Signaleren draagt de lock niet over: een gewekte thread moet deze opnieuw verkrijgen. Bij ReentrantLock moet de aanroepende thread de lock vasthouden bij het aanroepen van een wacht- of signaleringsmethode. Een aanroep van signal() of signalAll() zonder de lock vast te houden gooit IllegalMonitorStateException. In de implementatie van ReentrantLock in JDK 21 controleren await() en awaitNanos() eerst de interruptstatus en pas daarna of de thread de lock vasthoudt. Als de interruptstatus bij de aanroep al is ingesteld, gooien ze InterruptedException, ook als de thread de lock niet vasthoudt. Als die status niet is ingesteld, gooit een aanroep zonder lock IllegalMonitorStateException. Geef de lock altijd vrij in finally.
Controleer en wijzig de beschermde toestand onder dezelfde lock. Het voorbeeld drukt ready af, ongeacht of publish wordt uitgevoerd voordat het wachten begint: de toestand ready blijft behouden, niet het signaal. Deze vermelding behandelt Java SE 21; noch de repository, noch de productieomgeving is bevestigd.
Voorbeelden
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionDemo {
private final ReentrantLock lock = new ReentrantLock();
private final Condition changed = lock.newCondition();
private boolean ready;
void awaitReady() throws InterruptedException {
lock.lock();
try {
while (!ready) {
changed.await();
}
} finally {
lock.unlock();
}
}
void publish() {
lock.lock();
try {
ready = true;
changed.signalAll();
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
ConditionDemo demo = new ConditionDemo();
Thread producer = new Thread(demo::publish);
producer.start();
demo.awaitReady();
producer.join();
System.out.println("ready");
}
}Resultaat
ready
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.