Discussion :

[SOA_j2EE]

bonjour tout le monde,
soit le programme java 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
 
package tp8;
 
public class Testesync implements Runnable{
private int balance;
	public static void main(String[] args) {
		Testesync obj = new Testesync();
		Thread t = new Thread(obj);
		Thread tt = new Thread(obj);
		t.setName("Thread 1");
		tt.setName("Thread 2");
		t.start();
		tt.start();
 
	}
	public void run(){
	for(int i = 0;i<5;i++){
		incrementer();
		System.out.println(Thread.currentThread().getName()+" balance is :"+balance);
	}
 
	}
	void incrementer(){
		int i = balance;
		balance = i+1;
	}
 
}

l'exécution de ce programme donne:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Thread 1 balance is :1
Thread 1 balance is :3
Thread 1 balance is :4
Thread 1 balance is :5
Thread 1 balance is :6
Thread 2 balance is :2  // ????
Thread 2 balance is :7
Thread 2 balance is :8
Thread 2 balance is :9
Thread 2 balance is :10

quelqu'un peut m'expliquer ce résultat. notamment : Thread 2 balance is :2
si un thread est bloqué par la JVM , est ce qu'il fait la sauvgarde de l'état de ses variables (mème partagés). si oui au reprend il consulte l'état des variables sauvgardé et non pas les nouveaux états, n'est ce pas?
remarque: je sais pour résoudre ce type de problème je dois utiliser synchronized.
merci d'avance.

[professeur shadoko]

exemple de considérations annexes sur ce problème : sur le modèle mémoire

[Uther]

En effet l'état des variables accédée par deux thread différents peuvent poser ce genre de surprises.
C'est du aux optimisations que ce permet le programme. Pour les interdire, il faut les déclarer "volatile".

[egann538]

Tes 2 thread sont construits à partir du même objet "Testesync", donc la valeur "balance" de cet objet sera accédée par les 2 threads simultanément. Jusque là, pas de pb.

Le fait que les valeurs de "balance" ne soient pas affichées dans un ordre croissant ne signifie pas qu'il y a un bug, mais simplement que l'affichage ne se rafraichit pas forcément à chaque fois qu'un thread y accède. L'affichage peut "bufferiser" certaines lignes concernant un thread et les relacher quand l'autre thread rend la main.

Si tu veux afficher les valeurs de "balance" dans l'ordre croissant, il faut effectivement utiliser le mot clé synchronized, et vider le buffer d'affichage ainsi:

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
public class Testesync implements Runnable{
	private volatile int balance = 0;
	public static void main(String[] args) {
		Testesync obj = new Testesync();
		Thread t = new Thread(obj);
		Thread tt = new Thread(obj);
		t.setName("Thread 1");
		tt.setName("Thread 2");
		t.start();
		tt.start();
 
	}
	public void run(){
		for(int i = 0;i<5;i++){
			incrementer();
		}
	}
 
	public synchronized void incrementer()
	{
		balance++;
		System.out.println(Thread.currentThread().getName()+" balance is :"+balance);
		System.out.flush();
	}
 
}

Le mot clé volatile, sert à s'assurer que le système met bien à jour la valeur de "balance" lorsqu'un thread y accède.

[tchize_]

ca prouve juste que ton thread 2 a été bloqué entre le moment ou il a construit la string "Thread 2 balance is :2" et le moment ou il a appelé System.out.println() avec. T'as encor de la chance, balance n'est pas été corrompu, si ton thread avait été interrompu entre les deux instructions de incrementer, t'aurais pus avoir des doublons, genre

Code :

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

1
2
3
4
5
6
7
8
Thread 1 balance is :1
Thread 1 balance is :2
Thread 2 balance is :2 
Thread 2 balance is :3 
Thread 2 balance is :4
Thread 1 balance is :3
Thread 2 balance is :4
Thread 1 balance is :5

[samaury]

Tes 2 thread sont construits à partir du même objet "Testesync", donc la valeur "balance" de cet objet sera accédée par les 2 threads simultanément. Jusque là, pas de pb.....

J'ai peur de (ne pas) comprendre. Es-tu en train de dire que les deux threads accèdent à la même référence de "balance"? Du coup quand Thread 1 modifie "balance" Thread 2 voie cette modification?

[adiGuba]

Es-tu en train de dire que les deux threads accèdent à la même référence de "balance"? Du coup quand Thread 1 modifie "balance" Thread 2 voie cette modification?

Ben oui puisque tu n'as qu'une seule et unique instance de la classe Testesync. Tu n'as donc qu'un seul "balance"...


Après tu obtiens des résultats aléatoire car tu manipules les mêmes données depuis différents threads sans synchronisation.
Du coup tu peux avoir des comportements aléatoire...


En fait il y a une synchronisation (sur System.out) mais elle n'englobe pas tout ton traitement.


a++

[tchize_]

J'ai peur de (ne pas) comprendre. Es-tu en train de dire que les deux threads accèdent à la même référence de "balance"? Du coup quand Thread 1 modifie "balance" Thread 2 voie cette modification?

en réalité, "Thread1" et "Thread2" (les objets donc) n'ont pas accès à balance. C'est le run() d'une seule instance de TesteSync qui fonctionne deux fois en parallèle, et donc forcément avec les même champs

[SOA_j2EE]

bonjour,
merci pour vos réponses;
si j'ai bien compris c'est un problème de visibilié (utiliser un registre pour stocker le resultat ...), reordonner les instructions par le compilateur,etc.
voici un nouveau problème, cette fois ci avec synchronized.
cas 1: code précedant (toujours avec Runnable)+ synchronized:

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
 
package tp8;
 
public class Testesync implements Runnable{
private  int balance;
	public static void main(String[] args) {
		Testesync obj = new Testesync();
		Thread t1 = new Thread(obj);
		Thread t2 = new Thread(obj);
		t1.setName("Thread 1");
		t2.setName("Thread 2");
		t1.start();
		t2.start();
 
	}
	public void run(){
	for(int i = 0;i<5;i++){
		incrementer();
 
	}
 
	}
	 synchronized void incrementer(){
 
		int i = balance;
		balance = i+1;
		System.out.println(Thread.currentThread().getName()+" balance is :"+balance);
 
	}
 
}

à la fin de l'exécution, j'obtiens toujours: rrrr balance is :10 ou rrrr est un des deux threads
pour moi, c'est le résutat attendu

cas 2: le mème programme mais cette fois-ci, j'ai utilisé la classe Thread:

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
 
package tp9;
 
public class A extends Thread {
private int balance;
 
public void run(){
	for(int i = 0;i<5;i++){
		incrementer();
 
	}
 
	}
	 synchronized void incrementer(){
 
		int i = balance;
		balance = i+1;
		System.out.println(Thread.currentThread().getName()+" balance is :"+balance);
 
	}
 
}

la classe de test:

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
 
package tp9;
 
public class B {
 
 
	public static void main(String[] args) {
		A t1 = new  A();
		A t2 = new  A();
		t1.setName("Thread 1");
		t2.setName("Thread 2");
		t1.start();
		t2.start();
 
	}
 
}

j'obtiens un résultat bizarre, la variable balance n'a jamais atteint la valeur 10
exemple d'exécution:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Thread 1 balance is :1
Thread 2 balance is :1
Thread 1 balance is :2
Thread 2 balance is :2
Thread 1 balance is :3
Thread 2 balance is :3
Thread 1 balance is :4
Thread 2 balance is :4
Thread 1 balance is :5
Thread 2 balance is :5

question: quelqu'un peut m'exliquer pour quoi le resultat final dans cas 2 ne correspond pas au resultat dans cas 1 ?
merci d'avance

[herve91]

Parce que cette fois chaque instance de thread t1 et t2 dispose de sa propre "balance". Avant tu n'instanciais qu'une seule fois Testesync, donc la variable "balance" était partagée par les threads. A présent tu as deux instances de A, chacune disposant de son propre attribut "balance".