WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Object.wait() und Object.notifyAll(): auf eine Bedingung warten

Schütze den gemeinsamen Zustand mit einem Monitor, prüfe die Bedingung in einer `while`-Schleife und beachte, dass `notifyAll()` die Sperre weder freigibt noch überträgt.

Version: 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() und notify() sind Instanzmethoden von java.lang.Object. Rufe sie auf genau dem Objekt lock auf, dessen Monitor der aktuelle Thread hält, etwa in synchronized (lock). Der Monitor eines anderen Objekts genügt nicht: Ohne den Monitor des Objekts, auf dem die Methode aufgerufen wird, entsteht eine IllegalMonitorStateException.

Hält der aktuelle Thread den Monitor von lock und ist sein Unterbrechungsstatus beim Aufruf von lock.wait() bereits gesetzt, löscht die Methode diesen Status und löst eine InterruptedException aus, ohne den Thread in die Wartemenge aufzunehmen oder den Monitor freizugeben. Andernfalls nimmt lock.wait() den aktuellen Thread in die Wartemenge von lock auf und gibt nur diesen Monitor auf allen Ebenen der reentranten Sperre frei. Andere Monitore bleiben gesperrt. Der wartende Thread muss den Monitor mit der vorherigen Sperrtiefe erneut erwerben, bevor wait() zurückkehrt oder wegen einer Unterbrechung des Wartens eine Ausnahme auslöst. notifyAll() weckt alle Threads in dieser Wartemenge; notify() wählt einen beliebigen aus, falls jemand wartet. Keine der Methoden gibt die Sperre frei, überträgt sie oder speichert eine Benachrichtigung für später. Geweckte Threads konkurrieren nach der Freigabe um den Monitor, ohne garantierte Reihenfolge.

Lies und ändere den gemeinsamen Zustand unter demselben Monitor. Rufe nach der Änderung und vor der Freigabe notifyAll() auf. Verwende while (!ready) { lock.wait(); }, nicht if: Ein Thread kann grundlos aufwachen, oder ein anderer Thread kann die Bedingung ändern, bevor der Wartende den Monitor erneut erwirbt. Eine Benachrichtigung ist ein Anlass zur erneuten Prüfung, kein Beweis dafür, dass die Bedingung erfüllt ist. Freigabe und späterer Erwerb desselben Monitors machen die geschützten Änderungen sichtbar.

wait() hat kein Zeitlimit. wait(long timeoutMillis) erwartet Millisekunden, wait(long timeoutMillis, int nanos) zusätzlich Nanosekunden von 0 bis 999999. Sind alle Argumente null, gilt kein Zeitlimit; negative Millisekunden oder Nanosekunden außerhalb des Bereichs führen zu IllegalArgumentException. Berechne für ein Zeitlimit der gesamten Schleife die verbleibende Zeit neu. Löst wait() eine InterruptedException aus, wird der Unterbrechungsstatus gelöscht. Gib die Ausnahme weiter oder stelle den Status wieder her, wenn du den Vorgang ohne Weitergabe beendest.

Beispiele

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();
    }
}

Ergebnis

ready

Der Hauptthread startet den zweiten Thread, während er `lock` hält. Erst wenn `wait()` diesen Monitor freigibt, kann der zweite Thread `ready` setzen. Nach dem erneuten Erwerb prüft der Hauptthread die Bedingung noch einmal. Das Programm gibt eine Zeile aus: `ready`.

Zugehörige Lektionen

  • Java · Lektion 28 · Fortgeschritten · Version: 2

Quellen