Qu'est-ce que Java synchronisé

Qu'est-ce qui est synchronisé

Chers lecteurs Java, vous n'êtes pas étranger au mot-clé synchronisé. Il peut être vu dans divers codes sources de middleware ou de lecteurs JDK qui ne sont pas familiers avec synchronisé uniquement. savoir Vous devez utiliser le mot-clé synchronisé en multi-threading, sachant que synchronisé peut garantir la sécurité des threads.

• est appelé : verrouillage mutex (un seul thread peut s'exécuter en même temps, les autres threads attendront)

• # 🎜🎜# Également connu sous le nom de : verrouillage pessimiste (un seul thread peut s'exécuter en même temps, les autres threads attendront)

• La machine virtuelle JVM vous aide à implémenter et à développer Ou utilisez simplement le mot-clé synchronisé.

• Vous devez utiliser un objet comme mutex de verrouillage

• pour garantir qu'un morceau de code ( zone critique) atomicité + visibilité.

Analyse du mot-clé synchronisé à partir du niveau du bytecode

Il est plus approprié de commencer par un cas.

class Demo1{
    // 互斥对象
    static Object object = new Object();
    // 竞争条件
    static int cout = 0;
    public static void main(String[] args) {
        // 互斥
        synchronized(object){
            // 以下是临界区
            cout++;
            System.out.println("synchronized");
        }
    }
}

Nous ne pouvons rien dire uniquement à partir du code Java, et le programme Java est compilé dans un fichier de bytecode, nous analysons donc à nouveau le bytecode

Pool constant :
   #1 = Methodref          #7.#26         // java/lang/Object."7e51f00a783d7eb8f68358439dee7daf":()V
   #2 = Fieldref           #8.#27         // Demo1.object:Ljava /lang/Object;
   #3 = Fieldref           #8.#28         // Demo1.cout:I
   #4 = Fieldref           #29.#30          // java/lang/System.out:Ljava/io/PrintStream;
   # " #34            // java/lang/ Objet
   #8 = Classe              #35            // Démo1
   #9 = Utf8               object
  #10 = Utf8               Ljava/lang/Object;
  #11 = Utf8              cout
  #12 = Utf8                I
  #13 = Utf8               7e51f00a783d7eb8f68358439dee7daf
#14 = Utf8               ()V
  #15 = Utf8               Code
  #16 = Utf8               LineNumberTable
  #17 = Utf8              main
  #18 = Ut f8               ([Ljava/lang/String;)V
  #19 = Utf8               StackMapTable
  #20 = Classe              #36            // "[Ljava/lang/String;"
  #21 = Classe              #34            // java/lang/Object
  #22 = Classe              #37         // java/lang/Throwable
  #23 = Utf8                 #24 = Utf8               SourceFile
  #25 = Utf8               Demo1.java
  #26 = NameAndType        #13:#14        // "7e51f00a783d7eb8f68358439dee7daf":()V
  #27 = NameAndType        #9:#10         // objet :Ljava/lang/Object;
  #28 = NomEtType        #11:#12        // cout:I
  #29 = Classe              #38            // java/lang/System
  #30 = NomEtType        #39:#40       // sortie : Ljava/io/PrintStream;
  #31 = Utf8              synchronisé
  #32 = Classe              #41            // java/io/PrintStream
  #33 = NameAndType        #42:#43       // println :(Ljava/lang/String;)V
#34 = Utf8               java/lang/Object
  #35 = Utf8               Démo1
#36 = Utf8               [Ljava/lang/String;
  #37 = Utf8               java/ lang/Throwable
  #38 = Utf8               java/lang/System
  #39 = Utf8              out
  #40 = Utf8               Ljava/io/PrintStream;
  #41 = Utf8               java/io/PrintStream
  #42 = Utf8               println
  #43 = Utf8               (Ljava/lang/String;)V
         0 : getstatic      #2 // 从2号常量池中拿到静态变量，压入到操作数栈中                  
         3: dup                     //把操作数栈栈顶的对象赋值一份
4 : ASTORE_1 // Sauvegarde les données de la pile de numéros d'exploitation dans la table de variables locales n°1, utilise le release lock
5 : Monitorenter // ouverture de verrouillage mutuel, c'est aussi le niveau de byte code syndronisé
6 : getstation #3 // / Récupère la variable statique du pool de constantes n°2 et la pousse dans la pile d'opérandes
9 : iconst_1 9 : iconst_1 // Pousse la constante 1 dans la pile d'opérandes
10 : iadd 10 : iadd Consomme les données des deux piles d'opérandes, Ajouter, puis pousser vers le haut de la pile
          11 : putstatic     #3         // Attribuer la variable en haut de la pile d'opérandes au pool de constantes n° 3
    14 : getstatic     #4                          17 : DC #5 / / Analysez les symboles du pool régulier n°5, récupérez la constante de chaîne "Synchronisée"
19 : Invirtual #6 // exécute la fonction Println, consomme 2 opérations de pile
22 : ALOAD_1 // 1 sera 1 Les données dans la variable locale le numéro de table est poussé sur la pile d'opérandes
23 : sortie du moniteur // La fin du verrouillage mutex est également implémentée au niveau du bytecode de synchronisé
24 : goto 32 // Passer à la ligne 32. Concernant 27 : ASTORE_2 // Il peut y avoir des anomalies, mais le verrou est nécessaire, alors placez l'objet anormal dans la table de variables locales 2
28 : ALOAD_1 // Appuyez les données de la table de variables locales en haut de la pile de numéros d'exploitation pour le pile de la pile d'exploitation pour l'approvisionnement pour la pile de la pile d'exploitation pour l'approvisionnement pour la pile de la pile du numéro d'exploitation est utilisée
29 : monitorexit               // Il peut y avoir une exception, mais le verrou. doit être libéré, sinon il sera dans l’impasse. A 30 : ALOAD_2 // Appuyez sur l'objet anormal de la table de variables locales 2 vers le haut de la pile de numéros d'exploitation
31 : Atthrow // Il y a une anomalie qui est rejetée
32 : Return // Function Return


Ce qui précède est le code d'octet La solution complète est en fait très simple. Enfin, le mot-clé Synchronized est analysé en octets dans les instructions de bytecode Monitorenter et MonitorExit. Puis, à chaque fois avant d'exécuter ces deux instructions de bytecode, l'objet mutex est poussé dans la pile d'opérandes pour fournir Monitorenter et. Monitorexit. Les instructions de bytecode sont utilisées.

Le prochain article consiste donc à accéder au code source du Hotspot pour analyser le processus détaillé des instructions de bytecode Monitorenter et MonitorExit.

La différence entre Synchronized et ReentrantLock

Il s'agit d'une question d'entretien très courante, et elle est posée très fréquemment lors des entretiens

Similarités :

Les deux sont des implémentations de verrous mutex

Différences :

Synchronisé basé sur le implémentation interne de la JVM, ReentrantLock est implémenté au niveau Java (mais le code principal de ReentrantLock appelle toujours du code C++).

• Synchronized a été optimisé après la version 1.6. Il existe plusieurs niveaux de verrouillage différents. La force du verrouillage est augmentée en fonction de l'intensité de la concurrence des threads (communément appelée mise à niveau du verrouillage). est légèrement rigide dans le choix de la force de verrouillage.

• Bien que ReentrantLock soit légèrement rigide dans la sélection de la force de verrouillage, vous pouvez choisir entre juste et injuste, tandis que Synchronisé ne peut être que des verrous injustes

• La file d'attente conditionnelle de ReentrantLock peut créer plusieurs verrous hautement personnalisés. Il n’y a qu’une seule file d’attente au bas de Synchronisé.

• ReentrantLock nécessite que l'utilisateur ouvre manuellement le verrou et le libère manuellement. La couche inférieure du mot-clé synchronisé est automatiquement implémentée via le bytecode

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!