CKTIS / Java
Object.wait() en Object.notifyAll(): wachten op een voorwaarde
Bescherm gedeelde toestand met dezelfde monitor, toets de voorwaarde opnieuw in een `while`-lus en onthoud dat `notifyAll()` de vergrendeling niet vrijgeeft of overdraagt.
Versie: Java SE 21
Syntax
java.lang.Object instance methods (Java SE 21):
public final void wait() throws InterruptedException
public final void wait(long timeoutMillis) throws InterruptedException
public final void wait(long timeoutMillis, int nanos) throws InterruptedException
public final void notifyAll()
public final void notify()
Waiting thread: synchronized (lock) { while (!ready) { lock.wait(); } }
Signalling thread: synchronized (lock) { ready = true; lock.notifyAll(); }wait(), notifyAll() en notify() zijn instantiemethoden van java.lang.Object. Roep ze aan op hetzelfde object lock waarvan de huidige thread de monitor bezit, bijvoorbeeld binnen synchronized (lock). De monitor van een ander object bezitten volstaat niet: zonder de monitor van het object waarop je de methode aanroept, krijg je IllegalMonitorStateException.
Als de huidige thread de monitor van lock bezit en zijn interruptstatus al gezet is wanneer hij lock.wait() aanroept, wist de methode die status en werpt ze InterruptedException zonder de thread aan de wachtverzameling toe te voegen of de monitor vrij te geven. Anders voegt lock.wait() de huidige thread toe aan de wachtverzameling van lock en geeft alleen die monitor op alle re-entrante niveaus vrij. Andere monitors blijven vergrendeld. De wachtende thread moet de monitor met de oorspronkelijke vergrendelingsdiepte terugkrijgen voordat wait() terugkeert of een exceptie werpt omdat het wachten is onderbroken. notifyAll() wekt alle threads in die verzameling; notify() kiest er willekeurig één als er threads wachten. Geen van beide geeft de vergrendeling vrij, draagt haar over of bewaart een melding voor later. Gewekte threads concurreren na vrijgave om de monitor, zonder gegarandeerde volgorde.
Lees en wijzig gedeelde toestand onder dezelfde monitor. Roep na de wijziging en vóór het vrijgeven notifyAll() aan. Gebruik while (!ready) { lock.wait(); }, niet if: een thread kan spontaan ontwaken, of een andere thread kan de voorwaarde wijzigen voordat de wachtende thread de monitor terugkrijgt. Een melding is een reden om opnieuw te toetsen, geen bewijs dat de voorwaarde waar is. Het vrijgeven en later verkrijgen van dezelfde monitor maakt de beschermde wijzigingen zichtbaar.
wait() heeft geen tijdslimiet. wait(long timeoutMillis) neemt milliseconden aan en wait(long timeoutMillis, int nanos) ook extra nanoseconden van 0 tot 999999. Zijn alle argumenten nul, dan is er geen tijdslimiet; negatieve milliseconden of nanoseconden buiten het bereik leiden tot IllegalArgumentException. Bereken de resterende tijd telkens opnieuw als de limiet voor de hele lus geldt. Als wait() InterruptedException werpt, wordt de interruptstatus gewist. Geef de exceptie door of herstel de status als je de bewerking beëindigt zonder haar door te geven.
Voorbeelden
public final class WaitNotifyDemo {
private final Object lock = new Object();
private boolean ready;
private void makeReady() {
synchronized (lock) {
ready = true;
lock.notifyAll();
}
}
private void runDemo() throws InterruptedException {
Thread publisher = new Thread(this::makeReady);
synchronized (lock) {
publisher.start();
while (!ready) {
lock.wait();
}
}
publisher.join();
System.out.println("ready");
}
public static void main(String[] args) throws InterruptedException {
new WaitNotifyDemo().runDemo();
}
}Resultaat
ready
De hoofdthread start de tweede thread terwijl hij `lock` bezit. De tweede thread kan `ready` pas op waar zetten als `wait()` die monitor vrijgeeft. Nadat de hoofdthread de monitor heeft teruggekregen, toetst hij de voorwaarde opnieuw. Het programma drukt één regel af: `ready`.
Gerelateerde lessen
- Java · Les 28 · Gevorderd · Versie: 2