Comment utiliser synchronisé pour implémenter le mécanisme de synchronisation en Java ?

Résumé de l'utilisation de synchronisé en Java

1. Lors de l'utilisation de synchronisé comme modificateur de fonction, l'exemple de code est le suivant :

Public synchronized void method(){   //….   }

C'est la méthode de synchronisation. Alors, quel objet est verrouillé par synchronisé à ce moment-là ? Ce qu'il verrouille appelle cet objet méthode synchronisée. En d'autres termes, lorsqu'un objet P1 exécute cette méthode de synchronisation dans différents threads, une exclusion mutuelle sera formée entre eux pour obtenir un effet de synchronisation. Cependant, un autre objet P2 généré par la Classe à laquelle appartient cet objet peut arbitrairement appeler cette méthode en ajoutant le mot-clé synchronisé.
L'exemple de code ci-dessus est équivalent au code suivant :

public void method()   {   synchronized (this)      //  (1)   {          //…..   }   }

À quoi fait référence ce point (1) ? Il fait référence à l'objet qui appelle cette méthode, comme P1. On peut voir que l'essence de la méthode de synchronisation est d'appliquer la synchronisation à la référence d'objet. ——Seul le thread qui a obtenu le verrou d'objet P1 peut appeler la méthode de synchronisation de P1. En ce qui concerne P2, le verrou P1 n'a rien à voir avec cela. Le programme peut également se débarrasser du contrôle du mécanisme de synchronisation. dans ce cas, cela entraîne une confusion des données.

2. Bloc de synchronisation, l'exemple de code est le suivant :

public void method(SomeObject so) {   synchronized(so)   {          //…..   }   }

À ce stade, le verrou est l'objet so, et celui qui obtient le verrou peut exécuter le code qu'il contrôle. Lorsqu'il y a un objet clair comme verrou, vous pouvez écrire le programme comme ceci, mais lorsqu'il n'y a pas d'objet clair comme verrou et que vous souhaitez simplement synchroniser un morceau de code, vous pouvez créer une variable d'instance spéciale (elle doit être un objet) pour agir comme le verrou :

class Foo implements Runnable   {          private byte[] lock = new byte[0];  // 特别的instance变量       Public void method()   {          synchronized(lock) { //… }   }   //…..   }

Remarque : un objet tableau d'octets de longueur nulle sera plus économique à créer que n'importe quel objet - regardez le bytecode compilé : générer un objet byte[] de longueur nulle ne nécessite que 3 opcodes , et Object lock = new Object () nécessite 7 lignes d'opcode.

3. Appliquer synchronisé à une fonction statique. L'exemple de code est le suivant :

      Class Foo   {   public synchronized static void method1()   // 同步的static 函数   {   //….   }   public void method2()   {          synchronized(Foo.class)   //  class literal(类名称字面常量)   }          }

La méthode method2() dans le code utilise un littéral de classe comme verrou. Elle a le même effet que la fonction statique synchronisée, et le verrou obtenu est. très spécial. , est la classe à laquelle appartient l'objet qui appelle actuellement cette méthode (Classe, plutôt qu'un objet spécifique généré par cette Classe).
Je me souviens avoir lu dans le livre "Effective Java" que l'utilisation de Foo.class et P1.getClass() pour les verrous de synchronisation n'est pas la même chose. Vous ne pouvez pas utiliser P1.getClass() pour atteindre l'objectif de verrouiller cette classe. P1 fait référence à l'objet généré par la classe Foo.
Cela peut être déduit : si une fonction statique synchronisée A est définie dans une classe et qu'une fonction d'instance synchronisée B est également définie, alors lorsque le même objet Obj de cette classe accède respectivement aux méthodes A et B dans plusieurs threads, il non Cela constitue une synchronisation car leurs verrous sont tous différents. Le verrou de la méthode A est la classe à laquelle appartient Obj, et le verrou de la méthode B est l'objet auquel appartient Obj.

Un résumé de la façon d'utiliser synchronisé en Java est le suivant :

Comprendre quels verrous synchronisés d'objets peut nous aider à concevoir des programmes multithread plus sûrs.

Il existe également certaines techniques qui peuvent rendre plus sécurisé notre accès synchrone aux ressources partagées :
1. Définissez des variables d'instance privées + leurs méthodes get au lieu de variables d'instance publiques/protégées. Si la variable est définie comme publique, l'objet peut l'obtenir directement et la modifier depuis le monde extérieur, en contournant le contrôle de la méthode de synchronisation. C'est également l'une des méthodes d'implémentation standard de JavaBean.
2. Si la variable d'instance est un objet, tel qu'un tableau ou ArrayList, alors la méthode ci-dessus n'est toujours pas sûre, car lorsque l'objet externe obtient la référence de l'objet d'instance via la méthode get et la pointe vers un autre objet, alors la variable privée est-ce que si ça change, ne serait-ce pas dangereux ? À ce stade, vous devez ajouter une synchronisation synchronisée à la méthode get et renvoyer uniquement le clone() de cet objet privé - de cette manière, l'appelant obtient une référence à la copie de l'objet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!