java et les thread

Version imprimable

java et les thread

Bonjour
je n'ai pas vraiment compris le probléme des varibles partagée dans cet algorithme qui me semble pas correcte

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
Class SharedVar{int value;
bool available=false;}
classe producteur implements runnable{
private SharedVar v;
producteur(.....) {...}
 
void write(int valeur)
synchronized(v){
while(available) {v.wait() ;}  ///??? je n'ai pas compris ça
 
v.value=valeur;
v.available=true;  ///Quand est ce que on laisse les autres processus     exécuter leur tache
v.notifyAll();
}
void run(){
while(true) {int c=readChar();
write(c);}
}
}

merci

20/09/2009, 18h59
tchize_

il est censé faire quoi ce code? LA ligne que tu metionne fait attendre le thread jusqu'à ce qu'un autre thread fasse un notify ou notifyall
20/09/2009, 19h47
gentelmand

l'algo sert pour l'écriture dans une variable partagée.
pour la ligne ca veut dire que le processus est mis en attente tant que available=false ou vrai ??
et quand c'est vrai donc le proc peut écrire dans la variable mais aprés comment les autres processus peuvent accéder à la variable ??
c'est un peu flou.

merci de m'éclaircir ceci.
20/09/2009, 19h54
tchize_

t'as une boucle qui attend les notificaiton (cf le v.wait). Quand elle est notifié, elle vérifie si available est à false. Si available est à false, elle rempli v.valeur et sort de ta méthode.

Quand à comment tes processus lisent, je suppose qu'ils font une opération similaire, mais ne lisent que si availabe est à true et mettent available à false.
21/09/2009, 23h31
SOA_j2EE
Citation:

Envoyé par gentelmand

l'algo sert pour l'écriture dans une variable partagée.
pour la ligne ca veut dire que le processus est mis en attente tant que available=false ou vrai ??
et quand c'est vrai donc le proc peut écrire dans la variable mais aprés comment les autres processus peuvent accéder à la variable ??
c'est un peu flou.

merci de m'éclaircir ceci.

-
je ne vois pas l'utilité d'utiliser la var available et les méthodes: wait et notifyAll. sauf s'il y'a une autre méthode : synchronized int read() { return v.value} exécuté par un autre thread....
à mon avis, le code ci dessous devrait suffire:
Code:

1 2 3 4 5 6 void write(int valeur) synchronized(v){ v.value=valeur; ); }
22/09/2009, 01h56
tchize_

SOA: le notify/wait permet de garantir une espèce de queue à une entrée. Quand tu écris, tu attends que ce soit lu avant de réécrire.
22/09/2009, 02h58
SOA_j2EE

Citation:

Envoyé par tchize_

SOA: le notify/wait permet de garantir une espèce de queue à une entrée. Quand tu écris, tu attends que ce soit lu avant de réécrire.

oui tout à fait. Mais ici je ne vois pas une méthode (synchronized) qui fait la lecture de la variable partagé (v.value) ?. ou bien vous avez imaginer qu 'il y' une autre classe comsommateur qui contient une méthode read
22/09/2009, 10h17
Bbaboulinet

lu,
il y a la possibilité que dans ton main, on est instancié plusieurs fois ta class thread, il est donc utile de faire un verrou pour éviter le problème lié au multi-thread.
22/09/2009, 11h07
tchize_

Citation:

Envoyé par SOA_j2EE

oui tout à fait. Mais ici je ne vois pas une méthode (synchronized) qui fait la lecture de la variable partagé (v.value) ?. ou bien vous avez imaginer qu 'il y' une autre classe comsommateur qui contient une méthode read

Le code n'est pas complet, on peut supposer une méthode read() dans le même accabi (synchronized, notify , wait) qui serait le consommateur (ici on est dans le producteur). Mais c'est sur qu'utiliser les queue synchronizées java serait plus performant et plus facile à coder ;)
22/09/2009, 12h45
SOA_j2EE

Citation:

Envoyé par tchize_

Le code n'est pas complet, on peut supposer une méthode read() dans le même accabi (synchronized, notify , wait) qui serait le consommateur (ici on est dans le producteur). Mais c'est sur qu'utiliser les queue synchronizées java serait plus performant et plus facile à coder ;)

si tel est le cas, pour répondre à "gentelmand"

Citation:

Envoyé par gentelmand

Code:

while(available) {v.wait() ;} ///??? je n'ai pas compris ça

normelement devient:

Code:

while(v.available) {v.wait() ;}

cette ligne permet d'empêcher le producteur d'ecrire sur la var v.value avant sa lecture par un autre thread( le principal "main" ou un consommateur), et ce en cas que le thread producteur est plus rapide que les autre threads qui font la lecture. notons que v.wait libére le verrou sur l'objet v.
dans les thread qui font la lecture on met v.value = false.
22/09/2009, 19h26
gentelmand

d'aprés SOA à chaque fois le processus (producteur ) teste si le v.available est false donc il se met en attente sinon il fait le traitement.??
Pour le consommateurs il teste si v.available est true donc il se met en attente ??
Question 1 :Le fait de mettre un while(v.available) revient à dire while(v.available=false) dans notre cas ???
Question 2 : Est ce que vous pouvez m'expliquer la difference entre l'attente active et l'attente passive est leur but??
merci
23/09/2009, 07h13
SOA_j2EE

salut,

Citation:

Envoyé par gentelmand

d'aprés SOA à chaque fois le processus (producteur ) teste si le v.available est false donc il se met en attente sinon il fait le traitement.??
Pour le consommateurs il teste si v.available est true donc il se met en attente ??

c'est exactement l'inverse car:

Code:

while(v.available) {v.wait() ;}

est l'équivalent de:

Code:

while(v.available = true) {v.wait() // la réponse à la question1;}

-je laisse les gens répondre à la question2

mais dans la classe available= false par défaut
Code:

1 2 3 Class SharedVar{int value; bool available=false;}
donc est ce :
Code:

1 2 while(v.available) est equivalent à while(v.available=false)

23/09/2009, 09h49
SOA_j2EE
je sais par défaut que v.available = false. donc le producteur ne peut entrer dans la boucle: while(v.available) {v.wait() ; car v.avaiable = false(par défaut) et la condition pour entrer dans la boucle est v.availabe = true. à ce moment là il saute la boucle et exécute :
Code:

1 2 3 4 5 v.value=valeur; v.available=true; v.notifyAll(); ...
dans l'autre coté, le consommateur, il y' a un code qui ressemble au suivant:
Code:

1 2 3 4 5 6 ... while(v.available = false) {v.wait() ;} System.out.println (v.value);// par exemple; v.available = false; v.notifyAll; ...
si le consommateur commence le premier, il va se bloquer(exécute v.wait) car il trouve v.available = false et la condition de la boucle c'est v.available = false .
si le producteur commence le premier, il ne se bloquera pas (il n'exécute pas v.wait) car v.available = false et la condition c'est v.avalable = true.
le producteur va réveiller le consommateur par v.notfiyAll et ainsi ...
.....