CKTIS / Java
Object.wait() y Object.notifyAll(): esperar una condición
Protege el estado compartido con un mismo monitor, vuelve a comprobar la condición en un bucle `while` y recuerda que `notifyAll()` no libera ni transfiere el bloqueo.
Versión: Java SE 21
Sintaxis
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() y notify() son métodos de instancia de java.lang.Object. Llámalos sobre el objeto lock cuyo monitor posee el hilo actual, por ejemplo dentro de synchronized (lock). Poseer el monitor de otro objeto no basta: sin el monitor del objeto sobre el que se invoca el método, se lanza IllegalMonitorStateException.
Si el hilo actual posee el monitor de lock y su estado de interrupción ya está activado al llamar a lock.wait(), el método borra ese estado y lanza InterruptedException sin añadir el hilo al conjunto de espera ni liberar el monitor. En caso contrario, lock.wait() añade el hilo actual al conjunto de espera de lock y libera únicamente ese monitor, en todos los niveles de adquisición reentrante. Los demás monitores siguen bloqueados. El hilo debe volver a adquirir ese monitor con el mismo nivel de bloqueo antes de que wait() retorne o lance una excepción por haberse interrumpido la espera. notifyAll() despierta a todos los hilos del conjunto; notify() elige uno arbitrariamente si hay alguno. Ninguno libera ni transfiere el bloqueo ni guarda una notificación para más tarde. Los hilos despertados compiten por el monitor cuando se libera, sin un orden garantizado.
Lee y modifica el estado compartido bajo el mismo monitor. Tras modificarlo, llama a notifyAll() antes de liberar el bloqueo. Usa while (!ready) { lock.wait(); }, no if: un hilo puede despertarse de forma espuria, u otro hilo puede cambiar la condición antes de que el primero recupere el monitor. Una notificación indica que hay que volver a comprobar la condición, no que esta se cumpla. Liberar y adquirir después el mismo monitor hace visibles los cambios protegidos.
wait() no tiene límite de tiempo. wait(long timeoutMillis) recibe milisegundos y wait(long timeoutMillis, int nanos) recibe también nanosegundos adicionales de 0 a 999999. Si todos los argumentos son cero no hay límite; los milisegundos negativos o los nanosegundos fuera del intervalo provocan IllegalArgumentException. Para limitar el tiempo del bucle entero, vuelve a calcular el tiempo restante. Cuando wait() lanza InterruptedException, se borra el estado de interrupción. Propaga la excepción o restablece ese estado si terminas la operación sin propagarla.
Ejemplos
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();
}
}Resultado
ready
El hilo principal arranca el segundo hilo mientras posee `lock`. El segundo hilo no puede poner `ready` a verdadero hasta que `wait()` libere ese monitor. Tras recuperarlo, el hilo principal comprueba otra vez la condición. El programa imprime una línea: `ready`.
Lecciones relacionadas
- Java · Lección 28 · Avanzado · Versión: 2