wait() vs sleep() en Java : que choisir pour les threads ?

wait() vs sleep() en Java : le choc des titans du multithreading

Imaginez que vous êtes le chef d’orchestre. Vous avez des violonistes (threads) qui doivent jouer en harmonie, mais parfois ils doivent attendre que d’autres terminent leur partie. En Java, pour gérer ces pauses, deux outils puissants existent : wait() et sleep(). À première vue, ils se ressemblent – tous deux forcent un thread à « figer » temporairement. Mais en réalité, ce sont des mécanismes totalement différents, et les confondre est un moyen sûr d’obtenir un deadlock ou une race condition.

Cet article est votre guide dans la jungle du multithreading. Nous ne nous contenterons pas d’énumérer les différences, mais nous les analyserons avec des exemples vivants, pour que vous reteniez à jamais : sleep est une pause, wait est une libération de ressource. C’est parti !

Qu’est-ce que sleep() ? (Thread.sleep)

La méthode Thread.sleep(millisecondes) est le moyen le plus simple d’« endormir » le thread actuel pendant une durée définie. Le thread se repose simplement, sans libérer les verrous des objets. C’est comme un chat paresseux qui somnole sur le canapé, mais continue de tenir son jouet avec la patte.

Faits importants sur sleep() :

\n
• C’est une méthode statique de la classe Thread.
\n
• Le thread ne libère pas les moniteurs (verrous) qu’il détient.
\n
• Une fois le minuteur écoulé, le thread passe à l’état Runnable (prêt à être exécuté).
\n
• Peut lever une InterruptedException.
\n

Exemple simple :

public class SleepExample {\n    public static void main(String[] args) throws InterruptedException {\n        System.out.println("Début : " + System.currentTimeMillis());\n        Thread.sleep(2000); // on dort 2 secondes\n        System.out.println("Réveillé : " + System.currentTimeMillis());\n    }\n}

Résultat : il y aura exactement 2 secondes entre les deux affichages. Le thread a simplement attendu, sans rien faire.

Qu’est-ce que wait() ? (Object.wait)

La méthode wait() n’est pas une simple pause, mais un mécanisme de communication inter-threads. Elle est définie dans la classe Object, et ne peut être appelée qu’à l’intérieur d’un bloc synchronisé (synchronized). Lorsqu’un thread appelle wait(), il :

\n
• Libère le moniteur de l’objet (c’est-à-dire qu’il relâche le verrou).
\n
• Passe à l’état WAITING ou TIMED_WAITING (si un délai est spécifié).
\n
• Attend qu’un autre thread appelle notify() ou notifyAll() sur le même objet.
\n

C’est comme si vous disiez : « Je pose ma fourchette et j’attends qu’on m’apporte le plat principal. » Vous ne dormez pas simplement – vous libérez une place à table pour un autre.

Exemple de base :

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("Le thread-serveur attend...");\n                    lock.wait(); // libère lock et attend\n                    System.out.println("Le thread-serveur a reçu la notification !");\n                } catch (InterruptedException e) {\n                    Thread.currentThread().interrupt();\n                }\n            }\n        });\n\n        Thread notifier = new Thread(() -> {\n            synchronized (lock) {\n                System.out.println("Le thread-cuisinier prépare...");\n                try {\n                    Thread.sleep(1000); // simulation de la cuisson\n                } catch (InterruptedException e) {\n                    Thread.currentThread().interrupt();\n                }\n                lock.notify(); // réveille le thread en attente\n                System.out.println("Le cuisinier a notifié le serveur !");\n            }\n        });\n\n        waite