Discussion :

[0redd]

Bonsoir,
j'ai essayé d'écrire un programme qui utilisé wait et notify, il se compile mais lorsque je l'execute, il ne m'affiche rien, d'ou vient l'erreur

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
39
40
41
42
43
 
public class Main {
 
	public static void main(String[] args) {
 
 
		final Calcul t = new Calcul();
 
		Thread t2 = new Thread() {
			public void run() {
				synchronized(t) {
					try { t.wait(); } catch(InterruptedException e) {out.printf("nari nari nari");}
					System.out.println(t.getSomme());
				}
			}
		};
 
		t.start();
		try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
		t2.start();
 
	}
 
}
 
class Calcul extends Thread {
 
	public void run() {
		synchronized(this) {
			for(int i = 0;i<100;i++) {
				somme+=i;
			}
			this.notifyAll();
		}
	}
 
	private int somme;
 
	public int getSomme() {
		return somme;
	}
 
};

Merci d'avance pour votre aide

[adiGuba]

Salut,


Le premier thread se termine et appelle notifyAll() bien avant que le second ne soit démarré. Du coup le second ne rentre pas dans le bloc synchronized() ni dans le wait().

Lorsque tu fais le notifyAll() il n'y a aucun thread à notifier...

Ton premier thread se termine et libère le verrou, et ton second peut donc commencer et il se retrouve bloquer sur le wait().



Expliques précisément ce que tu cherches à faire, il doit surement y avoir des truc tout fait.




A moins que ce ne soit pour tester le fonctionnement du wait/notify, et dans ce cas là il ne faut pas hésiter à logger pas mal pour voir comment ca se passe.

Il faut également éviter de faire des suppositions sur le déroulement des opérations. En particulier on ne peut pas garantir que le notify() sera bien appelé lorsque l'autre thread est dans le wait(). Il faut protéger cela avec une variable afin d'éviter les interblocages...


Exemple :

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public class Main {
 
	public static void main(String[] args) {
 
		final Calcul t = new Calcul();
 
		Thread t2 = new Thread() {
			public void run() {
				System.out.println("Début du thread 2");
				synchronized(t) {
					System.out.println("Début du synchronized du thread 2");
					System.out.println("Avant le wait() dans le thread 2");
					while ( t.isFinished()==false ) {
						try { t.wait(); } catch(InterruptedException e) {System.out.printf("nari nari nari");} 
					}
					System.out.println("Après le wait() dans le thread 2");
					System.out.println(t.getSomme());
					System.out.println("Fin du synchronized du thread 2");
				}
				System.out.println("Fin du thread 2");
			}
		};
 
		t.start();
		t2.start();
 
	}
 
}
 
class Calcul extends Thread {
 
	private volatile boolean finished = false;
 
	public void run() {
		System.out.println("Début du thread 1");
		synchronized(this) {
			System.out.println("Début du synchronized du thread 1");
			for(int i = 0;i<100;i++) {
				somme+=i;
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("Avant le notifyAll() dans le thread 1");
			finished = true;
			this.notifyAll();
			System.out.println("Après le notifyAll() dans le thread 1");
			System.out.println("Fin du synchronized du thread 1");
		}
		System.out.println("Fin du thread 1");
	}
 
	private int somme;
 
	public int getSomme() {
		return somme;
	}
 
	public boolean isFinished() {
		return finished;
	}
};

a++

[tchize_]

Salut,


Le premier thread se termine et appelle notifyAll() bien avant que le second ne soit démarré. Du coup le second ne rentre pas dans le bloc synchronized() ni dans le wait().

Heu si, il rentre dans le synchronized, il rentre dans le wait, il ne sera juste jamais notifié et attendra indéfiniment Sinon, pour le reste, entièrement d'accord avec toi.

[adiGuba]

Oui en effet je voulais dire que le second thread ne rentrait dans le synchronized/wait qu'après la fin du premier thread...

Bien vu

a++

[0redd]

c'est vrai j'avais inversé l'ordre des appel des thread,
du coup le wait attendait indéfiniment ..
en effet, le code que j'avais écrit est seulement pour mieux comprendre le fonctionnement du wait/notify.

sinon j'aurai deux autres petites questions,
1 - pourquoi wait et notify doivent être dans un bloc synchroniser ?
2 - InterruptedException c'est quoi?

sinon merci pour vos réponses

[tchize_]

1) parce que! Plus précisément, ca garanti que ce n'est pas à la jvm de le faire, de plus, en général, le wait/ notify n'est pas seul dans le bloc à protéger. L'un dans l'autre ca garanti que
-> deux thread différents ne peuvent pas simultanément être respectivement dans le wait et le notify, ce qui pourrait amener des micmac
-> Lors du retour du wait, la jvm te garanti que tu est le possesseur du verrou concerné par ton synchronized, ca permet de faire des traitement requérant la synchronisation, tout en ayant la garanti qu'aucun autre thread n'aura bidouillé des valeur entre le retour de wait et la réobtention du verrou!


2)Ton thread attends, le notify qu'il attends n'a pas eu lieu, mais un autre thread a appelé interrupt() sur ton thread pour le réveiller.

[0redd]

Merci beaucoup, c'est plus clair là