Discussion :

[vince3147]

Salut,

Lorsqu'on fait du multi thread, on a souvent un thread1 qui fait:

Code :

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

1
2
3
4
5
6
7
while () {
   truc
   truc
   truc
   dire au thread2 qu'il peut travailler => lock.notify()
}

et le thread2 serait :

Code :

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

1
2
3
4
5
6
7
while () {
   attendre que lock soit libre pour travailler => lock.wait()
   travaille
   travaille
   travaille
}

Je ne comprends pas trop comment utiliser en toute sécurité ce système car le problème est le suivant :

Si le travail du thread2 prend plus de temps que prévu, le thread1 va éventuellement faire 2 ou 3 notify pendant que le thread2 travaillera toujours.
Or dans certains cas il est important que tous les événements soient pris en compte, pas 1 de plus ni 1 de moins. On peut avoir aussi besoin de repérer le dernier événement (valeur ayant atteint une certaine valeur) donc si on a plusieurs notify, on le rate.


C'est un programme idiot mais par exemple avec ce code :

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
public class Semaphores {
 
	private static final Object lock = new Object();	
	private static int nombre;
 
	public static void main(String[] args) {
 
		(new Thread(){
			public void run () {
				for (int i=0;i<500;i++) {
					synchronized(lock) {
						nombre=i+1;
						lock.notify();
					}
				}
			}
		}).start();
 
		for (;;) {
			synchronized (lock) {
 
				try {
					lock.wait();
				} catch (InterruptedException e) {e.printStackTrace();}
 
				System.out.println("nombre a changé de valeur : nombre=" + nombre);
			}
		}
 
	}
 
}

On a un thread qui compte de 1 à 500 et l'autre qui affiche la valeur dès qu'elle change. La sortie donne ceci :

Code :

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

1
2
3
4
5
6
7
nombre a changé de valeur : nombre=3
nombre a changé de valeur : nombre=237
nombre a changé de valeur : nombre=309
nombre a changé de valeur : nombre=311
nombre a changé de valeur : nombre=388
nombre a changé de valeur : nombre=453
nombre a changé de valeur : nombre=455

Pouvez-vous m'éclaircir sur le sujet ?

Merci

[®om]

Le plus simple est d'utiliser des sémaphores (et non des moniteurs, comme tu le fais sur ton exemple). La principale différence est que le sémaphore "mémorise" le nombre de P (wait) et le nombre de V (notify), avec V-P = nombre de jetons

java.util.concurrent.Semaphore

[vince3147]

Ah OK alors si je comprends bien c'est au niveau de mon thread1 qu'il faut vérifier que le sémaphore vaut 0 avant de faire le notify?
Mais comment vérifier cela sans faire de l'attente active ?

[®om]

Ah OK alors si je comprends bien c'est au niveau de mon thread1 qu'il faut vérifier que le sémaphore vaut 0 avant de faire le notify?
Mais comment vérifier cela sans faire de l'attente active ?

Si tu utilises des sémaphores, tu n'utilises plus de moniteur (donc plus de wait/notify).
Tu utilises les méthodes du sémaphore (acquire/release)...

[vince3147]

OK

Merci !