Discussion :

[soad]

hello tout le monde...

j'ai quelque question sur le synchronized...


toute les methodes qui ont un synchronized ne peuvent pas être exécuté si une des méthodes est en cours d'exécution ! c'est bien ca ???


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
 
 
public classe Calcule {
  private int x = 5, y = 2, resultat;
 
 
  public synchronized void additionne() {
 
    resultat = x+y;
  }
 
 
  public synchronized int getResultat() {
 
    return resultat;
  }
 
 
  public int getX() {
 
    return x;
  }
}

si j'ai un Thread qui exécute la méthode additionne() seule la methode getX() pourra être appeler par un autre Thread ???

[herve91]

toute les methodes qui ont un synchronized ne peuvent pas être exécuté si une des méthodes est en cours d'exécution ! c'est bien ca ???

oui, pour un même objet, si une des méthodes synchronized est en cours d'exécution.

si j'ai un Thread qui exécute la méthode additionne() seule la methode getX() pourra être appeler par un autre Thread ???

Exactement, sur la même instance d'objet.

[Shiftane]

Lorsque tu mets synchonized, la méthode ou la classe ne peut être utilisé que par un seul Thread à la fois.
Maintenant dans ton cas, tes méthodes ne pourront être exécuté en même temps par deux Threads différents, l'un des deux devra attendre que l'autre ait fini.

[soad]

ok alors si je fais ca:

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
 
 
public classe Calcule { 
  private int x = 5, y = 2, resultat; 
 
 
  public synchronized void additionne() { 
 
    resultat = x+y; 
  } 
 
 
  public synchronized int getResultat() { 
 
    additionne();
    return resultat; 
  } 
}

est ce que une methode synchronized peut en appeler une autre ? vu que getResultat() est en cours d'exécution est ce que additionne() pourra etre appeller ?

[herve91]

Oui, car le moniteur (l'objet attaché à ton instance de Calcule qui sert au contrôle des accès concurrents) est déjà pris par la méthode getResultat(), il ne sera relaché qu'à la fin de son exécution.

[Shiftane]

Mais le mieux, et dites moi si je me trompe, est de mettre ta classe en synchronized...

[herve91]

Le mot-clé synchronized n'existe pas au niveau classe...

[soad]

oki merci beaucoup pour vos réponse

[ghorgor]

A priori, (mais j'avoue que tu me mets le doute..) je te dirai oui, parce que tu es déjà dans l'objet qui appelle la méthode... tu restes en interne, tu ne sors pas de ton thread dans ton execution...

Maintenant, ca n'a pas forcement de sens de le faire comme ca, dans ton cas...

Si tu fais un traitement en synchronized, y'a t'il un interet à ce que additionne soit en synchronized si pour l'appeler tu passes par GetResultat ?

Ou y a t'il vraiment besoin d'appeler additionne dans GetResultat, alors que tu peux y accéder directement avant ?
Pour moi, ca n'a pas lieu d'etre dans GetResultat, mais c'est mon avis perso... Ne mets en synchronized que ce qui a réellement besoin de l'être.

[herve91]

A priori, (mais j'avoue que tu me mets le doute..) je te dirai oui, parce que tu es déjà dans l'objet qui appelle la méthode... tu restes en interne, tu ne sors pas de ton thread dans ton execution...

Ca signifie quoi "tu ne sors pas de ton thread dans ton execution" ?
Comment peut-on sortir d'un thread ?
Ca marche tout simplement parce que le moniteur est le même pour toutes les méthodes synchronisées. Quand on fait :

Code :

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

1
2
3
public synchronized void additionne() { 
  resultat = x+y; 
}

c'est équivalent à :

Code :

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

1
2
3
4
5
public void additionne() { 
  synchronized(this) {
    resultat = x+y; 
  }
}

le moniteur est l'objet "this" (l'instance courante).
Mais on peut très bien faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Objet monitor = new Object();
 
public void additionne() { 
  synchronized(monitor) {
    resultat = x+y; 
  }
}
 
public int getResultat() { 
  synchronized(monitor) {
    additionne();
    return resultat;
  }
}

Dans ce cas, la synchronisation n'a lieu que sur les accès à l'objet "monitor", et pas sur "this".

[ghorgor]

Ca signifie quoi "tu ne sors pas de ton thread dans ton execution" ?
Comment peut-on sortir d'un thread ?

Scuse moi hervé, t'énerve pas, j'avoue en me relisant que je me suis très mal exprimé et que le terme thread etait très mal utilisé... Pas taper s'il te plait...

[herve91]

Non, non, pas taper...

[ghorgor]

Il y avait quand meme une certaine poesie lyrique ayant trait avec l'usage de substances illicites, pour ca, j'ai droit a un coup de marteau en moins quand meme ?

Si tu utilises Java avec une conception non euclidienne, et avec un bon zeste de relativité, je suis sur que tu arriveras a y trouver un sens...

Bon, j'arrete, sinon, ca va partir en delire...

[soad]

Si tu fais un traitement en synchronized, y'a t'il un interet à ce que additionne soit en synchronized si pour l'appeler tu passes par GetResultat ?

Ou y a t'il vraiment besoin d'appeler additionne dans GetResultat, alors que tu peux y accéder directement avant ?
Pour moi, ca n'a pas lieu d'etre dans GetResultat, mais c'est mon avis perso... Ne mets en synchronized que ce qui a réellement besoin de l'être.

Oui dans ce cas si y a pas d'intéret mais c'étais juste un exemple bidon pour savoir si ca marchais !

[adiGuba]

Salut,

Cela ne répond pas à la question mais c'est juste pour information : depuis Java 5.0 il est possible de gérer les blocs synchronized via du code avec l'interface Lock et sa principale implémentation ReentrantLock :

Code :

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

1
2
3
4
5
6
7
8
Lock l = ...; 
 
l.lock();
try {
         // access aux ressources protégés
} finally {
	l.unlock();
}

Le principal intérêt étant l'existance des méthodes tryLock() et tryLock(long,TimeUnit) qui permettent d'effectuer un traitement secondaire si le lock n'est pas disponible...

Par exemple si on veut faire autre chose si on n'obtient pas la main au bout de 5 secondes :

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
 
private Lock lock = new ReentrantLock();
 
public void method() {
	String lResult = null;
	if (lock.tryLock(5, TimeUnit.SECONDS)) {
		try {
              		// Traitement synchronisé
		} finally {
			lock.unlock();
		}
	} else {
		// Traitement alternatif non-synchronizé
      }
}

a++

[Gfx]

On peut aussi synchroniser des blocs de code sur un moniteur qu'on a defini (si on n'a pas Java 5) :

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
 
class MaClasse {
  private Object lock = new Object();
 
  public void calcul() {
    synchronized(lock) {
      // ...
    }
  }
 
  public int getResultat() {
    synchronized(lock) {
      // ...
    }
  }

Mais il vaut mieux utiliser les solutions du JDK 1.5.