wait() vs sleep() en Java: ¿cuál elegir para los hilos?

wait() vs sleep() en Java: batalla de titanes del multihilo

Imagina que eres el director de una orquesta. Tienes violinistas (hilos) que deben tocar en armonía, pero a veces necesitan esperar a que otros terminen su parte. En Java, para gestionar esas pausas hay dos herramientas poderosas: wait() y sleep(). A primera vista son similares — ambas hacen que un hilo se "congele" por un tiempo. Pero en realidad son mecanismos completamente diferentes, y confundirlos es la forma segura de obtener un deadlock o una race condition.

Este artículo es tu guía por la jungla del multihilo. No solo enumeraremos las diferencias, sino que las analizaremos con ejemplos vivos, para que recuerdes para siempre: sleep es una pausa, wait es liberar un recurso. ¡Allá vamos!

¿Qué es sleep()? (Thread.sleep)

El método Thread.sleep(milisegundos) es la forma más simple de "dormir" el hilo actual durante un tiempo determinado. El hilo simplemente descansa, sin liberar los bloqueos de los objetos. Es como un gato perezoso que duerme en el sofá, pero sigue sosteniendo un juguete con la pata.

Datos importantes sobre sleep():

\n
• Es un método estático de la clase Thread.
\n
• El hilo no libera los monitores (bloqueos) que mantiene.
\n
• Después de que expire el temporizador, el hilo pasa al estado Runnable (listo para ejecutarse).
\n
• Puede lanzar InterruptedException.
\n

Ejemplo simple:

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

Resultado: entre las dos salidas habrá exactamente 2 segundos. El hilo simplemente esperó, sin hacer nada.

¿Qué es wait()? (Object.wait)

El método wait() ya no es solo una pausa, sino un mecanismo de comunicación entre hilos. Está definido en la clase Object, y solo se puede llamar dentro de un bloque sincronizado (synchronized). Cuando un hilo llama a wait(), este:

\n
• Libera el monitor del objeto (es decir, suelta el bloqueo).
\n
• Pasa al estado WAITING o TIMED_WAITING (si se especifica un tiempo de espera).
\n
• Espera hasta que otro hilo llame a notify() o notifyAll() sobre el mismo objeto.
\n

Es como si dijeras: "Dejo el tenedor y espero a que me traigan el segundo plato". No solo duermes — liberas espacio en la mesa para otro.

Ejemplo 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("El hilo mesero espera...");\n                    lock.wait(); // libera lock y espera\n                    System.out.println("¡El hilo mesero recibió la notificación!");\n                } catch (InterruptedException e) {\n                    Thread.currentThread().interrupt();\n                }\n            }\n        });\n\n        Thread notifier = new Thread(() -> {\n            synchronized (lock) {\n                System.out.println("El hilo cocinero prepara...");\n                try {\n                    Thread.sleep(1000); // simulación de cocción\n                } catch (InterruptedException e) {\n                    Thread.currentThread().interrupt();\n                }\n                lock.notify(); // despierta al hilo en espera\n                System.out.println("¡El cocinero notificó al mesero!");\n            }\n        });\n\n        waite