Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Object.wait() e Object.notifyAll(): esperar por uma condição

Protege o estado partilhado com o mesmo monitor, volta a testar a condição num ciclo `while` e lembra-te de que `notifyAll()` não liberta nem transfere o bloqueio.

Versão: Java SE 21

Sintaxe

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() são métodos de instância de java.lang.Object. Invoca-os sobre o objeto lock cujo monitor a thread atual detém, por exemplo dentro de synchronized (lock). Deter o monitor de outro objeto não basta: sem o monitor do objeto sobre o qual é feita a chamada, o método lança IllegalMonitorStateException.

Se a thread atual detiver o monitor de lock e já tiver o estado de interrupção ativo quando invoca lock.wait(), o método limpa esse estado e lança InterruptedException sem incluir a thread no conjunto de espera nem libertar o monitor. Caso contrário, lock.wait() inclui a thread atual no conjunto de espera de lock e liberta apenas esse monitor, em todos os níveis de aquisição reentrante. Os outros monitores mantêm-se bloqueados. A thread tem de voltar a adquirir o monitor com a profundidade de bloqueio anterior antes de wait() retornar ou lançar uma exceção por a espera ter sido interrompida. notifyAll() acorda todas as threads desse conjunto; notify() escolhe uma arbitrariamente se houver alguma. Nenhum dos métodos liberta ou transfere o bloqueio, nem guarda uma notificação para mais tarde. As threads acordadas disputam o monitor após a sua libertação, sem ordem garantida.

Lê e altera o estado partilhado sob o mesmo monitor. Depois da alteração, chama notifyAll() antes de libertar o bloqueio. Usa while (!ready) { lock.wait(); }, não if: uma thread pode acordar sem motivo aparente, ou outra thread pode alterar a condição antes de a primeira recuperar o monitor. Uma notificação indica que é preciso testar a condição de novo, não que ela seja verdadeira. Libertar e voltar a adquirir o mesmo monitor torna visíveis as alterações protegidas.

wait() não tem limite de tempo. wait(long timeoutMillis) recebe milissegundos e wait(long timeoutMillis, int nanos) recebe ainda nanossegundos adicionais de 0 a 999999. Se todos os argumentos forem zero, não há limite; milissegundos negativos ou nanossegundos fora do intervalo provocam IllegalArgumentException. Para limitar o tempo do ciclo inteiro, recalcula o tempo restante. Quando wait() lança InterruptedException, limpa o estado de interrupção. Propaga a exceção ou repõe o estado se terminares a operação sem a propagar.

Exemplos

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

A thread principal inicia a segunda thread enquanto detém `lock`. A segunda thread só pode atribuir o valor verdadeiro a `ready` depois de `wait()` libertar esse monitor. Depois de o recuperar, a thread principal testa novamente a condição. O programa escreve uma linha: `ready`.

Lições relacionadas

  • Java · Lição 28 · Avançado · Versão: 2

Fontes