wait() vs sleep() em Java: o que escolher para threads?

wait() vs sleep() em Java: batalha dos titãs do multithreading

Imagine que você é o maestro de uma orquestra. Você tem violinistas (threads) que devem tocar em harmonia, mas às vezes precisam esperar enquanto outros terminam sua parte. Em Java, existem duas ferramentas poderosas para gerenciar essas pausas: wait() e sleep(). À primeira vista, elas são parecidas — ambas fazem a thread "congelar" por um tempo. Mas, na verdade, são mecanismos completamente diferentes, e confundi-las é uma maneira certeira de obter um deadlock ou uma race condition.

Este artigo é o seu guia pela selva do multithreading. Não vamos apenas listar as diferenças, mas analisá-las com exemplos práticos, para que você nunca mais esqueça: sleep é uma pausa, wait é uma liberação de recurso. Vamos nessa!

O que é sleep()? (Thread.sleep)

O método Thread.sleep(milissegundos) é a maneira mais simples de "adormecer" a thread atual por um tempo determinado. A thread simplesmente descansa, sem liberar os bloqueios dos objetos. É como um gato preguiçoso que cochila no sofá, mas continua segurando o brinquedo com a pata.

Fatos importantes sobre sleep():

\n
• É um método estático da classe Thread.
\n
• A thread não libera os monitores (bloqueios) que ela mantém.
\n
• Após o término do temporizador, a thread vai para o estado Runnable (pronta para execução).
\n
• Pode lançar InterruptedException.
\n

Exemplo simples:

public class SleepExample {\n    public static void main(String[] args) throws InterruptedException {\n        System.out.println("Iniciando: " + System.currentTimeMillis());\n        Thread.sleep(2000); // dorme por 2 segundos\n        System.out.println("Acordou: " + System.currentTimeMillis());\n    }\n}

Resultado: entre as duas saídas, haverá exatamente 2 segundos. A thread apenas esperou, sem fazer nada.

O que é wait()? (Object.wait)

O método wait() não é apenas uma pausa, mas um mecanismo de comunicação entre threads. Ele é definido na classe Object e só pode ser chamado dentro de um bloco sincronizado (synchronized). Quando uma thread chama wait(), ela:

\n
• Libera o monitor do objeto (ou seja, solta o bloqueio).
\n
• Vai para o estado WAITING ou TIMED_WAITING (se um tempo limite for especificado).
\n
• Aguarda até que outra thread chame notify() ou notifyAll() no mesmo objeto.
\n

É como se você dissesse: "Vou largar o garfo e esperar até que me tragam o segundo prato". Você não está apenas dormindo — está liberando espaço na mesa para outra pessoa.

Exemplo básico:

public class WaitNotifyExample {\n    private static final Object lock = new Object();\n\n    public static void main(String[] args) throws InterruptedException {\n        Thread waiter = new Thread(() -> {\n            synchronized (lock) {\n                try {\n                    System.out.println("Thread-garçom esperando...");\n                    lock.wait(); // libera lock e espera\n                    System.out.println("Thread-garçom recebeu notificação!");\n                } catch (InterruptedException e) {\n                    Thread.currentThread().interrupt();\n                }\n            }\n        });\n\n        Thread notifier = new Thread(() -> {\n            synchronized (lock) {\n                System.out.println("Thread-cozinheiro preparando...");\n                try {\n                    Thread.sleep(1000); // simula o preparo\n                } catch (InterruptedException e) {\n                    Thread.currentThread().interrupt();\n                }\n                lock.notify(); // acorda a thread em espera\n                System.out.println("Cozinheiro notificou o garçom!");\n            }\n        });\n\n        waite