Discussion :

[gentelmand]

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

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
 
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

[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

[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.

[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.

[SOA_j2EE]

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 :

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

1
2
3
4
5
6
 
void write(int valeur)
synchronized(v){
v.value=valeur;
);
}

[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.

[SOA_j2EE]

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

[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.

[tchize_]

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

[SOA_j2EE]

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"

Code :

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

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

normelement devient:

Code :

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

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.

[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

[SOA_j2EE]

salut,

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 :

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

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

est l'équivalent de:

Code :

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

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

-je laisse les gens répondre à la question2

[gentelmand]

mais dans la classe available= false par défaut

Code :

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

1
2
3
 
Class SharedVar{int value;
bool available=false;}

donc est ce :

Code :

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

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

[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 :

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

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 :

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

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 ...
.....