【并发编程】synchronized 实现原理

今天药忘吃喽~ 2022-03-20 07:17 296阅读 0赞

# 前言 #

Github：[GitHub - yihonglei/jdk-source-code-reading: JDK source code reading][GitHub - yihonglei_jdk-source-code-reading_ JDK source code reading]（java-concurrent）

# 一 线程安全和非线程安全 #

在使用 synchronized 同步关键字前，先了解"线程安全"和"非线程安全"。

## 1、方法内部的变量不存在线程安全问题，即永远为线程安全的。 ##

**为什么局部变量是线程安全的？**

方法执行的时候是在虚拟机栈上进行的，而虚拟机栈是线程私有的，每个方法执行的时候都

会在虚拟机栈上创建栈帧，栈帧存了局部变量表等，局部变量则存在局部变量表里面，不会

出现并发资源竞争，所以，局部变量是线程安全的。

jvm 内存结构：[【JVM原理】内存结构\_yhl\_jxy的博客-CSDN博客][JVM_yhl_jxy_-CSDN]

**定义一个方法中含有私有变量类。**

package com.jpeony.concurrent.synchronizeds.safeprivate;
    
    /**
     * 方法内部的私有变量都是线程安全的
     *
     * @author yihonglei
     */
    public class HasSelfPrivateNum {
        public void addUser(String username) {
            try {
                int num = 0;
                if ("a".equals(username)) {
                    num = 500;
                    System.out.println("a set over!");
                    Thread.sleep(2000);
                } else {
                    num = 1000;
                    System.out.println("b set over!");
                }
                System.out.println("username = " + username + " & num = " + num);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    
    }

**线程A**

package com.jpeony.concurrent.synchronizeds.safeprivate;
    
    /**
     * @author yihonglei
     */
    public class ThreadA extends Thread {
        private HasSelfPrivateNum hasSelfPrivateNum;
    
        public ThreadA(HasSelfPrivateNum hasSelfPrivateNum) {
            super();
            this.hasSelfPrivateNum = hasSelfPrivateNum;
        }
    
        @Override
        public void run() {
            hasSelfPrivateNum.addUser("a");
        }
    }

**线程B**

package com.jpeony.concurrent.synchronizeds.safeprivate;
    
    /**
     * @author yihonglei
     */
    public class ThreadB extends Thread {
        private HasSelfPrivateNum hasSelfPrivateNum;
    
        public ThreadB(HasSelfPrivateNum hasSelfPrivateNum) {
            super();
            this.hasSelfPrivateNum = hasSelfPrivateNum;
        }
    
        @Override
        public void run() {
            hasSelfPrivateNum.addUser("b");
        }
    }

**测试类**

package com.jpeony.concurrent.synchronizeds.safeprivate;
    
    /**
     * @author yihonglei
     */
    public class RunTest {
        public static void main(String[] args) {
            // 创建实例
            HasSelfPrivateNum hasSelfPrivateNum = new HasSelfPrivateNum();
            // 创建线程A
            ThreadA threadA = new ThreadA(hasSelfPrivateNum);
            threadA.start();
            // 创建线程B
            ThreadB threadB = new ThreadB(hasSelfPrivateNum);
            threadB.start();
        }
    }

**运行结果**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70][]

从程序运行结果可以看出，线程 A 与线程 B 调用 addUser 方法时，对变量 num 并未产生"非线程

安全问题"。

## 2、实例变量为非线程安全 ##

实例变量存储在 jvm 堆上，堆是共享内存，对象的实例变量存在多线程竞争资源，不是线程

安全的。

package com.jpeony.concurrent.synchronizeds.unsafeobject;
    
    /**
     * 实例变量为"非线程安全"
     *
     * @author yihonglei
     */
    public class HasSelfPrivateNum {
        private int num = 0;
    
        public void addUser(String username) {
            try {
                if (username.equals("a")) {
                    num = 500;
                    System.out.println("a set over!");
                    Thread.sleep(2000);
                } else {
                    num = 1000;
                    System.out.println("b set over!");
                }
                System.out.println("username = " + username + " & num = " + num);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

**线程A**

package com.jpeony.concurrent.synchronizeds.unsafeobject;
    
    /**
     * @author yihonglei
     */
    public class ThreadA extends Thread {
        private HasSelfPrivateNum hasSelfPrivateNum;
    
        public ThreadA(HasSelfPrivateNum hasSelfPrivateNum) {
            super();
            this.hasSelfPrivateNum = hasSelfPrivateNum;
        }
    
        @Override
        public void run() {
            hasSelfPrivateNum.addUser("a");
        }
    }

**线程B**

package com.jpeony.concurrent.synchronizeds.unsafeobject;
    
    /**
     * @author yihonglei
     */
    public class ThreadB extends Thread {
        private HasSelfPrivateNum hasSelfPrivateNum;
    
        public ThreadB(HasSelfPrivateNum hasSelfPrivateNum) {
            super();
            this.hasSelfPrivateNum = hasSelfPrivateNum;
        }
    
        @Override
        public void run() {
            hasSelfPrivateNum.addUser("b");
        }
    }

**测试类**

package com.jpeony.concurrent.synchronizeds.unsafeobject;
    
    /**
     * @author yihonglei
     */
    public class RunTest {
        public static void main(String[] args) {
            // 创建实例
            HasSelfPrivateNum hasSelfPrivateNum = new HasSelfPrivateNum();
            // 创建线程A
            ThreadA threadA = new ThreadA(hasSelfPrivateNum);
            threadA.start();
            // 创建线程B
            ThreadB threadB = new ThreadB(hasSelfPrivateNum);
            threadB.start();
        }
    }

**运行结果**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 1][]

从运行结果，可以看出变量num读到的值出现交叉，都是1000，出现了非线程安全问题。

可以通过synchronized关键字加锁处理。

# 二 synchronized 使用 #

synchronized 对象锁和类锁：[【并发编程】synchronized 对象锁和类锁\_yhl\_jxy的博客-CSDN博客\_synchronized类锁][synchronized _yhl_jxy_-CSDN_synchronized]

## 1、单个对象锁 ##

为了解决上面实例出现"非线程安全"问题，可以给方法加上同步锁 synchronized。多个线程

访问同步方法，是线程安全的。在实例变量的方法上加上同步锁。

package com.jpeony.concurrent.synchronizeds.singleobject;
    
    /**
     * 方法addUser上加上同步锁synchronized
     *
     * @author yihonglei
     */
    public class HasSelfPrivateNum {
        private int num = 0;
    
        synchronized public void addUser(String username) {
            try {
                if (username.equals("a")) {
                    num = 500;
                    System.out.println("a set over!");
                    Thread.sleep(2000);
                } else {
                    num = 1000;
                    System.out.println("b set over!");
                }
                System.out.println("username = " + username + " & num = " + num);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

**线程 A**

package com.jpeony.concurrent.synchronizeds.singleobject;
    
    /**
     * @author yihonglei
     */
    public class ThreadA extends Thread {
        private HasSelfPrivateNum hasSelfPrivateNum;
    
        public ThreadA(HasSelfPrivateNum hasSelfPrivateNum) {
            super();
            this.hasSelfPrivateNum = hasSelfPrivateNum;
        }
    
        @Override
        public void run() {
            hasSelfPrivateNum.addUser("a");
        }
    }

**线程 B**

package com.jpeony.concurrent.synchronizeds.singleobject;
    
    /**
     * @author yihonglei
     */
    public class ThreadB extends Thread {
        private HasSelfPrivateNum hasSelfPrivateNum;
    
        public ThreadB(HasSelfPrivateNum hasSelfPrivateNum) {
            super();
            this.hasSelfPrivateNum = hasSelfPrivateNum;
        }
    
        @Override
        public void run() {
            hasSelfPrivateNum.addUser("b");
        }
    }

**测试类**

package com.jpeony.concurrent.synchronizeds.singleobject;
    
    /**
     * @author yihonglei
     */
    public class RunTest {
        public static void main(String[] args) {
            // 创建实例
            HasSelfPrivateNum hasSelfPrivateNum = new HasSelfPrivateNum();
            // 创建线程A
            ThreadA threadA = new ThreadA(hasSelfPrivateNum);
            threadA.start();
            // 创建线程B
            ThreadB threadB = new ThreadB(hasSelfPrivateNum);
            threadB.start();
        }
    }

**运行结果**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 2][]

从运行结果看出，使用 synchronized 解决了线程安全问题，当两个线程访问同一对象中的

同步方法时，是线程安全的。

## **2、多个对象多个锁问题** ##

synchronized 锁定单个对象时，如果是多线程，线程排队执行，获取锁，以上例子均为锁定

同一对象，多个线程排队获取锁执行。synchronized 锁定多个对象时，如果是多线程，jvm

会针对每个对象获取锁，多线程执行是异步的。

package com.jpeony.concurrent.synchronizeds.manyobject;
    
    /**
     * 方法addUser上加上同步锁synchronized
     *
     * @author yihonglei
     */
    public class HasSelfPrivateNum {
        private int num = 0;
    
        synchronized public void addUser(String username) {
            try {
                if (username.equals("a")) {
                    num = 500;
                    System.out.println("a set over!");
                    Thread.sleep(2000);
                } else {
                    num = 1000;
                    System.out.println("b set over!");
                }
                System.out.println("username = " + username + " & num = " + num);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

**线程 A**

package com.jpeony.concurrent.synchronizeds.manyobject;
    
    /**
     * @author yihonglei
     */
    public class ThreadA extends Thread {
        private HasSelfPrivateNum hasSelfPrivateNum;
    
        public ThreadA(HasSelfPrivateNum hasSelfPrivateNum) {
            super();
            this.hasSelfPrivateNum = hasSelfPrivateNum;
        }
    
        @Override
        public void run() {
            hasSelfPrivateNum.addUser("a");
        }
    }

**线程 B**

package com.jpeony.concurrent.synchronizeds.manyobject;
    
    /**
     * @author yihonglei
     */
    public class ThreadB extends Thread {
        private HasSelfPrivateNum hasSelfPrivateNum;
    
        public ThreadB(HasSelfPrivateNum hasSelfPrivateNum) {
            super();
            this.hasSelfPrivateNum = hasSelfPrivateNum;
        }
    
        @Override
        public void run() {
            hasSelfPrivateNum.addUser("b");
        }
    }

**测试类**

package com.jpeony.concurrent.synchronizeds.manyobject;
    
    /**
     * @author yihonglei
     */
    public class RunTest {
        public static void main(String[] args) {
            // 创建实例
            HasSelfPrivateNum hasSelfPrivateNumA = new HasSelfPrivateNum();
            HasSelfPrivateNum hasSelfPrivateNumB = new HasSelfPrivateNum();
            // 创建线程A
            ThreadA threadA = new ThreadA(hasSelfPrivateNumA);
            threadA.start();
            // 创建线程B
            ThreadB threadB = new ThreadB(hasSelfPrivateNumB);
            threadB.start();
        }
    }

**运行结果**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 3][]

从运行结果可以看出，先打印了 b 的 num，后打印 a 的 num，打印的顺序非同步打印，

而是以异步的顺序打印 num，是因为 synchronized 锁定的只是对象，也就是对象锁，

如果是单个对象，线程会 a 执行时，b 会等待，而这里直接打印了 b，说明 synchronized

锁定多个对象对于每个对象都是独立的锁，虚拟机会创建多个锁，程序以异步方式获取锁，

无需等待某个线程执行完，才能进行下一步执行。

## 3、当 synchronized 出现异常时，锁自动释放 ##

package com.jpeony.concurrent.synchronizeds.releases;
    
    /**
     * 使用synchronized当出现异常时，锁会自动释放
     *
     * @author yihonglei
     */
    public class MyService {
        synchronized public void serviceMethod() {
            if (Thread.currentThread().getName().equals("A")) {
                System.out.println("ThreadName = " + Thread.currentThread().getName()
                        + " begin time = " + System.currentTimeMillis());
                // 制造异常: 当异常产生时，A线程释放锁，B线程活期锁，开始执行。
                Integer.parseInt("A");
            } else {
                System.out.println("Thread B begin time = " + System.currentTimeMillis());
            }
        }
    }

**线程 A**

package com.jpeony.concurrent.synchronizeds.releases;
    
    /**
     * @author yihonglei
     */
    public class ThreadA extends Thread {
        private MyService myService;
    
        public ThreadA(MyService myService) {
            super();
            this.myService = myService;
        }
    
        @Override
        public void run() {
            myService.serviceMethod();
        }
    }

**线程 B**

package com.jpeony.concurrent.synchronizeds.releases;
    
    /**
     * @author yihonglei
     */
    public class ThreadB extends Thread {
        private MyService myService;
    
        public ThreadB(MyService myService) {
            super();
            this.myService = myService;
        }
    
        @Override
        public void run() {
            myService.serviceMethod();
        }
    }

**测试类**

package com.jpeony.concurrent.synchronizeds.releases;
    
    /**
     * @author yihonglei
     */
    public class RunTest {
        public static void main(String[] args) {
            MyService myService = new MyService();
    
            ThreadA threadA = new ThreadA(myService);
            threadA.setName("A");
            threadA.start();
    
            ThreadB threadB = new ThreadB(myService);
            threadB.start();
            threadB.setName("B");
        }
    }

**运行结果**

![Center][]

# 三 synchronized 实现原理 #

Java 锁机制、锁升级：[【并发编程】Java 锁实现原理\_yhl\_jxy的博客-CSDN博客][Java _yhl_jxy_-CSDN]

synchronized 实现同步的基础是基于每个对象都可以作为锁。主要有三种形式：

对于同步普通方法，锁是当前实例对象。

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

对于同步方法块，锁是 synchronized 括号里配置的对象。

Synchronized 在 JVM 层面实现的，加锁和解锁依赖 JVM 实现，不需要使用这显示的去释放锁。

monitorenter 指令是在编译后插入到同步代码块的开始位置，而 monitorexit 是插入到方法结束

和异常处，JVM 要保证每个 monitorenter 必须有对应的 monitorexit 与之配对。任何对象都有

一个 monitor 与之关联，当且一个 monitor 被持有后，它将处于锁定状态。线程执行到

monitorenter 指令时，将尝试获取对象对应的 monitor 的所有权，尝试获取对象的锁。加锁

代码将代码反编译后，可以看到 monitorenter 和 monitorexit 字节码指令。

## 1、HotSpot 虚拟机的对象头信息 ##

对象主要包含对象头、实例数据、对齐填充。synchronized 用的锁是存在 Java 对象头里的，

跟锁相关的操作，都存在对象头里面。对象头的相关信息如下：

**markword ：**用于存储对象自身的运行时数据，如 HashCode、GC 分代年龄、锁状态标志、

线程持有的锁、偏向线程 ID、偏向时间戳、可偏向状态等。

**klass ：**对象头的另外一部分是 klass 对象类型数据指针，即对象指向它的类元数据的指针，

虚拟机通过这个指针来确定这个对象是哪个类的实例。

**数组长度（只有数组对象有） ：**如果对象是一个数组，那在对象头中还必须有一块数据用于

记录数组长度。

synchronized 各种类型的锁状态标记在 markword 的标志位中。

对象所处的状态，决定了 markword 存储的内容，如下表所示:

<table> 
 <tbody> 
 <tr> 
 <td> 锁状态 </td> 
 <td> 标志位 </td> 
 <td> 存储内容 </td> 
 </tr> 
 <tr> 
 <td> 未锁定 </td> 
 <td> 01 </td> 
 <td> 对象哈希码、对象分代年龄 </td> 
 </tr> 
 <tr> 
 <td>可偏向</td> 
 <td>01</td> 
 <td>偏向线程ID、偏向时间戳、对象分代年龄</td> 
 </tr> 
 <tr> 
 <td> 轻量级锁定 </td> 
 <td> 00 </td> 
 <td> 指向栈中锁记录的指针 </td> 
 </tr> 
 <tr> 
 <td> 重量级锁定 </td> 
 <td> 10 </td> 
 <td> 指向重量级锁的指针 </td> 
 </tr> 
 <tr> 
 <td> GC 标记 </td> 
 <td> 11 </td> 
 <td> 空(不需要记录信息) </td> 
 </tr> 
 </tbody> 
</table>

## 2、Monitor ##

Monitor（管程或监视器锁）是一种用来实现同步的工具，任何一个对象都有一个 Monitor

与之关联，都有一个指针指向 Monitor 对象的起始地址。Monitor 是实现 Sychronized 的基础，

加锁就是竞争 Monitor 对象。Monitor 结构复杂，需要时才申请。

**1、不同使用场景的实现方式**

1）同步代码块是使用 monitorenter 和 monitorexit 指令实现的，会在同步块的区域通过

monitor 对象去获取锁和释放锁。

2）同步方法依靠的是方法修饰符上的 ACC\_SYNCHRONIZED 实现。当方法调用时，

调用指令如果发现方法的 ACC\_SYNCHRONIZED 标志被设置了，执行线程将先获取

monitor，获取成功之后才能执行方法体，方法执行完后再释放 monitor。在方法执行期间，

其他任何线程都无法再获得同一个 monitor 对象。

3）静态同步方法增加 ACC\_STATIC 标识，区分锁是当前实例对象还是当前类对象。

**2、Monitor 对象关键字段**

如果你很感兴趣，可以看 hotspot 的关于 Monitor 对象实现源码，是 C++ 代码写的。

**具体代码位置：jdk/src/hotspot/share/runtime/objectMonitor.hpp**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 4][]

属性比较多，重点关注几个跟锁有关的。

\_owner：指向持有 ObjectMonitor 对象的线程（每个等待锁的线程都会被封装成 ObjectWaiter 对象）；

\_cxq ：存储最近刚被阻塞的线程的 ObjectWaiter 对象的单向列表。多线程竞争锁时，会先进入此队列中；

\_EntryList：存储处于 Blocked 状态的 ObjectWaiter 对象列表；

\_WaitSet：存储 wait 状态的 ObjectWaiter 对象列表；

**3、Monitor 中数据结构的转换过程**

1）当一个线程尝试获得锁时，如果该锁已经被占用，则会将该线程封装成一个 ObjectWaiter

对象插入到 cxq 的队列的队首，然后调用 park 函数挂起当前线程。

2）当线程释放锁时，根据 QMode（QMode 是求模计算对应的队列）的不同，将 ObjectWaiter

从 \_cxq 或者 \_EntryList 中取出后唤醒，线程被唤醒后会尝试获得锁，但不一定能获得锁，

获取不到，继续等待。被选中的线程即为图中的 Ready Thread。

3）线程在调用 wait()  后被加入了 \_WaitSet 队列中。

4）线程在被 notify()/notifyAll() 唤醒后，从 \_WaitSet 中取出第一个，根据 Policy 的不同，

将这个线程放入 \_EntryList 或者 \_cxq 队列中，去等待尝试获取锁。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 5][]

## 3、JVM 锁优化 ##

现在 synchronized 内在机制已经进行了大量的优化，加入了 CAS（修改 markword 锁状态

标志位），偏向锁和轻量级锁。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的

重量级锁，这种锁的升级过程被称为锁膨胀。锁的膨胀是单向的，不会出现锁降级。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 6][]

## 4、偏向/轻量级锁/重量级锁 ##

Java 6 开始，为了减少获取锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”，

锁级别从低到高依次分为无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，

这几个状态会随着竞争情况逐渐升级。锁可以升级但是不能降级，主要是为了提高获得锁

和释放锁的效率。

##    1）偏向锁 ##

经过研究发现，在大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，

因此为了减少同一线程获取锁的代价而引入偏向锁。偏向锁的核心思想是，如果 A 线程获得

了锁，那么锁就进入偏向模式，此时 markword 的结构也变为偏向锁结构，会在对象头和

栈帧中的锁记录里存储锁偏向的线程 ID，当 A 线程再次获取锁时，测试对象头里的偏向线程

ID 是不是 A 线程的，是则直接返回获取锁成功，理论上都能成功。当 B 线程请求获取锁时，

需要测试下对象头里面是否已经存在该线程 ID，如果测试成功，表示线程已经获取锁成功即

重入锁，如果测试失败，则需要再测试一下 markword 偏向锁的标识是否设置为1（表示当前

是偏向锁），如果已经有偏向锁标识，需要撤销线程 A 的偏向锁，撤销偏向锁有两种结果，

一种是锁恢复为无状态标识，即 A 线程已经到达安全点，可以释放锁，B 线程 CAS 获取锁

成功后，线程偏向 ID 设置为 B 线程的，一种是升级为轻量级锁标识，即 A 线程未执行完同步体，

先暂停持有锁的线程，将 markword 修改为轻量级锁标识，恢复 A 线程，升级为轻量级锁，

B 线程在轻量级的基础上自旋尝试获取锁，自旋一定次数后还是失败会升级为重量级锁，

锁状态也会被标记为重量级锁，一旦升级为重量级锁，当 C 线程来获取锁时，直接就进入

阻塞队，主要是考虑都已经升级为重量级锁了，重复之前的步骤也是白搭，浪费性能，干脆直

接进入阻塞队列等待唤醒获取锁。

##    2）轻量级锁 ##

经验数据表示，对绝大部分的锁，在整个同步周期内都不存在竞争。轻量级锁所适应的场景是同步

块执行速度非常快，线程交替执行同步块的场合。当线程在获取轻量级锁的过程中执行 CAS 操作

失败时，使用 JDK1.6 引入自适应的自旋锁尝试获取锁，自旋的次数由 JVM 决定。如果自旋次数

到达后还不能获取到锁，那就将线程挂起，升级为重量级锁。

##    5、锁膨胀过程 ##

1）当没有被当成锁时，这就是一个普通的对象，Mark Word 记录对象的 HashCode，

锁标志位是 01，是否偏向锁那一位是 0。

2）当对象被当做同步锁并有一个线程 A 抢到了锁时，锁标志位还是 01，但是否偏向锁那一

位改成 1，记录抢到锁的线程 id。

3）当线程 A 再次来获得锁时，JVM 发现同步锁处于偏向状态，markword 中记录的线程 id

是线程 A 自己的 id，表示线程 A 已经获得了这个偏向锁。

4）当线程 B 试图获得这个锁时，JVM 发现偏向标志是 1，同步锁处于偏向状态，但是

markword 中的线程 id 记录的不是 B，那么线程 B 会试图获得锁。如果抢锁成功，就把

markword 里的线程 id 改为线程 B 的 id，线程 B 获得了偏向锁。

5）偏向锁状态抢锁失败，偏向锁将升级为轻量级锁。JVM 会在当前线程的线程栈中开辟一

块单独的空间，保存指向对象锁 markword 的指针，同时在对象锁 markword 中保存指向这

片空间的指针。如果保存成功，代表线程抢到了同步锁，把 markword 中的锁标志位改成 00。

6）轻量级锁抢锁失败，JVM 会使用自旋锁，自旋锁不是一个锁状态，只是代表不断的重试，

尝试抢锁。从 JDK1.7 开始，自旋锁默认启用，自旋次数由 JVM 决定。

7）自旋锁重试之后如果抢锁依然失败，同步锁会升级至重量级锁，锁标志位改为 10。

在这个状态下，未抢到锁的线程都会被阻塞。

# 四 总结 #

1）synchronized 可以同步语句块，也可以同步代码块；

2）只有"共享"的读写访问才需要同步，如果不是共享资源，同步就是多余的；

3）synchronized 还有个特别的特性，会强制拉取主内存数据，实现线程副本数据与主存一致；

[GitHub - yihonglei_jdk-source-code-reading_ JDK source code reading]: https://github.com/yihonglei/jdk-source-code-reading
[JVM_yhl_jxy_-CSDN]: https://blog.csdn.net/yhl_jxy/article/details/80882595
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70]: /images/20220320/5442a1986d384c0c81f4f295864636a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 1]: /images/20220320/247bcf7bc2d2400b88548b3ae4475c5a.png
[synchronized _yhl_jxy_-CSDN_synchronized]: https://jpeony.blog.csdn.net/article/details/87012803
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 2]: /images/20220320/f15e0721e5ca4ebd827326116924c1d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 3]: /images/20220320/2d738102517b4a1ca19c3a14fc91041d.png
[Center]: /images/20220320/4cbd43efdcb44394b88957898e721381.png
[Java _yhl_jxy_-CSDN]: https://blog.csdn.net/yhl_jxy/article/details/101687960
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 4]: /images/20220320/a943449322454202a65b3c370a394a8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 5]: /images/20220320/1ad5e9c173fb4ff18a86d3d8ae6d1a80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 6]: /images/20220320/2e42e6c9caa14d2f937761187e28aba4.png