Discussion :

[K-you]

Bonjour,

J'utilise les méthodes wait et notify en appelant wait() dans le run d'un thread, et en appelant notify dans le run d'un autre thread sur l'objet thread qui est en attente.
Mais 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();
	}
}

[nnovic]

Non ce n'est pas possible. notify() réveille un thread qui est actuellement en attente. Il n'est pas prévu pour s'utiliser au futur.

[K-you]

"Au futur" veut dire que potentiellement, mon notify de maMéthode() pourrait être appelé avant le wait, et donc n'avoir aucun effet ?

[tchize_]

pas potentiellement, certainement. L'appel à maMethode se fait avant le wait -> le notify dans maMethode se fait avant le wait. Le système notify est prévu pour réveiller "un autre thread" qui est endormi sur une wait.

[K-you]

Ah oui, mon exemple est incomplet : il n'y a pas d'objet synchronizé. en ajoutant le synchronized comme ci-dessous, le traitement de maMéthode() ne s'efféctuera qu'après avoir appelé wait (qui relache la mutex sur l'objet suivantsDe0, et permet donc à maMéthode de rentrer en zone critique).

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
34
35
36
37
38
 
 
public class monThread extends Thread {
	int[] monTableau;
	ArrayList<Integer> suivantsDe0 = new ArrayList<Integer>();
 
	public void run() {
 
		while(!isInterrupted())
		{
                    synchronized(suivantsDe0) {
			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(){
              synchronized(suivantsDe0) {
		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();
             }
	}
}

Donc dans ce nouveau cas est-ce juste ou toujours pas ?

[tchize_]

ton synchronized, il ne sert à rien. La variable suivantsDe0 étant local, aucun autre Thread n'y a accès et donc y a rien à protéger. ton thread va exécuter les instructions "dans l'ordre", donc il appellera maMethode jusqu'au bout, avant d'appeler le wait, c'est tout.

[K-you]

Si je comprend bien, j'ai compliqué la situation pour rien en utilisant les wait et notify de la mauvaise façon.

Dans mon cas quelque soit la longueur du traitement de maMéthode, ce traitement s'effectuera avant le rebouclage dans le while de mon Thread, donc en faite il n'y a pas de problème...