Was ist der Upgrade-Prozess synchronisierter Sperren in Java?

Was ist eine synchronisierte Sperre? Eine Sperre ist eigentlich ein Objekt. Alle Objekte in Java sind Sperren. Mit anderen Worten: Alle Objekte in Java können zu Sperren werden.
Dieses Mal sprechen wir hauptsächlich über die Routine des synchronisierten Sperren-Upgrades

synchronisiert durchläuft vier Phasen: 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 WorkKein Sperrstatus, voreingenommene Sperre, Leichte Volumensperren und Schwergewichtssperren sind von der Reihenfolge, in der sie die geringsten Ressourcen verbrauchen und die höchste Leistung haben, bis hin zu denen, die viele Ressourcen verbrauchen und die schlechteste Leistung haben, sortiert. Sperrprinzip Schauen wir uns zunächst an, warum diese Statussperren Sperren genannt werden und was ihr gegenseitiges Ausschlussprinzip ist. Voreingenommene Sperre

Wenn ein Thread den

synchronisierten Codeblock

erreicht und versucht, das Sperrobjekt abzurufen, wird er den einchecken der Objekt-Header. Die Thread-ID in MarkWord. Wenn hier keine ID vorhanden ist, speichern Sie Ihre eigene und holen Sie sich die Sperre. Wenn dies der Fall ist, prüfen Sie, ob es sich um den aktuellen Thread handelt. Wenn nicht, versucht CAS, ihn zu ändern. Wenn dies der Fall ist, wurde die Sperrressource erhalten.

• Hier ist eine detaillierte Beschreibung der Logik, die CAS zu ändern versucht: Es

  überprüft den Status des Threads, der die voreingenommene Sperre hält

  . Durchlaufen Sie zunächst alle verbleibenden Threads
der aktuellen JVM. Wenn
• den

  voreingenommenen Thread finden kann, bedeutet dies, dass der voreingenommene Thread

  noch am Leben ist #, dies Es wird
prüfen, ob der Thread den Code
• im synchronisierten Codeblock ausführt. Wenn ja, wird er auf eine leichte Sperre aktualisiert und konkurriert weiterhin um CAS-Sperren. Daher kann nach dem Hinzufügen einer voreingenommenen Sperre nur ein Thread gleichzeitig die Sperre erhalten und den Code im synchronisierten Codeblock ausführen.
  Lightweight lock
• Überprüfen Sie, ob der Lock Record-Zeiger im MarkWord im Objektheader auf das aktuelle For zeigt Wenn dies der Fall ist, verwenden Sie die Sperre, um das Geschäft auszuführen. Wenn dies nicht der Fall ist, führen Sie CAS aus und versuchen Sie, ihn zu ändern. Wenn die Änderungen mehrmals erfolglos sind, führen Sie ein Upgrade auf eine schwere Sperre durch.
  Heavyweight Lock
• Überprüfen Sie den ObjectMonitor, auf den im MarkWord im Objektheader verwiesen wird, um festzustellen, ob der Eigentümer der Besitzer ist Wenn nicht, wird der aktuelle Thread in die Warteschlange in der EntryList in ObjectMonitor geworfen, und der Thread wird angehalten und wartet darauf, geweckt zu werden.
  UPGRADE SPERREN

无码

Unter normalen Umständen ist

vorerst ein neues Objekt 🎜 🎜#无LOCKSTATE. Da voreingenommene Sperren standardmäßig verzögert sind, erfolgt in den ersten 4 Sekunden nach dem Starten der JVM keine voreingenommene Sperre. Wenn die Einstellung für die voreingenommene Sperre jedoch deaktiviert ist, wird dem neuen Objekt eine anonyme voreingenommene Sperre hinzugefügt. Das heißt, dieses Objekt möchte einen Thread zum Hinzufügen einer Bias-Sperre finden, kann aber keinen finden, was als anonyme Bias bezeichnet wird. Die gespeicherten Thread-IDs bestehen aus einer Reihe von 0000 und es gibt keinerlei Adressinformationen. Wir können die Bias-Lock-Verzögerung durch die folgende Konfiguration deaktivieren.

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

Voreingenommene Sperre

Wenn ein Thread zu kommt, um diese Sperrressource zu erhalten, wird sie zu diesem Zeitpunkt erfolgreich abgerufen, und das wird auch so sein #🎜🎜 #Zur voreingenommenen Sperre wechseln

, die voreingenommene Sperre speichert die ID des Threads.

Wenn

Voreingenommene Sperren-Upgrades, Voreingenommene Sperren-Aufhebung

wird ausgelöst, bis eine

Sicherheit erfolgt Punkt#🎜 🎜#Beispielsweise sind während der GC die Kosten für den Widerruf voreingenommener Sperren zu hoch, sodass standardmäßig zu Beginn eine voreingenommene Sperrverzögerung durchgeführt wird. Wenn mehrere Threads direkt konkurrieren, wird die Bias-Sperre übersprungen und direkt zu einer Lightweight-Sperre.

Lassen Sie uns ausführlich über den Prozess der Aufhebung der Bias-Sperre sprechen. Wenn ein Thread eine voreingenommene Sperre erhält, verweist er die Thread-ID im Mark Work des Sperrobjektheaders auf sich selbst. Wenn ein anderer Thread um die Sperre konkurriert und die Sperre aktualisiert wird, wird dies der Fall sein

Pausieren Sie den Thread, der zuvor die Bias-Sperre erhalten hat

, dann

Löschen Sie die Thread-ID in Mark Work #🎜🎜#, #🎜🎜#Fügen Sie eine leichte Sperre hinzu #🎜🎜# und dann Dann #🎜🎜# den angehaltenen Thread fortsetzen und mit der Ausführung von #🎜🎜# fortfahren. Aus diesem Grund warten Sie auch bis zu einem sicheren Punkt, bevor Sie eine Sperrenausweitung durchführen, da der Thread angehalten ist. #🎜🎜##🎜🎜#Gemeinsame Sicherheitspunkte: #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Beim Ausführen von GC#🎜🎜##🎜🎜##🎜🎜##🎜🎜#Methode Rückkehr vorher #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Nach dem Aufruf einer Methode#🎜🎜##🎜🎜##🎜🎜##🎜🎜#Der Ort, an dem die Ausnahme ausgelöst wird#🎜🎜##🎜 🎜 ##🎜🎜##🎜🎜#Das Ende einer Schleife#🎜🎜##🎜🎜##🎜🎜##🎜🎜#Leichte Sperre#🎜🎜##🎜🎜#Wenn mehrere Threads erscheinen Der Wettbewerb wird auf # hochgestuft 🎜🎜#Lightweight Lock#🎜🎜# Der Effekt von Lightweight Lock ist #🎜🎜#Versuchen Sie, Sperrressourcen basierend auf CAS#🎜🎜# zu erhalten, #🎜🎜# wird hier an die Spin-Sperre #🎜🎜 angepasst # Die Anzahl der Drehungen wird dieses Mal anhand des Erfolgs oder Misserfolgs des letzten CAS und der dafür benötigten Zeit bestimmt. #🎜🎜##🎜🎜#Leichte Sperren eignen sich für Szenarien, in denen #🎜🎜# die Konkurrenz nicht sehr groß ist. #🎜🎜# Ein Thread erhält die Sperre, führt den Synchronisierungscodeblock aus und der Vorgang ist schnell abgeschlossen. Ein anderer Thread versucht ein- oder zweimal, die Sperre zu erhalten, und führt sie dann aus, sodass ein Thread nicht lange warten muss. #🎜🎜##🎜🎜#Schwergewichtssperre#🎜🎜##🎜🎜# Wenn es eine Schwergewichtssperre erreicht, gibt es nichts zu sagen. Wenn ein Thread die Sperre hält, können andere #🎜🎜# die Sperre übernehmen, wenn sie möchten Zum Anhalten warten Sie, bis die Sperre aufgehoben wird, und werden wiederum geweckt #🎜🎜#. #🎜🎜##🎜🎜#Lock-Vergröberung und Lock-Eliminierung#🎜🎜##🎜🎜#Lock-Vergröberung/Lock-Erweiterung#🎜🎜##🎜🎜#Lock-Erweiterung ist das, was JIT für uns beim Kompilieren von Java-Dateien tut reduziert die Anzahl der Sperrerfassungs- und -freigabezeiten. Zum Beispiel: #🎜🎜#

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

锁消除

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

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

Das obige ist der detaillierte Inhalt vonWas ist der Upgrade-Prozess synchronisierter Sperren in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!