Le mot-clé synchronisé en Java est utilisé pour réaliser la synchronisation des threads

1. Synchronized implémente l'expression des verrous

1. modifie les méthodes synchronisées ordinaires, le verrou est l'objet d'instance actuel

2. modifie les méthodes statiques synchronisées, le verrou est l'objet Class actuel

   .

3. Modifiez le bloc de code méthode Pour le bloc méthode synchronisé, le verrou est l'objet configuré entre parenthèses synchronisées !

Lorsqu'un thread tente d'accéder à un bloc de code synchronisé, il doit obtenir le verrou. Une fois terminé (ou une exception se produit), le verrou doit être libéré. Alors, où se trouve exactement le verrou ? Explorons ensemble !

Cependant, je crois que puisque vous pouvez retrouver cet article, je crois que vous connaissez déjà son utilisation. Nous n'expliquerons pas en détail son utilisation et pourquoi les données seront confondues en multi-threading ! Seules quelques façons de l’utiliser sont répertoriées à titre de référence !

①Modifiez la méthode d'instance

Modifiez la méthode d'instance. Pour les méthodes de synchronisation ordinaires, le verrou est l'objet d'instance actuel

Après avoir utilisé la même instance, après avoir ajouté synchronisé, le thread doit être mis en file d'attente. pour terminer une opération atomique, mais notez qu'elle ne prendra effet que si utilise la même instance ! 使用的同一个实例，他才会生效！

正例：

<code>/**<br> * @author huangfu<br> */<br>public class ExploringSynchronized implements Runnable {<br>    /**<br>     * 共享资源(临界资源)<br>     */<br>    static int i=0;<br>    public synchronized void add(){<br>        i++;<br>    }<br><br>    @Override<br>    public void run() {<br>        for (int j = 0; j             add();<br>        }<br>    }<br><br>    public static void main(String[] args) throws InterruptedException {<br>        ExploringSynchronized exploringSynchronized = new ExploringSynchronized();<br>        Thread t1 = new Thread(exploringSynchronized);<br>        Thread t2 = new Thread(exploringSynchronized);<br>        t1.start();<br>        t2.start();<br>        //join 主线程需要等待子线程完成后在结束<br>        t1.join();<br>        t2.join();<br>        System.out.println(i);<br><br>    }<br>}</code>

反例：

<code>/**<br> * @author huangfu<br> */<br>public class ExploringSynchronized implements Runnable {<br>    /**<br>     * 共享资源(临界资源)<br>     */<br>    static int i=0;<br>    public synchronized void add(){<br>        i++;<br>    }<br><br>    @Override<br>    public void run() {<br>        for (int j = 0; j             add();<br>        }<br>    }<br><br>    public static void main(String[] args) throws InterruptedException {<br>        Thread t1 = new Thread(new ExploringSynchronized());<br>        Thread t2 = new Thread(new ExploringSynchronized());<br>        t1.start();<br>        t2.start();<br>        //join 主线程需要等待子线程完成后在结束<br>        t1.join();<br>        t2.join();<br>        System.out.println(i);<br><br>    }<br>}</code>

这种，即使你在方法上加上了synchronized也无济于事，因为，对于普通同步方法，锁是当前的实例对象！实例对象都不一样了，那么他们之间的锁自然也就不是同一个！

②修饰静态方法

修饰静态方法，对于静态同步方法，锁是当前的Class对象

从定义上可以看出来，他的锁是类对象，那么也就是说，以上面那个类为例：普通方法的锁对象是 new ExploringSynchronized()而静态方法对应的锁对象是ExploringSynchronized.class所以对于静态方法添加同步锁，即使你重新创建一个实例，它拿到的锁还是同一个！

<code>package com.byit.test;<br><br>/**<br> * @author huangfu<br> */<br>public class ExploringSynchronized implements Runnable {<br>    /**<br>     * 共享资源(临界资源)<br>     */<br>    static int i=0;<br>    public synchronized static void add(){<br>        i++;<br>    }<br><br>    @Override<br>    public void run() {<br>        for (int j = 0; j             add();<br>        }<br>    }<br><br>    public static void main(String[] args) throws InterruptedException {<br>        Thread t1 = new Thread(new ExploringSynchronized());<br>        Thread t2 = new Thread(new ExploringSynchronized());<br>        t1.start();<br>        t2.start();<br>        //join 主线程需要等待子线程完成后在结束<br>        t1.join();<br>        t2.join();<br>        System.out.println(i);<br><br>    }<br>}</code>

当然，结果是我们期待的  200000

③修饰方法代码块

修饰方法代码块，对于同步方法块，锁是synchronized括号里面配置的对象！

<code>package com.byit.test;<br><br>/**<br> * @author huangfu<br> */<br>public class ExploringSynchronized implements Runnable {<br>    /**<br>     * 锁标记<br>     */<br>    private static final String LOCK_MARK = "LOCK_MARK";<br>    /**<br>     * 共享资源(临界资源)<br>     */<br>    static int i=0;<br>    public void add(){<br>        synchronized (LOCK_MARK){<br>            i++;<br>        }<br>    }<br><br>    @Override<br>    public void run() {<br>        for (int j = 0; j             add();<br>        }<br>    }<br><br>    public static void main(String[] args) throws InterruptedException {<br>        Thread t1 = new Thread(new ExploringSynchronized());<br>        Thread t2 = new Thread(new ExploringSynchronized());<br>        t1.start();<br>        t2.start();<br>        //join 主线程需要等待子线程完成后在结束<br>        t1.join();<br>        t2.join();<br>        System.out.println(i);<br><br>    }<br>}</code>

对于同步代码块，括号里面是什么，锁对象就是什么，里面可以使用this  字符串  对象等等！

二、synchronized的底层实现

java中synchronized的实现是基于进入和退出的 Monitor对象实现的，无论是显式同步（修饰代码块，有明确的monitorenter和 monitorexit指令）还是隐式同步(修饰方法体)！

需要注意的是，只有修饰代码块的时候，才是基于monitorenter和 monitorexit指令来实现的；修饰方法的时候，是通过另一种方式实现的！我会放到后面去说！

在了解整个实现底层之前，我还是希望你能够大致了解一下对象在内存中的结构详情！

• 实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐。

• 填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐，这点了解即可。

这两个概念，我们简单理解就好！我们今天并不去探究对象的构成原理！我们着重探究一下对象头，他对我们理解锁尤为重要！

一般而言，synchronized使用的锁存在于对象头里面！如果是数组对象，则虚拟机使用3个字宽存储对象，如果是非数组对象，则使用两个字宽存储对象头！字虚拟机里面1字宽等于4字节！主要结构是 Mark Word 和 Class Metadata Address

Exemple positif :

<code>package com.byit.test;<br><br>/**<br> * @author Administrator<br> */<br>public class SynText {<br>    private static String A = "a";<br>    public int i ;<br><br>    public void add(){<br>        synchronized (A){<br>            i++;<br>        }<br><br>    }<br>}</code>

Contre-exemple :

<code>Compiled from "SynText.java"<br>public class com.byit.test.SynText {<br>  public int i;<br><br>  public com.byit.test.SynText();<br>    Code:<br>       0: aload_0<br>       1: invokespecial #1                  // Method java/lang/Object."<init>":()V<br>       4: return<br><br>  public void add();<br>    Code:<br>       0: getstatic     #2                  // Field A:Ljava/lang/String;<br>       3: dup<br>       4: astore_1<br>       5: monitorenter<br>       6: aload_0<br>       7: dup<br>       8: getfield      #3                  // Field i:I<br>      11: iconst_1<br>      12: iadd<br>      13: putfield      #3                  // Field i:I<br>      16: aload_1<br>      17: monitorexit<br>      18: goto          26<br>      21: astore_2<br>      22: aload_1<br>      23: monitorexit<br>      24: aload_2<br>      25: athrow<br>      26: return<br>    Exception table:<br>       from    to  target type<br>           6    18    21   any<br>          21    24    21   any<br><br>  static {};<br>    Code:<br>       0: ldc           #4                  // String a<br>       2: putstatic     #2                  // Field A:Ljava/lang/String;<br>       5: return<br>}<br></init></code>

Dans ce cas, même si vous ajoutez synchronisé à la méthode, cela n'aidera pas, car, pour les méthodes synchronisées ordinaires, le verrou est l'objet d'instance actuel ! Les objets d'instance sont différents, donc les verrous entre eux ne sont naturellement pas les mêmes ! ②Modifier les méthodes statiquesModifier les méthodes statiques synchronisées, le verrou est l'objet Class actuelIl ressort de la définition que son verrou est. Objet de classe, c'est-à-dire prenez la classe ci-dessus comme exemple : l'objet verrou de la méthode ordinaire est new ExploringSynchronized() et l'objet verrou correspondant à la méthode statique est ExploringSynchronized. class Donc, si vous ajoutez un verrou de synchronisation à une méthode statique, même si vous recréez une instance, le verrou qu'elle obtient est toujours le même !

<code>   5: monitorenter<br>      ...<br>      17: monitorexit<br>      ...<br>      23: monitorexit</code>

Bien sûr, le résultat est ce à quoi nous nous attendions 200000

Pour les blocs de code synchronisés, ce qu'il y a entre parenthèses, quel est l'objet verrou, vous pouvez utiliser cet objet chaîne et ainsi de suite ! 2. L'implémentation sous-jacente de synchroniséL'implémentation de synchronized en Java est basée sur l'entrée et la sortie des objets Monitor, qu'il s'agisse d'une synchronisation explicite (blocs de code modifiés , Existe-t-il des instructions monitorenter et monitorexit explicites) ou une synchronisation implicite (corps de méthode modifié) ! Il est à noter que ce n'est que lors de la modification des blocs de code qu'il est implémenté sur la base des instructions monitorenter et monitorexit lors de la modification des méthodes, il est implémenté d'une autre manière Réalisé ! J'en parlerai plus tard ! Avant de comprendre la couche inférieure de toute l'implémentation, j'espère toujours que vous pourrez avoir une compréhension générale des détails de la structure des objets en mémoire ! Padding data : Parce que la machine virtuelle exige que l'adresse de départ de l'objet soit un multiple entier de 8 octets. Les données de remplissage ne doivent pas nécessairement exister, c'est juste pour l'alignement des octets, comprenez simplement cela.

③Modifier le bloc de code de méthode	Modifier le bloc de code de méthode Pour les blocs de méthode synchronisés, le verrouillage est configuré en synchronisé. crochets Objet !	javap -verbose -p SynText > 3.txt
	Variables d'instance : stockent les informations sur les données d'attribut de la classe, y compris les informations d'attribut de la classe parent, s'il s'agit d'un instance d'un tableau Part inclut également la longueur du tableau, cette partie de la mémoire est alignée sur 4 octets.

🎜On peut tout simplement comprendre ces deux concepts ! Nous n’allons pas explorer les principes de composition des objets aujourd’hui ! Concentrons-nous sur l'exploration de l'en-tête de l'objet, qui est particulièrement important pour notre compréhension des verrous ! 🎜🎜D'une manière générale, le verrou utilisé par synchronized existe dans l'entête de l'objet ! S'il s'agit d'un objet tableau, la machine virtuelle utilise 3 mots de large pour stocker l'objet. S'il s'agit d'un objet non-tableau, elle utilise deux mots de large pour stocker l'en-tête de l'objet ! Dans le mot machine virtuelle, 1 mot de largeur équivaut à 4 octets ! La structure principale est composée de Mark Word et de Class Metadata Address. La structure est la suivante : 🎜🎜🎜🎜🎜🎜Bits de machine virtuelle🎜🎜Structure de l'objet d'en-tête🎜🎜Description. 🎜🎜🎜🎜 🎜🎜32/64 bits🎜🎜Marquer le mot de passe🎜🎜Le hashCode de l'objet de stockage, les informations de verrouillage ou l'âge de la génération ou le drapeau GC et d'autres informations🎜🎜🎜🎜32/64 bits🎜🎜Adresse des métadonnées de classe🎜🎜Pointeur stocké vers les données de type de formation 🎜 🎜🎜🎜32/64 bits (tableau)🎜🎜Longueur du tableau🎜🎜La longueur du tableau🎜🎜🎜🎜

On peut voir dans le tableau ci-dessus que 锁信息 存在于 Mark Word est à l'intérieur, alors comment est composé l'intérieur de Mark Word ?

Statut de verrouillage	25 bits	4bit	1 bit est-il un verrou biaisé	Drapeau de verrouillage 2 bits
Statut déverrouillé	Code de hachage de l'objet	L'âge générationnel de l'objet	0	01

在运行起见，mark Word 里存储的数据会随着锁的标志位的变化而变化。mark Word可能变化为存储一下四种数据

Java SE 1.6为了减少获得锁和释放锁带来的消耗，引入了偏向锁和轻量级锁，从之前上来就是重量级锁到1.6之后，锁膨胀升级的优化，极大地提高了synchronized的效率；

锁一共有4中状态，级别从低到高：

这几个状态会随着锁的竞争，逐渐升级。锁可以升级，但是不能降级，其根本的原因就是为了提高获取锁和释放锁的效率！

那么，synchronized是又如何保证的线程安全的呢？或许我们需要从字节码寻找答案！

<code>package com.byit.test;<br><br>/**<br> * @author Administrator<br> */<br>public class SynText {<br>    private static String A = "a";<br>    public int i ;<br><br>    public void add(){<br>        synchronized (A){<br>            i++;<br>        }<br><br>    }<br>}</code>

反编译的字节码

<code>Compiled from "SynText.java"<br>public class com.byit.test.SynText {<br>  public int i;<br><br>  public com.byit.test.SynText();<br>    Code:<br>       0: aload_0<br>       1: invokespecial #1                  // Method java/lang/Object."<init>":()V<br>       4: return<br><br>  public void add();<br>    Code:<br>       0: getstatic     #2                  // Field A:Ljava/lang/String;<br>       3: dup<br>       4: astore_1<br>       5: monitorenter<br>       6: aload_0<br>       7: dup<br>       8: getfield      #3                  // Field i:I<br>      11: iconst_1<br>      12: iadd<br>      13: putfield      #3                  // Field i:I<br>      16: aload_1<br>      17: monitorexit<br>      18: goto          26<br>      21: astore_2<br>      22: aload_1<br>      23: monitorexit<br>      24: aload_2<br>      25: athrow<br>      26: return<br>    Exception table:<br>       from    to  target type<br>           6    18    21   any<br>          21    24    21   any<br><br>  static {};<br>    Code:<br>       0: ldc           #4                  // String a<br>       2: putstatic     #2                  // Field A:Ljava/lang/String;<br>       5: return<br>}<br></init></code>

省去不必要的，简化在简化

<code>   5: monitorenter<br>      ...<br>      17: monitorexit<br>      ...<br>      23: monitorexit</code>

从字节码中可知同步语句块的实现使用的是monitorenter和 monitorexit指令，其中monitorenter指令指向同步代码块的开始位置，monitorexit指令则指明同步代码块的结束位置,当执行monitorenter指令的时候，线程将试图获取对象所所对应的monitor特权，当monitor的的计数器为0的时候，线程就可以获取monitor,并将计数器设置为1.去锁成功！如果当前线程已经拥有monitor特权，则可以直接进入方法（可重入锁），计数器+1；如果其他线程已经拥有了monitor特权，那么本县城将会阻塞！

拥有monitor特权的线程执行完成后释放monitor，并将计数器设置为0；同时执行monitorexit指令；不要担心出现异常无法执行monitorexit指令；为了保证在方法异常完成时 monitorenter 和 monitorexit 指令依然可以正确配对执行，编译器会自动产生一个异常处理器，这个异常处理器声明可处理所有的异常，它的目的就是用来执行 monitorexit 指令。从字节码中也可以看出多了一个monitorexit指令，它就是异常结束时被执行的释放monitor 的指令。

同步代码块的原理了解了，那么同步方法如何解释？不急，我们不妨来反编译一下同步方法的状态！

javap -verbose -p SynText > 3.txt

代码

<code>package com.byit.test;<br><br>/**<br> * @author huangfu<br> */<br>public class SynText {<br>    public int i ;<br><br>    public synchronized void add(){<br>        i++;<br><br>    }<br>}</code>

字节码

<code>Classfile /D:/2020project/byit-myth-job/demo-client/byit-demo-client/target/classes/com/byit/test/SynText.class<br>  Last modified 2020-1-6; size 382 bytes<br>  MD5 checksum e06926a20f28772b8377a940b0a4984f<br>  Compiled from "SynText.java"<br>public class com.byit.test.SynText<br>  minor version: 0<br>  major version: 52<br>  flags: ACC_PUBLIC, ACC_SUPER<br>Constant pool:<br>   #1 = Methodref          #4.#17         // java/lang/Object."<init>":()V<br>   #2 = Fieldref           #3.#18         // com/byit/test/SynText.i:I<br>   #3 = Class              #19            // com/byit/test/SynText<br>   #4 = Class              #20            // java/lang/Object<br>   #5 = Utf8               i<br>   #6 = Utf8               I<br>   #7 = Utf8               <init><br>   #8 = Utf8               ()V<br>   #9 = Utf8               Code<br>  #10 = Utf8               LineNumberTable<br>  #11 = Utf8               LocalVariableTable<br>  #12 = Utf8               this<br>  #13 = Utf8               Lcom/byit/test/SynText;<br>  #14 = Utf8               syncTask<br>  #15 = Utf8               SourceFile<br>  #16 = Utf8               SynText.java<br>  #17 = NameAndType        #7:#8          // "<init>":()V<br>  #18 = NameAndType        #5:#6          // i:I<br>  #19 = Utf8               com/byit/test/SynText<br>  #20 = Utf8               java/lang/Object<br>{<br>  public int i;<br>    descriptor: I<br>    flags: ACC_PUBLIC<br><br>  public com.byit.test.SynText();<br>    descriptor: ()V<br>    flags: ACC_PUBLIC<br>    Code:<br>      stack=1, locals=1, args_size=1<br>         0: aload_0<br>         1: invokespecial #1                  // Method java/lang/Object."<init>":()V<br>         4: return<br>      LineNumberTable:<br>        line 6: 0<br>      LocalVariableTable:<br>        Start  Length  Slot  Name   Signature<br>            0       5     0  this   Lcom/byit/test/SynText;<br><br>  public synchronized void syncTask();<br>    descriptor: ()V<br>    flags: ACC_PUBLIC, ACC_SYNCHRONIZED<br>    Code:<br>      stack=3, locals=1, args_size=1<br>         0: aload_0<br>         1: dup<br>         2: getfield      #2                  // Field i:I<br>         5: iconst_1<br>         6: iadd<br>         7: putfield      #2                  // Field i:I<br>        10: return<br>      LineNumberTable:<br>        line 10: 0<br>        line 11: 10<br>      LocalVariableTable:<br>        Start  Length  Slot  Name   Signature<br>            0      11     0  this   Lcom/byit/test/SynText;<br>}<br>SourceFile: "SynText.java"<br></init></init></init></init></code>

简化，在简化

<code> public synchronized void syncTask();<br>    descriptor: ()V<br>    flags: ACC_PUBLIC, ACC_SYNCHRONIZED<br>    Code:<br>      stack=3, locals=1, args_size=1<br>         0: aload_0<br>         1: dup</code>

我们能够看到 flags: ACC_PUBLIC, ACC_SYNCHRONIZED这样的一句话

从字节码中可以看出，synchronized修饰的方法并没有monitorenter指令和monitorexit指令，取得代之的确实是ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM通过该ACC_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。这便是synchronized锁在同步代码块和同步方法上实现的基本原理。

那么在JAVA6之前，为什么synchronized会如此的慢？

那是因为，操作系统实现线程之间的切换需要系统内核从用户态切换到核心态!这个状态之间的转换，需要较长的时间，时间成本高！所以这也就是synchronized慢的原因！

三、锁膨胀的过程

在这之前，你需要知道什么是锁膨胀！他是JAVA6之后新增的一个概念！是一种针对之前重量级锁的一种性能的优化！他的优化，大部分是基于经验上的一些感官，对锁来进行优化！

①偏向锁

研究发现，大多数情况下，锁不仅不存在多线程竞争，而且还总是由一条线程获得！因为为了减少锁申请的次数！引进了偏向锁！在没有锁竞争的情况下，如果一个线程获取到了锁，那么锁就进入偏向锁的模式！当线程再一次请求锁时，无需申请，直接获取锁，进入方法！但是前提是没有锁竞争的情况，存在锁竞争，锁会立即膨胀，膨胀为轻量级锁！

②轻量级锁

偏向锁失败，那么锁膨胀为轻量级锁！此时锁机构变为轻量级锁结构！他的经验依据是：“绝大多数情况下，在整个同步周期内，不会存在锁的竞争”，故而，轻量级锁适合，线程交替进行的场景！如果在同一时间出现两条线程对同一把锁的竞争，那么此时轻量级锁就不会生效了！但是，jdk官方为了是锁的优化性能更好，轻量级锁失效后，并不会立即膨胀为重量级锁！而是将锁转换为自旋锁状态！

③自旋锁

轻量级锁失败后，为了是避免线程挂起，引起内核态的切换！为了优化，此时线程会进入自选状态！他可能会进行几十次，上百次的空轮训！为什么呢？又是经验之谈！他们认为，大多数情况下，线程持有锁的时间都不会太长！做几次空轮训，就能大概率的等待到锁！事实证明，这种优化方式确实有效！最后如果实在等不到锁！没办法，才会彻底升级为重量级锁！

④锁消除

jvm在进行代码编译时，会基于上下文扫描；将一些不可能存在资源竞争的的锁给消除掉！这也是JVM对于锁的一种优化方式！不得不感叹，jdk官方的脑子！举个例子！在方法体类的局部变量对象，他永远也不可能会发生锁竞争，例如：

<code>/**<br> * @author huangfu<br> */<br>public class SynText {<br>    public static void add(String name1 ,String name2){<br>        StringBuffer sb = new StringBuffer();<br>        sb.append(name1).append(name2);<br>    }<br><br>    public static void main(String[] args) {<br>        for (int i = 0; i             add("w"+i,"q"+i);<br>        }<br>    }<br>}</code>

不能否认，StringBuffer是线程安全的！但是他永远也不会被其他线程引用！故而，锁失效！故而，被消除掉！

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!