【并发编程】Java 锁实现原理

港控/mmm° 2023-08-17 16:45 206阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/jdk-source-code-reading][https_github.com_yihonglei_jdk-source-code-reading]（java-concurrent）

# 一 锁的种类 #

## **1、乐观锁/悲观锁** ##

**悲观锁：**悲观锁会假设我们总是处于最坏的情况下，如果不加锁数据完整性就会被破坏；

**乐观锁：**乐观锁指是一种基于冲突检测的方法，检测到冲突时操作就会失败；

乐观锁与悲观锁并不是特指某个锁，而是不同加锁策略。

## 2、公平锁/非公平锁 ##

**公平锁：**公平锁是指多个线程按照申请锁的顺序来获取锁；

**非公平锁：**非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁；

## 3、可重入锁 ##

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

ReentrantLock 即是可重入锁，对于 synchronized 而言，也是一个可重入锁。

## 4、独享锁/共享锁 ##

**独享锁：**独享锁是指该锁一次只能被一个线程所持有；

**共享锁：**共享锁是指该锁可被多个线程所持有；

## 5、互斥锁/读写锁 ##

互斥锁/读写锁就是独享锁/共享锁具体的实现。

互斥锁在 Java 中的具体实现有 ReentrantLock；

读写锁 ReadWriteLock，其读锁是共享锁，其写锁是独享锁。

## 6、分段锁 ##

分段锁其实是一种锁的设计，并不是具体的一种锁。分段锁的设计目的是细化锁的粒度。

参考 ConcurrentHashMap 中 Segment。

## 7、自旋锁 ##

自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，

这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

# 二 CAS #

## 1、什么是 CAS？ ##

乐观锁思想，全称 Compare And Swap（比较与交换），解决多线程并行情况下使用锁造成性能损耗的一种机制，

减少使用锁造成的线程状态切换。是用于实现多线程同步的原子指令，它将内存位置的内容与给定值进行比较，

只有在相同的情况下，将该内存位置的内容修改为新的给定值。CAS 操作由处理器提供支持，是一种原语，

执行是连续的，不允许被中断的。

## 2、Java 中的 CAS ##

java.util.concurrent 包中大量使用了 CAS 原理，如 AtomicInteger、ReentrantLock 等。

都是调用 Unsafe 类中的方法，Unsafe 不是 Java 标准。

Unsafe 类提供一系列增加Java语言能力的操作，如内存管理、操作类/对象/变量、多线程同步等。

## 3、CAS 的缺点 ##

1）ABA 问题，当线程 A 执行 CAS 操作，尚未修改为新值之前，内存中的值已经被线程 B 连续修改了两次。

线程 A 在进行 CAS 操作时发现值没有变更，然后操作成功，但变回原值不代表没有变化。所以 Java 提供

AtomicStampedReference 来处理会发生 ABA 的场景，主要是在对象中额外再增加一个标记来标识对象是否有过变更。

2）因为 CAS 操作很多采用自旋操作，如果没有操作成功会一直循环，如果有很多个线程并发，

CAS 循环可能会长时间不成功，会增大 CPU 的执行开销。

**CAS和ABA问题：**[https://blog.csdn.net/yhl\_jxy/article/details/87520148][https_blog.csdn.net_yhl_jxy_article_details_87520148]

# 三 synchronized 实现原理 #

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

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

偏向线程ID、偏向时间戳、可偏向状态等。

**klass ：**对象头的另外一部分是 klass 类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定

这个对象是哪个类的实例。

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

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

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

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:top;width:237pt;"> 状态 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:160pt;"> 标志位 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:318pt;"> 存储内容 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:top;width:237pt;"> 未锁定 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:160pt;"> 01 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:318pt;"> 对象哈希码、对象分代年龄 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:top;width:237pt;"> 轻量级锁定 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:160pt;"> 00 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:318pt;"> 指向锁记录的指针 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:top;width:237pt;"> 重量级锁定 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:160pt;"> 10 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:318pt;"> 执行重量级锁定的指针 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:top;width:237pt;"> GC标记 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:160pt;"> 11 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:318pt;"> 空(不需要记录信息) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#ffffff;vertical-align:top;width:237pt;"> 可偏向 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:160pt;"> 01 </td> 
 <td style="border-color:#ffffff;vertical-align:top;width:318pt;"> 偏向线程ID、偏向时间戳、对象分代年龄 </td> 
 </tr> 
 </tbody> 
</table>

## 2、Monitor ##

Monitor 是一种用来实现同步的工具，任何一个对象都有一个 Monitor 与之关联，Monitor 是实现 Sychronized 的基础，

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

1）同步代码块是使用 monitorenter 和 monitorexit 指令实现的，会在同步块的区域通过 monitor 对象去获取锁和释放锁。

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

ACC\_SYNCHRONIZED 标志被设置了，执行线程将先获取 monitor，获取成功之后才能执行方法体，

方法执行完后再释放 monitor。在方法执行期间，其他任何线程都无法再获得同一个 monitor 对象。

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

**Monitor 对象关键字段：**

owner：指向一个持有当前 monitor 的 ObjectWaiter 对象（每个等待锁的线程都会被封装成 ObjectWaiter 对象）。

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

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

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

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

1）当一个线程尝试获得锁时，如果该锁已经被占用，则会将该线程封装成一个 ObjectWaiter 对象插入到 cxq 的队列的队首，

然后调用 park 函数挂起当前线程。

2）当线程释放锁时，根据 QMode 的不同，将 ObjectWaiter 从 \_cxq 或者 \_EntryList 中取出后唤醒，被唤醒后会尝试获得锁，

但不一定能获得锁。被选中的线程即为图中的Ready Thread。

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

4）线程在被 notify() 唤醒后，从 \_WaitSet 中取出第一个，根据 Policy 的不同，将这个线程放入 \_EntryList 或者 \_cxq 队列中。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70][]

## 3、JVM 锁优化 ##

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

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 1][]

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

## 1）偏向锁 ##

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

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

那么锁就进入偏向模式，此时 markword 的结构也变为偏向锁结构，当这个线程再次请求锁时，

无需再做任何同步操作，即获取锁。

## 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 发现同步锁处于偏向状态，但是 markword 中的线程 id 记录的不是 B，

那么线程 B 会试图获得锁。如果抢锁成功，就把 markword 里的线程 id 改为线程 B 的 id，线程 B 获得了偏向锁。

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

保存指向对象锁 markword 的指针，同时在对象锁 markword 中保存指向这片空间的指针。如果保存成功，

代表线程抢到了同步锁，把 markword 中的锁标志位改成 00。

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

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

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

未抢到锁的线程都会被阻塞。

# 四 Lock #

Lock 作为接口更为灵活，处理复杂的同步应用中更容易处理。可以中断等待获取锁的线程，提供公平锁模式，

返回是否获取锁的结果等。

## 1、Lock 接口的方法 ##

**lock()：**用来获取锁。如果锁已被其他线程获取，则进行等待。

**lockInterruptibly()：**当通过这个方法去获取锁时，如果线程正在等待获取锁，可以中断线程的等待状态。

当通过此方法获取某个锁时，如果未获取到，线程本身就处于一个挂起状态，调用interrupt()方法中断线程会

抛出InterruptedException异常来中断线程。

**tryLock()：**返回值为boolean类型，它表示用来尝试获取锁，无论何种情况都会立即返回结果，

在拿不到锁时不会一直等待。

**tryLock(long time, TimeUnit unit)：**此方法在拿不到锁时会等待一定的时间，如果还拿不到锁就返回false。

**unlock()：**释放锁。采用synchronized不需要用户去手动释放锁，系统会自动释放。而Lock则必须要手动释放锁，

如果没有主动释放锁，就有可能导致出现死锁现象。

**Condition newCondition()：**初始化Condition用于线程间协作。

## 2、AQS 同步器 ##

AQS（AbstractQueuedSynchronizer）就是抽象的队列式同步器，它是一个双端队列，

主要作用是用来存放在锁上阻塞的线程，当一个线程尝试获取锁失败时，

会被构造成一个 Node 节点加入到同步队列的尾部。head 节点是成功获取锁的节点，不包含在阻塞队列中。

当 head 节点线程释放锁时，会唤醒后面的节点并释放当 head 节点的引用。

![20190929143103896.png][]

AQS 主要作用是为 Java 中的并发同步组件提供统一的底层支持，我们无需关心获取资源失败，线程排队，

线程阻塞/唤醒等一系列复杂的实现。AQS 是很经典的模板方法设计模式的应用，通过继承 AQS 实现其模版方法，

实现不同的自定义同步器。

AQS 维护了一个 state（代表共享资源），并提供了一系列的 CAS 操作来管理这个同步状态。

**1）AQS 定义两种资源共享方式**

Exclusive（独占）和Share（共享）

**2）很多常用的锁都是基于 AQS 实现的，在实现时主要实现以下几种方法**

**isHeldExclusively()：**该线程是否正在独占资源。只有用到condition才需要去实现它。

**tryAcquire(int)：**独占方式。尝试获取资源，成功则返回true，失败则返回false。

**tryRelease(int)：**独占方式。尝试释放资源，成功则返回true，失败则返回false。

**tryAcquireShared(int)：**共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；

正数表示成功，且有剩余资源。

**tryReleaseShared(int)：**共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

**3）waitStatus的几种状态**

SIGNAL：后续线程正在阻塞，当前 node 在释放锁时必须启动后续线程。

CANCELLED：node 失效，因为超时或者被中断等原因。

CONDITION：node 当前属于条件锁。

PROPAGATE：node 是共享锁节点，他需要进行唤醒传播。

## 3、ReentrantLock ##

**获取锁的基本流程及使用到的方法：**  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 2][]

1）调用 AQS 的 acquire() 方法。非公平锁进入后先尝试是否可以获取到锁。

2）尝试获取锁。具体实现由 ReentrantLock 提供。公平锁不同在于需要判断有没有前继节点。

3）将当前线程加入队尾。如果队列是空的，调用 enq(node) 初始化队列并将节点放入队尾。

4）队列中获取资源，当节点的前继节点为 head 节点时尝试获取锁。

5）获取锁失败时调用，判断是否需要挂起。通过对当前节点前一个节点的状态进行判断。

6）挂起线程并检查中断状态。

7）异常或中断情况下，取消正在进行的获取尝试。

**释放锁：**

release(int) 方法是独占模式下线程释放共享资源的顶层入口。释放指定量的资源，如果彻底释放，

会唤醒等待队列里的其他线程来获取资源。

tryRelease() 需要独占模式的自定义同步器去实现，逐一释放掉重入的锁，state=0 表示彻底释放资源，返回 true。

unparkSuccessor(Node) 方法用于唤醒等待队列中下一个可以用来唤醒的线程，如果这个节点存在，调用 unpark() 方法唤醒。

## 4、共享模式 ##

**1）获取锁**  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 3][]

**acquireShared：**共享模式下线程获取共享资源的顶层入口。获取指定量的资源，获取成功则直接返回，

获取失败则进入等待队列，直到获取到资源为止，整个过程忽略中断。

**doAcquireShared：**将当前线程加入等待队列尾部休息，直到其他线程释放资源唤醒自己，成功拿到相应量的资源后才返回。

只有线程是head.next时才会去尝试获取资源。

**setHeadAndPropagate：**获取资源成功，在setHead()后如果条件符合（比如还有剩余资源或头结点已释放），

还会去唤醒后继结点。

**线程挂起：**同独占模式，如果没有资源则线程先检验是否可以阻塞，如果可以阻塞则挂起线程并检验线程中断状态。

**2）释放锁**

**releaseShared()**共享模式下线程释放共享资源的顶层入口，会释放指定量的资源，如果成功释放并且允许唤醒等待线程，

会唤醒等待队列里的其他线程来获取资源。

使用**tryReleaseShared(arg)**方法尝试释放资源，如果释放后允许唤醒后续等待结点，

则调用**doReleaseShared()**方法唤醒后继节点，自定义同步器可以根据需要决定tryReleaseShared()的返回值。

## 4、Condition ##

Condition 用来实现线程间的协作。在一个 Lock 对象里面可以创建多个Condition实例，实现多路通知功能，

在调度线程上更加灵活。

Condition依赖于Lock接口，调用Condition的await()和signal()方法必须在lock.lock()和lock.unlock()之间才可以使用。

ReetrantLock的newCondition()方法就是初始化AQS的ConditionObject对象。

ConditionObject实现了Condition接口，是AQS的内部类。每个Condition对象都包含一个等待队列，

await时当前线程包装成一个ConditionWaiter并加入至Condition等待队列的队尾，然后释放掉持有的锁。

释放掉锁后，会一直检测此节点是否在AQS队列中，直到节点被加入队列中后，重新开始竞争锁资源。

singal唤醒时，将Condition队列的队首节点添加至AQS的队尾，并尝试设置前置任务的waitstatus，

以指示线程正在等待。如果取消或尝试设置waitstatus失败，唤醒线程以重新同步。

**ReentrantLock和Condition实现原理：**[https://blog.csdn.net/yhl\_jxy/article/details/87088314][https_blog.csdn.net_yhl_jxy_article_details_87088314]

# 五 锁优化 #

**1）减小锁的持有时间**

锁持有的时间长，后面的线程等待的时间就长，不需要同步执行的代码不要放在同步块内，

可以让锁尽快释放。提高系统的吞吐量。

**2）减小锁的粒度**

一个锁拆成逻辑上的多个锁，增加并行度，从而降低锁竞争，比如 ConcurrentHashMap，

只锁住一个 Segment，不是锁住整个对象。

**3）锁粗化**

大部分情况下我们是要让锁的粒度最小化，锁的粗化则是要增大锁的粒度;

假如有一个循环，循环内的操作需要加锁，我们应该把锁放到循环外面，否则每次进出循环，

都进出一次临界区，效率是非常差的。

**4）使用读写锁替换独占锁**

ReentrantReadWriteLock 是一个读写锁，读操作加读锁，可以并发读，写操作使用写锁，只能单线程写。

**5）锁分离**

如果将读写锁进一步延伸，就是锁分离，读写锁根据读写操作功能的不同，进行了有效的分离。

[https_github.com_yihonglei_jdk-source-code-reading]: https://github.com/yihonglei/jdk-source-code-reading
[https_blog.csdn.net_yhl_jxy_article_details_87520148]: https://blog.csdn.net/yhl_jxy/article/details/87520148
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70]: /images/20230809/4f4e8cd99be541338b7a70d8de6c5ea5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 1]: /images/20230809/18fd4a3e68834029979cd92799a83250.png
[20190929143103896.png]: /images/20230809/fcae1ab765404236b22b56f739cd3f9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 2]: /images/20230809/7510f9c0ee754d8d9b3ddef4266d010d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70 3]: /images/20230809/050fdf7b9a264279bfcabada87ef5c74.png
[https_blog.csdn.net_yhl_jxy_article_details_87088314]: https://blog.csdn.net/yhl_jxy/article/details/87088314