Discussion :

[l'unique]

bonjour, j'aimerais savoir, si un "synchronized" sur une méthode pose un verrou sur l'accès à cette méthode ou sur l'ensemble de l'objet?

Merci de votre compréhension.

[bulbo]

La ressource protégée par un synchronized est un objet, l'accès à un bloc ou à une méthode synchronized sur un même objet sera autorisé à la condition qu'aucun autre thread ne soit actif dans un de ces blocs.

Bulbo

[tchize_]

Code :

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

 synchronized void methode(){........}

est équivalent à

Code :

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

1
2
3
4
5
 void methode(){
   synchronized(this){ 
        ......
   }
}

et

Code :

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

 static synchronized void methode(){........}

est équivalent à

Code :

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

1
2
3
4
5
static void methode(){
   synchronized(CetteClasse.class){ 
        ......
   }
}

[l'unique]

d'après ce que vous m'avais dit, j'ai essayé de comprendre ou se situe l'interblocage dans le code suivant; je voudrais savoir si c'est bien là où est l'interblocage.
Je pense que l'interblocage se situe dans la méthode synchronized(writeLock), ai-je raison?
Pour supprimer cet interblocage que faudrait-il 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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
public class Oups {
     private int value;
 
     public void setValue(int value) {
       synchronized(readLock) {
         synchronized(writeLock) {
           this.value=value;
         }
       }
     }
 
     public int getValue() {
       synchronized(readLock) {
        return value;
       }
     }
 
     public void performs() throws InterruptedException {
       Thread t = new Thread() {
         public void run() {
           setValue(12);
         }
       };
 
       synchronized(writeLock) {
         t.start();
         Thread.sleep(1000);
 
         System.out.println(getValue());
       }
     }
 
     private final Object readLock = new Object();
     private final Object writeLock = new Object();
 
     public static void main(String[] args) throws InterruptedException {
       Oups oups = new Oups();
       oups.performs();
     }
   }

Merci de votre compréhension.

[tchize_]

l'interblocage viens du fait que d'un coté vous faites l'acquisition de readlock avant writelock et de l'autre coté l'inverse. Lorsque vous faites l'acquisition de verrous multiples, assurez vous toujours de faire l'acquistion dans le même ordre!

Ici, cette correction suffirait:

Code :

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

1
2
3
4
5
6
7
8
9
 
synchronized(readLock){
    synchronized(writeLock) { // writeLock requiert readLock
         t.start();
         Thread.sleep(1000);
 
         System.out.println(getValue());
       }
}

a noter qu'il existe déjà des apis toutes faites (dans commons transaction par exemple) pour gérer les verrous à niveaux multiples

[Logan Mauzaize]

C'est quoi l'intérêt de synchroniser sur writeLock dans le "Main" thread ?

[l'unique]

tchize, est ce que le synchonized dans le getValue() doit être supprimer avant pour faire la modification que tu viens de me dire?

voici le code j'ai supprimé le synchronized dans la getValue():

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
32
33
34
35
36
37
38
39
40
 
public class Oups {
     private int value;
 
     public void setValue(int value) {
       synchronized(readLock) {
         synchronized(writeLock) {
           this.value=value;
         }
       }
     }
 
     public int getValue() {
        return value;
     }
 
     public void performs() throws InterruptedException {
       Thread t = new Thread() {
         public void run() {
           setValue(12);
         }
       };
     synchronized(readLock) {
       synchronized(writeLock) {
         t.start();
         Thread.sleep(1000);
 
         System.out.println(getValue());
       }
     }
	}
 
     private final Object readLock = new Object();
     private final Object writeLock = new Object();
 
     public static void main(String[] args) throws InterruptedException {
       Oups oups = new Oups();
       oups.performs();
     }
   }

qu'en penses tu?

[tchize_]

ben non y a pas de raison de le retire, ou alors le readLock n'a plus aucun sens si tu lit sans acquérir ce lock

[l'unique]

merci de ton aide....