Discussion :

[nolofinwe]

Bonjour,

J'ai un probleme avec les méthodes wait(), notify() et notifyAll() appliquées aux threads...
D'aprés ce que j'ai compris elles sont utiles pour la synchronisation des threads mais je ne parvient pas a comprendre comment les utiliser et laquelle utiliser quand...

Si il vous est possible de me l'expliquer simplement ou de me dire ou je pourrai trouver un bon tuto assez clair je suis preneur.

merci pour votre aide.

[adiGuba]

Salut,


Ces méthodes s'utilisent uniquement dans les blocs synchronized et sur l'objet utilisé comme lock. Pour rappel pour rentrer dans un bloc synchronized un thread doit acquérir le lock, et tout les autres threads qui tente d'acquérir ce même lock sont mis en sommeil jusqu'à qu'il soit disponible.

Lorsqu'on appelle wait() le thread courant s'endort et libère le verrou associé au bloc synchronized :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
	// On essaye de récupérer le verrou associé à lock
	// -> S'il est disponible on rentre dans le block synchronized
	// -> Sinon le thread est endormi en attendant qu'il soit libéré
	synchronized (lock) {
 
		// wait() endort le thread courant et libère le verrou associé à lock
		// -> Pour sortir du wait() il faut que le thread soit réveillé par notify()
		// ET que le verrou soit à nouveau disponible
		lock.wait();
 
	}

Ce code endort le thread courant et libère le verrou 'lock', qui peut ainsi être utilisé par un autre thread....



notify() et notifyAll() permettent de réveiller un thread ou tout les threads qui se sont endormis sur le lock, ainsi si depuis un autre thread on a ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
	// On essaye de récupérer le verrou associé à lock
	// -> S'il est disponible on rentre dans le block synchronized
	// -> Sinon le thread est endormi en attendant qu'il soit libéré
	synchronized (lock) {
 
		// notify() permet simplement de réveiller un autre thread
		// qui s'est endormi avec wait() sur le même lock
		// -> Le thread courant conserve malgré tout le verrou et
		// l'autre thread devra attendre qu'il soit libéré pour continuer
		// (via wait() ou en sortant du bloc synchronized)
		lock.notify();
 
	}

Ce second thread peut prendre le verrou puisque le premier l'a libéré (via wait()), et il utilise notify() pour réveiller le premier thread. Mais pour sortir du wait ce dernier doit d'abord récupérer le verrou (toujours maintenu par le second thread tant qu'il ne sort pas du bloc synhronized).


Plus de détail :

• Java et la synchronisation
• Cours Thread et Communication en Java

Maintenant il faut bien voir que wait()/notify() ne sont que des instructions basiques de synchronisation, et qu'avec Java 5.0 on pourrait choisir de se tourner vers les packages java.util.concurrent, java.util.concurrent.atomic et java.util.concurrent.locks qui propose des mécanismes bien plus évolués

a++

[nolofinwe]

donc si j'ai bien compris wait() permet d'endormir un thread afin de liberer un verrou et pouvoir passer la main a un autre thread qui attendait la liberation du verrou.

notify() permet de reveiller un thread endormi qui pourra etre actif des que le verrou sera levée.

et notifyAll() fait la meme chose que notify() mais sur tous les threads endormi c'est ca ?

merci pour ton aide adiGuba.

[adiGuba]

Oui c'est bien cela !

Mais il y a quelques pièges à éviter :

• Le lock doit être la même référence pour les deux threads : si chacun utilise le sien il ne "communiqueront" pas.
• Il faut faire attention à l'ordonnancement : ce n'est pas parce qu'un thread est lancé en premier qu'il s'exécutera forcément avant dans tous les cas. Le problème vient lorsque le notify() est exécuté avant le wait() : le premier thread ne sera pas réveillé puisqu'il ne dort pas, mais s'endormira lorsqu'il rentrera dans le wait...
  
  En général il faut utiliser un booléen pour vérifier si le notify() a été appelé ou pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
	synchronized (lock) {
		if (!notified) {
			lock.wait();
		}
	}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
	synchronized (lock) {
		lock.notify();
		notified = true;
	}

a++

[nolofinwe]

ok je pense avoir compris merci pour tout adiGuba.

[K-you]

Est-il possible de lancer ce notify ailleurs que dans un autre thread ?

Par exemple dans une méthode appelée dans le run avant le wait (dans mon exemple maMethode). Ou bien est-ce que la méthode ne fera pas son traitement du fait du wait?

Ce qui donnerai l'exemple suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
public class monThread extends Thread {
	int[] monTableau;
	ArrayList<Integer> suivantsDe0 = new ArrayList<Integer>();
 
	public void run() {
 
		while(!isInterrupted())
		{
			if(monTableau[0] == 0){
				maMethode();
				try{
					wait();
				} catch(InterruptedException e){}
			}
			else{
				for(int i=0; i<monTableau.length-1 ; i++)
					monTableau[i] = monTableau[i+1];
				monTableau[monTableau.length] = 0;
			}
		}
	}
	private void maMethode(){
		if(monTableau.length > 1){
			suivantsDe0.add(monTableau[1]);
			for(int i=0; i<monTableau.length-2 ; i++)
				monTableau[i] = monTableau[i+2];
			monTableau[monTableau.length-1] = 0;
			monTableau[monTableau.length] = 0;
		}
		notify();
	}
}