CKTIS / Java
Object.wait() e Object.notifyAll(): attendere una condizione
Proteggi lo stato condiviso con lo stesso monitor, ricontrolla la condizione in un ciclo `while` e ricorda che `notifyAll()` non rilascia né trasferisce il lock.
Versione: Java SE 21
Sintassi
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() e notify() sono metodi di istanza di java.lang.Object. Chiamali sull’oggetto lock di cui il thread corrente detiene il monitor, per esempio all’interno di synchronized (lock). Detenere il monitor di un altro oggetto non basta: senza quello dell’oggetto su cui viene chiamato il metodo, viene lanciata IllegalMonitorStateException.
Se il thread corrente detiene il monitor di lock e il suo stato di interruzione è già impostato quando chiama lock.wait(), il metodo azzera tale stato e lancia InterruptedException senza inserire il thread nell’insieme di attesa né rilasciare il monitor. Altrimenti, lock.wait() inserisce il thread corrente nell’insieme di attesa di lock e rilascia solo quel monitor, a tutti i livelli di acquisizione rientrante. Gli altri monitor rimangono bloccati. Il thread deve riacquisire il monitor con la profondità di blocco precedente prima che wait() ritorni o lanci un’eccezione a causa dell’interruzione dell’attesa. notifyAll() risveglia tutti i thread dell’insieme; notify() ne sceglie uno arbitrariamente, se ce ne sono. Nessuno dei due metodi rilascia o trasferisce il lock, né conserva una notifica per il futuro. I thread risvegliati competono per il monitor una volta rilasciato, senza un ordine garantito.
Leggi e modifica lo stato condiviso sotto lo stesso monitor. Dopo la modifica chiama notifyAll() prima di rilasciare il lock. Usa while (!ready) { lock.wait(); }, non if: un thread può risvegliarsi in modo spurio, oppure un altro thread può cambiare la condizione prima che il primo riacquisisca il monitor. Una notifica invita a ricontrollare la condizione, ma non dimostra che sia vera. Rilasciare e poi acquisire lo stesso monitor rende visibili le modifiche protette.
wait() non ha un limite di tempo. wait(long timeoutMillis) accetta millisecondi e wait(long timeoutMillis, int nanos) anche nanosecondi aggiuntivi da 0 a 999999. Se tutti gli argomenti sono zero non c’è limite; millisecondi negativi o nanosecondi fuori intervallo causano IllegalArgumentException. Per limitare la durata dell’intero ciclo, ricalcola il tempo rimanente. Quando wait() lancia InterruptedException, lo stato di interruzione viene azzerato. Propaga l’eccezione oppure ripristina lo stato se termini l’operazione senza propagarla.
Esempi
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();
}
}Risultato
ready
Il thread principale avvia il secondo thread mentre detiene `lock`. Il secondo thread non può impostare `ready` a vero finché `wait()` non rilascia quel monitor. Dopo averlo riacquisito, il thread principale ricontrolla la condizione. Il programma stampa una riga: `ready`.
Lezioni correlate
- Java · Lezione 28 · Avanzato · Versione: 2