Quel est le processus de mise à niveau des verrous synchronisés en Java ?

Qu'est-ce qu'un verrouillage synchronisé ? Un verrou est en fait un objet, n'importe lequel peut être utilisé. Tous les objets en Java sont des verrous.
Cette fois, nous parlons principalement de la routine de mise à niveau du verrouillage synchronisé

synchronisé passera par quatre étapes : synchronized会经历四个阶段：无锁状态、偏向锁、轻量级锁、重量级锁依次从耗费资源最少，性能最高，到耗费资源多，性能最差。

锁原理

先看看这些状态的锁为什么称之为锁，他们的互斥原理是啥。

偏向锁

当一个线程到达同步代码块，尝试获取锁对象的时候，会查看对象头中的MarkWord里的线程ID，如果这里没有ID则将自己的保存进去，拿到锁。若是有，则查看是否是当前线程，如果不是，就CAS尝试改，如果是，就已经拿到了锁资源。

这里详细说说CAS尝试修改的逻辑：它会检查持有偏向锁的线程状态。首先遍历当前JVM的所有存活的线程，如果能找到偏向的线程，则说明偏向的线程还存活，此时会检查线程是否在执行同步代码块中的代码，如果是，则升级为轻量级锁，去继续进行CAS竞争锁。所以加了偏向锁之后，同时只有一个线程可以拿到锁执行同步代码块中的代码。

轻量级锁

查看对象头中的MarkWord里的Lock Record指针指向的是否是当前线程的虚拟机栈，如果是，拿锁执行业务，如果不是则进行CAS，尝试修改，若是修改几次都没有成功，再升级到重量级锁。

重量级锁

查看对象头中的MarkWord里的指向的ObjectMonitor，查看owner是否是当前线程，如果不是，扔到ObjectMonitor里的EntryList中排队，并挂起线程，等待被唤醒。

锁升级

无锁

一般情况下，新new出来的一个对象，暂时就是无锁状态。因为偏向锁默认是有延迟的，在启动JVM的前4s中，不存在偏向锁，但是如果关闭了偏向锁延迟的设置，new出来的对象，就会添加一个匿名偏向锁。也就是说这个对象想找一个线程去增加偏向锁，但是没有找到，称之为匿名偏向。存储的线程ID为一堆0000，也没有任何地址信息。

我们可以通过以下配置关闭偏向锁延迟。

//关闭偏向锁延迟的指令
-XX:BiasedLockingStartuoDelay=0

偏向锁

当某一个线程来获取这个锁资源时，此时会成功获取到，就会变为偏向锁，偏向锁存储线程的ID。

当偏向锁升级时，会触发偏向锁撤销，偏向锁撤销需要等到一个安全点，比如GC的时候，偏向锁撤销的成本太高，所以默认开始时，会做偏向锁延迟。若是直接有多个线程竞争，会跳过偏向锁，直接变为轻量级锁。

细说一下偏向锁撤销的过程，成本为啥高呢？当一个线程拿到偏向锁之后，会把锁的对象头的Mark WorkÉtat sans verrouillage, verrouillage biaisé, verrouillage léger, verrouillage lourdAfin de consommer des ressources De au moins, la performance est la plus élevée, à la consommation de ressources, la performance est la pire. Principe de verrouillageVoyons d'abord pourquoi ces verrous d'état sont appelés verrous et quel est leur principe d'exclusion mutuelle. Verrouillage biaisé

Lorsqu'un thread atteint le

bloc de code synchronisé

et tente d'obtenir l'objet de verrouillage, il vérifiera l'ID du thread dans le MarkWord dans l'en-tête de l'objet. ici, il ajoutera sa propre sauvegarde à l'intérieur et obtiendra le verrou. Si c'est le cas, vérifiez s'il s'agit du thread actuel. Sinon, CAS tentera de le modifier. Si c'est le cas, la ressource de verrouillage a été obtenue.

• Voici une description détaillée de la logique que CAS tente de modifier : il

  vérifiera l'état du thread détenant le verrou biaisé

  . Tout d'abord,
parcourez tous les threads survivants
• de la JVM actuelle. Si

  peut trouver

  le thread biaisé, cela signifie que le thread biaisé
est toujours vivant
• À ce moment, il

  vérifiera si le thread exécute le code dans. le bloc de code synchronisé

  , et si tel est le cas, il sera mis à niveau vers un verrou léger et continuera à rivaliser pour les verrous CAS. Par conséquent, après avoir ajouté un verrou biaisé, un seul thread peut obtenir le verrou et exécuter le code dans le bloc de code synchronisé en même temps.
• Verrou léger
  Vérifiez si le pointeur Lock Record dans MarkWord dans l'en-tête de l'objet pointe vers la pile de machine virtuelle du thread actuel. Si tel est le cas, prenez le verrou et. exécutez-le. Business, sinon, exécutez CAS et essayez de le modifier si les modifications échouent plusieurs fois, passez au verrouillage lourd.
• Verrouillage lourd
  Vérifiez le ObjectMonitor pointé dans le MarkWord dans l'en-tête de l'objet pour voir si le propriétaire est le thread actuel. Sinon, lancez-le vers ObjectMonitor< Mettez le thread en file d'attente dans <code>EntryList dans /code> et suspendez le thread, en attendant d'être réveillé.

Mise à niveau du verrouillage

Sans verrouillage

Dans des circonstances normales, un nouvel objet est temporairement dans un état sans verrouillage. Étant donné que les verrous biaisés sont retardés par défaut, il n'y a pas de verrou biaisé dans les 4 premières secondes suivant le démarrage de la JVM. Cependant, si le paramètre de délai de verrouillage biaisé est désactivé, un verrou biaisé anonyme sera ajouté au nouvel objet. C'est-à-dire que cet objet veut trouver un thread pour ajouter un verrou de biais, mais ne peut pas le trouver, ce qu'on appelle un biais anonyme. Les ID de thread stockés sont constitués d'un groupe de 0000 et il n'y a aucune information d'adresse.

Nous pouvons désactiver le délai de verrouillage biaisé grâce à la configuration suivante.

while(){
   synchronized(){
      // 多次的获取和释放，成本太高，会被优化为下面这种
   }
}
synchronized(){
   while(){
       //  拿到锁后执行循环，只加锁和释放一次
   }
}

Verrou biaisé

Quand un fil parvient à

obtenir cette ressource de verrouillage

, il sera acquis avec succès à ce moment-là, et il

deviendra un verrou biaisé, et le verrou biaisé stocke l'ID du fil.

Lorsque le

verrouillage biaisé est mis à niveau

, la

révocation du verrouillage biaisé

sera déclenchée. La révocation du verrouillage biaisé doit attendre un

point de sécurité

, tel que GC, le coût de la révocation du verrouillage biaisé est trop élevé, donc par défaut, la polarisation sera effectuée au début du délai de verrouillage. S'il y a plusieurs threads en concurrence directe, le verrou de biais sera ignoré et deviendra directement un verrou léger. 🎜🎜 Parlons en détail du processus d'annulation du verrouillage de biais. Pourquoi le coût est-il élevé ? Lorsqu'un thread obtient un verrou biaisé, il pointera l'identifiant du thread dans le Mark Work de l'en-tête de l'objet de verrouillage vers lui-même. Lorsqu'un autre thread vient en compétition pour le verrou et que le verrou est mis à niveau, il le fera. 🎜Mettez en pause le fil qui a précédemment obtenu le verrouillage de biais🎜, puis 🎜effacez l'identifiant du fil dans Mark Work🎜, 🎜ajoutez un verrou léger🎜, puis 🎜reprenez le fil suspendu pour continuer l'exécution🎜. C'est également la raison pour laquelle vous attendez un point sûr avant d'effectuer une escalade de verrouillage, car le thread est en pause. 🎜🎜Points de sécurité courants : 🎜🎜🎜🎜Lors de l'exécution de GC🎜🎜🎜🎜Avant le retour de la méthode🎜🎜🎜🎜Après l'appel d'une méthode🎜🎜🎜🎜L'emplacement où l'exception est levée🎜🎜🎜🎜La fin d'une boucle 🎜 🎜 🎜🎜Verrouillage léger🎜🎜En cas de concurrence entre plusieurs threads, il sera mis à niveau vers 🎜Verrouillage léger🎜 L'effet du verrouillage léger est 🎜d'essayer d'obtenir des ressources de verrouillage basées sur CAS🎜, qui seront utilisées ici🎜 Rotation adaptative. lock🎜, en fonction du succès ou de l'échec du dernier CAS et du temps passé, détermine le nombre de tours cette fois. 🎜🎜Les verrous légers conviennent aux scénarios dans lesquels 🎜la concurrence n'est pas très féroce🎜 Un thread obtient le verrou, exécute le bloc de code de synchronisation et le processus se termine rapidement. Un autre thread essaie une ou deux fois d'obtenir le verrou, puis l'exécute à nouveau, ce qui ne fera pas attendre un thread longtemps. 🎜🎜Verrou lourd🎜🎜S'il atteint un verrou lourd, il n'y a rien à dire. Si un fil tient le verrou, les autres fils qui veulent prendre le verrou raccrocheront et attendront que le verrou soit libéré et se réveilleront à leur tour. 🎜. 🎜🎜Grossissement des verrous et élimination des verrous🎜🎜Grossissement des verrous/extension des verrous🎜🎜L'extension des verrous est une optimisation que JIT fait pour nous lors de la compilation de fichiers Java. Elle réduira le nombre d'acquisitions et de versions de verrous. Par exemple : 🎜

while(){
   synchronized(){
      // 多次的获取和释放，成本太高，会被优化为下面这种
   }
}
synchronized(){
   while(){
       //  拿到锁后执行循环，只加锁和释放一次
   }
}

锁消除

锁消除则是在一个加锁的同步代码块中，没有任何共享资源，也不存在锁竞争的情况，JIT编译时，就直接将锁的指令优化掉。 比如

synchronized(){
   int a = 1;
   a++;
   //操作局部变量的逻辑
}

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!