Discussion :

[angelmn]

bonjour à tous
svp est ce que quelqu'un pourrait m'expliquer le role de synchronized wait() et notify () en java.
j'ai lu et relu mon cour trouvé quelques tutoriels j'ai toujours pas compris quand est ce qu'il faut les utiliser.
j'ai essayé de creer des exemple et de les executer: avec synchronized ca ne change rien du tout à l'execution en parallele des threads.
et quand je mets wait() il y a chaque fois le meesage d'erreur suivant

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException: current thread not owner

at java.lang.Object.wait(Native Method)

j'y comprends rien
Merci de m'aider

[bulbo]

Bon je vais essayé de faire court et simple .. pas facile.

Le mot clé synchronized (appliqué a une méthode ou a un bloc { } ) défini une section ou un seul thread a la fois peu "entrer".

Si un thread est deja en train d'exécuter une partie de code synchronized, un autre thread voulant l'exécuter se retrouvera bloqué le temps que le précédent sorte de la section synchronized ou fasse un appel a wait.

notify ou notifyAll réveille un thread endormi sur un wait.

wait ou notify(All) ne peuvent être appelé que depuis une section synchronized.

Pour en revenir a ton exception..

Un synchronized se fait sur un objet, si c'est une méthode alors c'est this mais si c'est un bloc alors l'objet doit être passé en argument (et peut être this).

Deux synchronized sur deux objets différents ne s'exécutent pas en exclusion mutuelle, c'est a dire qu'un thread peut exécuter du code d'un synchronized sur un objet A pendant qu'un autre exécutera le code d'un synchronized sur un objet B.
De la même manière quand on fait un wait ou un notify(All) il est bon de préciser sur quel objet on les fait et on doit être dans un synchronized sur cet objet.

Par exemple

Code :

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

1
2
3
4
synchronized(objectA)
{
  objectA.wait(); // marche
}

alors que

Code :

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

1
2
3
4
synchronized(objectA)
{
  objectB.wait(); // ne marche pas
}

Bon j'espère que tu comprends tout ce que je raconte , n'hésite pas a poser des questions sinon.

Bulbo

[angelmn]

oui merci jcomprends un peu mieux; (surtout que jarrive à executer ss erreur maintenant )
sauf que je vois pas vraiment quand est ce qu'il est necessaire de les utliser pourriez vous me trouver un exemple.

et puis l'utilisation de synchronized je croyais que ca s'appliquait uniquement au methodes. alors ou est ce que on declare un objet synchronized à ca creation du genre
synchronized obj b=new obj();???

Merci bocou pour votre aide

[tchize_]

pour les bloc de synchronization, le code est sous tes yeux (faut lire!). Pour l'intérêt, çà consiste à se protéger des exécution concurrentes quand c'est nécessaire.

Regarde un exemple, 2 Thread non synchronisé. Chacun ajoute un élément à un tableau, qui est partagé entre les deux Threads:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Thread 1                                      Thread2
tmp = new int[tableau.length+1] 
 
                                              tmp = new int[tableau.length+1]
                                              for (int i=0; i<tableau.length;i++)
                                                  tmp[i]=tableau[i];
                                              tmp[tmp.length-1]=y;
for (int i = 0; i<tableau.length;i++)
    tmp[i]=tableau[i];
tmp[tmp.length-1]=x;
tableau=tmp;
                                              tableau=tmp;

Résultat: si au départ, tableau vaut [1,2,3], à l'arrivée il vaut (pour cette exécution seulement) [1,2,3,x] alors que, si les blocs avaient été synchronized, il aurait valu, correctement, soit [1,2,3,x,y] soit [1,2,3,y,x] (suivant quel thread aurait démarré en premier). Note que, comme dans mon cs ce n'est pas synchronized, les lignes des chaque colonne peuvent être déplacées par rapport à l'autre colonne, certains ordres d'exécution auraient donnée des arrayindexoutofboundexception, d'autre auraient mis juste y dans le tableau et d'autres auraient mis x,y, le tout étant aléatoire à chaque excécution.

Donc la règle générale, quand 2 Thread manipulent un ensemble de données communs, faut synchonizer pour garde la cohérence.