Principe de synchronisation des mots clés Java et exemple d'analyse de l'état du verrouillage

1. Le concept de verrou en Java

• Spin lock : signifie que lorsqu'un thread acquiert le verrou, si le verrou a été acquis par d'autres threads, alors le thread attendra en boucle, puis déterminera en continu si le Le verrou peut être acquis avec succès, la boucle ne se terminera pas tant que le verrou n'est pas acquis.

• Verrouillage optimiste : en supposant qu'il n'y a pas de conflit, si les données s'avèrent incohérentes avec les données précédemment obtenues lors de la modification des données, lisez les dernières données et réessayez la modification.

• Verrouillage pessimiste : supposez que des conflits de concurrence se produiront, synchronisez toutes les opérations liées aux données et démarrez le verrouillage à partir de la lecture des données.

• Verrouillage exclusif (écriture) : ajoutez un verrou en écriture à la ressource, le thread peut modifier la ressource et les autres threads ne peuvent pas la verrouiller à nouveau (écriture unique).

• Verrou partagé (lecture) : après avoir ajouté un verrou en lecture à une ressource, celle-ci ne peut être que lue mais pas modifiée. Les autres threads ne peuvent ajouter que des verrous en lecture et ne peuvent pas ajouter de verrous en écriture (plusieurs). Pensez-y simplement comme à un sémaphore (sémaphore).

• Verrous réentrants et verrous non réentrants : une fois qu'un thread a obtenu un verrou, il peut entrer librement un autre code synchronisé par le même verrou.

• Serrure équitable et serrure injuste : L'ordre de compétition pour les serrures est juste s'il est premier arrivé, premier servi. C'est-à-dire qu'il s'agit d'un verrou équitable si l'ordre de saisie du verrou et l'ordre de saisie du verrou sont garantis être les mêmes.

2. Fonctionnalités synchronisées par mot-clé synchronisé

Caractéristiques : verrouillage réentrant, exclusif et pessimiste.

Optimisations liées au verrouillage :

• Élimination du verrouillage : les paramètres permettant d'activer l'élimination du verrouillage sont -XX:+DoEscapeAnalysis, -XX:+EliminateLocks. -XX:+DoEscapeAnalysis、 -XX:+EliminateLocks。

• 锁粗化：JDK做了锁粗化的优化，但我们自己可从代码层面优化。

1、锁消除示例

/**
 * 锁消除示例，JIT即时编译，进行了锁消除
 * @author 刘亚楼
 * @date 2020/1/16
 */
public class LockEliminationExample {
	/**
	 * StringBuilder线程不安全，StringBuffer用了synchronized关键字，是线程安全的
	 * 针对下面这种单线程加锁、解锁操作，JIT会进行优化，进行锁消除
	 */
	public static void eliminateLock() {
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append("a");
		stringBuffer.append("b");
		stringBuffer.append("c");
		stringBuffer.append("a");
		stringBuffer.append("b");
		stringBuffer.append("c");
		stringBuffer.append("a");
		stringBuffer.append("b");
		stringBuffer.append("c");
	}
}

2、锁粗化示例

/**
 * 锁粗化示例
 * @author 刘亚楼
 * @date 2020/1/16
 */
public class LockCoarseningExample {
	/**
	 * 针对下面这种无意义的加锁操作，JIT会进行优化，对变量i的所有操作放到一个同步代码块里
	 */
	public static void lockCoarsening() {
		int i = 0;
		synchronized (LockCoarseningExample.class) {
			i++;
		}
		synchronized (LockCoarseningExample.class) {
			i--;
		}
		synchronized (LockCoarseningExample.class) {
			i++;
		}
		synchronized (LockCoarseningExample.class) {
			i++;
			i--;
			i++;
		}
	}
}

备注：锁消除和锁粗化的区别在于锁消除是针对单个线程重复加解锁做的优化，最终没有锁的存在。而锁粗化不只是针对单线程，且最终还是有锁的存在。

三、synchronized关键字原理

1、关于Mark Word

首先，对象在堆中由对象头、实例数据和对齐填充组成。

对象头包含两部分信息，第一部分用于存储对象自身的运行时数据，如哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向锁id等，这部分数据官方称为"Mark Word"。

对象头的另一部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。

synchronized实现的锁是通过改变对象头的"Mark Word"来实现的。

"Mard Word"在32位和64位的虚拟机(未开启压缩指针)中分别为32位和64位。32位虚拟机"Mark Word"如下：

2、锁的状态变化

(1) 无锁 → 轻量级锁

无锁变成轻量级锁时，多个线程会读取对象的对象头的无锁状态mark word内容，然后进行cas操作进行修改，预期值是无锁状态mark word内容，新值是轻量级锁状态mark word内容，若修改成功，Lock record address指向成功获取锁的线程的Lock Record。

演示流程如下：

(2) 轻量级锁 → 重量级锁

由于未成功获取锁的线程会自旋，长时间自旋会消耗CPU资源，因此自旋到一定次数会进行锁升级，由轻量级锁转变为重量级锁。

重量级锁是通过object monitor(对象监视器)实现的，对象监视器包括entryList(锁池)、owner(持锁者)、waitSet(等待集合)等。

升级为重量级锁时对象头mark word的内容是monitor address(对象监视器地址)，指向对象监视器。

演示流程如下：

备注：抢锁失败线程会进入entryList(锁池)，在调用wait方法后，线程会进入waitSet(等待集合)，waitSet中的线程被唤醒后会重新进入entryList。

(3) 关于偏向锁

加锁之后不解锁，针对单线程

所谓偏向就是偏心，单线程加锁之后就不再解锁，减少了加锁→业务处理→释放锁→加锁操作流程。

在JDK6以后，默认已经开启了偏向锁这个优化，通过JVM参数-XX:-UseBiasedLocking

Grossissement des verrous : JDK a optimisé le grossissement des verrous, mais nous pouvons l'optimiser nous-mêmes au niveau du code.

1. Exemple d'élimination de verrou

rrreee

2. Exemple de grossissement de verrou

rrreee🎜Remarque : La différence entre l'élimination de verrou et le grossissement de verrou est que l'élimination de verrou est répétée pendant un certain temps. thread unique. L'optimisation effectuée par le déverrouillage élimine finalement l'existence de verrous. Le grossissement des verrous ne concerne pas seulement les threads uniques, mais en fin de compte, il existe toujours des verrous. 🎜🎜3. Principe du mot-clé synchronisé🎜

1. À propos de Mark Word

🎜Tout d'abord, l'objet dans le tas se compose d'un en-tête d'objet, de données d'instance et d'un remplissage d'alignement. 🎜🎜L'en-tête de l'objet contient deux parties d'informations. La première partie est utilisée pour stocker les données d'exécution de l'objet lui-même, telles que le code de hachage, l'âge de génération GC, l'indicateur d'état du verrouillage, le verrou détenu par le thread, l'ID de verrouillage biaisé, etc. . Cette partie des données est officielle. Elle s'appelle "Mark Word". 🎜🎜L'autre partie de l'en-tête de l'objet est le pointeur de type, qui est le pointeur de l'objet vers ses métadonnées de classe. La machine virtuelle utilise ce pointeur pour déterminer de quelle classe l'objet est une instance. 🎜🎜Le verrou implémenté par synchronisé est implémenté en modifiant le "Mark Word" de l'en-tête de l'objet. 🎜🎜 "Mard Word" est respectivement en 32 bits et 64 bits dans les machines virtuelles 32 bits et 64 bits (les pointeurs compressés ne sont pas activés). La machine virtuelle 32 bits "Mark Word" est la suivante : 🎜🎜🎜

2. Modifications de l'état du verrouillage

(1) Pas de verrouillage→ verrouillage léger

🎜Lorsqu'aucun verrou ne devient un verrou léger, plusieurs threads lira le contenu du mot de marque d'état sans verrouillage de l'en-tête de l'objet, puis effectuera des opérations cas pour le modifier. La valeur attendue est le contenu du mot de marque d'état sans verrouillage, et la nouvelle valeur est un. verrou léger. Contenu du mot de la marque d'état, s'il est modifié avec succès, Adresse de l'enregistrement de verrouillage pointe vers le Enregistrement de verrouillage du thread qui a acquis avec succès le verrou. 🎜🎜Le processus de démonstration est le suivant : 🎜🎜🎜

(2) Verrouillage léger→ Verrouillage lourd

🎜Étant donné que le thread qui ne parvient pas à acquérir le verrou tournera, la rotation à long terme consommera des ressources CPU, donc la rotation atteindra un certain limit Le verrou sera mis à niveau à plusieurs reprises, passant d'un verrou léger à un verrou lourd. 🎜🎜Les verrous lourds sont implémentés via des moniteurs d'objets, qui incluent EntryList (pool de verrous), le propriétaire (détenteur du verrou), waitSet (wait set), etc. 🎜🎜Lors de la mise à niveau vers un verrou lourd, le contenu du mot de marque d'en-tête d'objet est l'adresse du moniteur (adresse du moniteur d'objet), pointant vers le moniteur d'objet. 🎜🎜Le processus de démonstration est le suivant : 🎜🎜🎜🎜Remarque : Le thread qui ne parvient pas à saisir le verrou entrera dans la liste d'entrée (pool de verrouillage). Après avoir appelé la méthode wait, le thread entrera dans le waitSet (ensemble en attente). Le thread dans le waitSet sera re -entrez dans la liste d'entrées après avoir été réveillé. 🎜

(3) À propos des verrous biaisés

🎜Pas de déverrouillage après le verrouillage, pour les threads uniques🎜🎜Le soi-disant biais signifie biais Après le verrouillage d'un seul thread, il ne se déverrouillera plus, ce qui réduit le verrouillage→le traitement métier&rarr. ; Libérez le verrouillage→ Processus d'opération de verrouillage. 🎜🎜Après JDK6, l'optimisation du verrouillage de biais a été activée par défaut. Le verrouillage de biais est désactivé via le paramètre JVM -XX:-UseBiasedLocking. Si le verrouillage de biais est activé, un seul thread peut le saisir. le verrou et obtenir le biais. 🎜🎜À propos du mot Bias Lock Mark, le contenu est le suivant : 🎜🎜🎜🎜

La marque de biais est utile pour la première fois, mais devient inutile une fois qu'un conflit se produit.

L'essence du verrouillage biaisé est qu'il est sans verrouillage. S'il n'y a pas de concurrence multithread pour le verrouillage, la JVM le considère comme un seul thread et aucune synchronisation n'est requise.

Remarque : Afin de réduire le travail de la JVM, la synchronisation est implémentée par de nombreuses opérations au bas de la JVM. S'il n'y a pas de conflit, il n'est pas nécessaire d'effectuer des opérations de synchronisation.

(4) Processus complet de mise à niveau du verrouillage

Si le verrouillage biaisé n'est pas activé, l'état sans verrouillage sera d'abord mis à niveau vers un verrou léger, et le verrou léger sera mis à niveau vers un verrou lourd dans une certaine mesure.

Si le verrou biaisé est activé, il existe deux situations :

• Lorsque le verrou n'est pas occupé, il sera mis à niveau vers un verrou sans verrou, puis le verrou sans verrou sera mis à niveau vers un verrou léger, puis le le verrou léger sera mis à niveau vers un verrou lourd.

• Lorsque la serrure est occupée, elle sera mise à niveau vers une serrure légère, puis mise à niveau d'une serrure légère vers une serrure lourde.

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!