CKTIS / Java
Object.wait() et Object.notifyAll() : attendre une condition
Protégez l’état partagé avec un même moniteur, revérifiez la condition dans une boucle `while` et gardez à l’esprit que `notifyAll()` ne libère ni ne transmet le verrou.
Version : Java SE 21
Syntaxe
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() et notify() sont des méthodes d’instance de java.lang.Object. Appelez-les sur l’objet lock dont le thread courant détient le moniteur, par exemple dans synchronized (lock). Détenir le moniteur d’un autre objet ne suffit pas : sans celui de l’objet sur lequel porte l’appel, la méthode lève IllegalMonitorStateException.
Si le thread courant détient le moniteur de lock et que son statut d’interruption est déjà activé lorsqu’il appelle lock.wait(), la méthode efface ce statut et lève InterruptedException sans ajouter le thread à l’ensemble d’attente ni libérer le moniteur. Sinon, lock.wait() ajoute le thread courant à l’ensemble d’attente de lock et ne libère que ce moniteur, à tous les niveaux d’acquisition réentrante. Les autres moniteurs restent verrouillés. Le thread doit reprendre ce moniteur avec la même profondeur de verrouillage avant que wait() retourne ou lève une exception parce que l’attente a été interrompue. notifyAll() réveille tous les threads de cet ensemble ; notify() en choisit un arbitrairement s’il y en a. Aucune des deux méthodes ne libère ni ne transmet le verrou, et aucune ne conserve de notification pour plus tard. Les threads réveillés se disputent le moniteur après sa libération, sans ordre garanti.
Lisez et modifiez l’état partagé sous le même moniteur. Après la modification, appelez notifyAll() avant de libérer le verrou. Utilisez while (!ready) { lock.wait(); }, et non if : un thread peut se réveiller spontanément, ou un autre thread peut modifier la condition avant que le premier ne reprenne le moniteur. Une notification invite à vérifier de nouveau la condition ; elle ne garantit pas qu’elle est vraie. La libération puis l’acquisition du même moniteur rendent les modifications protégées visibles.
wait() n’a pas de délai maximal. wait(long timeoutMillis) prend des millisecondes et wait(long timeoutMillis, int nanos) prend aussi des nanosecondes supplémentaires de 0 à 999999. Si tous les arguments valent zéro, il n’y a pas de limite ; des millisecondes négatives ou des nanosecondes hors plage provoquent IllegalArgumentException. Pour limiter la durée de toute la boucle, recalculez le temps restant. Quand wait() lève InterruptedException, le statut d’interruption est effacé. Propagez l’exception ou rétablissez le statut si vous terminez l’opération sans la propager.
Exemples
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();
}
}Résultat
ready
Le thread principal lance le second thread en détenant `lock`. Le second thread ne peut mettre `ready` à vrai que lorsque `wait()` libère ce moniteur. Après l’avoir repris, le thread principal revérifie la condition. Le programme affiche une seule ligne : `ready`.
Leçons associées
- Java · Leçon 28 · Avancé · Version : 2