【多线程】轻松彻底搞懂ReentrantLock的底层实现原理

最新推荐文章于 2025-09-12 14:47:00 发布
原创 最新推荐文章于 2025-09-12 14:47:00 发布 · 1.3k 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

前言

上篇博客讲解了Sychronized的底层实现原理，它是基于jdk实现的，现在此篇博客讲解基于AQS 框架实现的另一个锁ReentrantLock

1、名词解释

为什么叫CLH队列

CLH 全称是三个人创造的，分别为Craig、Landin、Hagersten，所以以这个三个名字的首字母命名，原始的CLH锁是一种单向链表结构的自旋锁队列
每个节点仅包含：

前驱指针（myPred）：指向队列中前一个节点
状态变量（locked）：表示当前线程是否需要获取锁（true=需要自旋等待，false=可获取锁）
线程信息：封装当前等待线程

但是在ReentrantLock里它对原来的CLH队列进行了升级，Java 并发包中的 AQS 框架采用 CLH 锁的变体（虚拟双向队列（FIFO队列）），通过封装线程为 Node 对象实现锁分配。

2、ReentrantLock的实现

2.1 Node的数据结构

在AQS框架中，是使用队列的方式来实现同步管理的，队列中每个节点是Node节点，看下Node的数据结构,

        static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null;
        static final int CANCELLED =  1;
        static final int SIGNAL    = -1;
        static final int CONDITION = -2;
        static final int PROPAGATE = -3;
        volatile int waitStatus;
        volatile Node prev;
        volatile Node next;
        volatile Thread thread;
        Node nextWaiter;

源码如上，其实核心的结构就是

thread：一个等待获取同步状态的线程

prev：指向上一个节点的引用

next：指向下一个节点的引用

waitStatus：等待的状态：
在这里插入图片描述
1.CANCELLED：值尾1，表示在同步队列中等待的线程等待超时或被中断，需要从同步队列中取消等待，接入CANCELLED状态后将不会再变化
2.SIGNAL：值尾-1，表示后续节点的线程处于等待状态，如果当前节点的线程释放了同步状态或者被取消便会通知后续节点，使后续节点的线程得以运行
3.CONDITION，值为-2 表示节点再条件队列中，节点等待线程再Condition上，当其它线程队Condition调用了signal()后，该节点将会从条件队列中转移到同步队列中
4.PROPAGATE：值为-3，表示下一次共享式同步状态获取将会无条件传播下去

nextWaiter：表示条件队列中的后续节点，如果当前节点是共享的，那么这个字段将是一个SHARED变量static final Node SHARED = new Node();，也就是说节点类型（独占和共享）和条件队列中的后续节点共用同一个字段EXCLUSIVE：独占模式节点

AQS实现原理

上边介绍了AQS 中的Node节点，现在说下AQS实现的原理

核心元素
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
   
   
	// Node节点
    static final class Node {
   
   ...}
    // 指向头节点
    private transient volatile Node head;
    // 指向尾节点
    private transient volatile Node tail;
    // 表示资源的可用状态
    private volatile int state;
}
AQS 中的同步等待队列结构

AQS中 维护了一个volatile int state（代表共享资源）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。
这里volatile能够保证多线程下的可见性，当state=1则代表当前对象锁已经被占有，其他线程来加锁时则会失败，加锁失败的线程会被放入一个FIFO的等待队列中，比列会被LockSupport.park()操作挂起，等待其他获取锁的线程释放锁才能够被唤醒。另外state的操作都是通过CAS来保证其并发修改的安全性。锁的可重入性state也会有所体现，当state等于0说明没有其它线程获取锁，可以被获取，获取后会设为1并将exclusiveOwnerThread设置为获取到锁的线程,如果不是等于0则判断是否是exclusiveOwnerThread的线程，是的话则获取锁，state+1，否则进入等待队列进行排队。需要注意的是head 指向的是一个虚拟节点，该节点不关联任何线程（thread=null），仅作为队列的起始标识。这种设计简化了队列操作，避免在无竞争时频繁创建和销毁节点
在这里插入图片描述

源码分析
1、ReentrantLock下的lock方法
   public ReentrantLock() {
   
   
        sync = new NonfairSync
最低0.47元/天 解锁文章
Java并发编程系列06:Lock之ReentrantLock(1)
fen_fen的专栏
11-25 1057
前提：在学Lock时，发现创建对象用的是ReentrantLock。这里也了解下“ReentrantLock” //创建一个锁对象 private final Lock lock = new ReentrantLock(); 上一篇文章：多线程学习04--＞解决多线程安全-Lock https://blog.youkuaiyun.com/fen_fen/article/details/121470551 ReentrantLock简介 ReentrantLock是一个可重入且独占式的锁，它具有与使用sy
Java多线程和并发编程面试题和参考答案100多道（持续更新）
大模型大数据攻城狮的专栏
05-20 624
守护线程（Daemon Thread）是一种特殊的线程，它在执行时不会阻止JVM的退出。当所有的非守护线程都结束运行时，JVM会自动退出，即使守护线程还在运行。守护线程主要用于执行一些后台任务，如垃圾回收、监控等。用途举例垃圾回收线程：JVM内部的垃圾回收线程就是一个典型的守护线程，它负责监控对象的使用情况，并在适当的时候回收不再使用的对象，释放内存资源。日志记录线程。
ReentrantLock从结构底层到原理一篇讲清
不经风雨，如何见彩虹
07-01 2237
ReentrantLock 1.是什么 Reetrantlock是一个可以重复获得锁的一个互斥锁，它的加锁与解锁都是需要手动执行，也可以多次加锁，同时它还可以指定是由公平锁还是非公平锁实现。 2.内部实现 构造方法： public ReentrantLock() { sync = new NonfairSync(); } public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : ne
最常用的锁：ReentrantLock可重入锁
最新发布
2401_85973273的博客
09-12 1397
本文系统解析了Java并发编程中的ReentrantLock同步工具。作为synchronized的增强替代方案，ReentrantLock通过AQS实现，具备可重入性、可中断锁获取、公平/非公平模式选择及多条件变量等核心特性。文章详细对比了其与synchronized的差异，包括灵活性、性能表现和使用复杂度，并给出标准使用流程（必须在try-finally中确保锁释放）和典型应用场景（如生产者-消费者模型）。最后指出应基于具体需求在易用性（synchronized）与高级功能（ReentrantLock）
ReentrantLock详解(可重入、可中断、锁超时、公平锁、条件变量)、同步模式之顺序控制
张大安的博客
03-12 1万+
文章目录1.ReentrantLock详解1.1 可重入1.2 可中断 lockInterruptibly()1.3 设置超时时间 tryLock()1.4 通过lock.tryLock()来解决, 哲学家就餐问题1.5 公平锁 new ReentrantLock(true)1.6 条件变量 Condition 1.ReentrantLock详解 相对于synchronized 它具备如下特点 可中断 可以设置超时时间 可以设置为公平锁 支持多个条件变量 与 synchronized 一样,都支持可重入
ReentrantLock详解
超级博客
04-19 1147
ReentrantLock 是 Java 并发包（java.util.concurrent.locks）中的一个可重入锁实现，它提供了比 synchronized 关键字更灵活、功能更丰富的线程同步机制。ReentrantLock类内部总共存在Sync、NonfairSync、FairSync三个类，NonfairSync（非公平锁）与FairSync（公平锁）类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类。
ReentrantLock实现原理
weixin_30687587的博客
02-15 493
以下是本篇文章的大纲 1 synchronized和lock 1.1synchronized的局限性 1.2 Lock简介 2 AQS 3 lock()与unlock()实现原理 3.1 基础知识 3.2 内部结构 3.3 NonfairSync 3.3.1 lock() 3.3.2 unlock() 3.3.3 小结 3.4 FairS...
ReentrantLock 实现原理
weixin_34152820的博客
01-26 185
使用 synchronize 来做同步处理时，锁的获取和释放都是隐式的，实现的原理是通过编译后加上不同的机器指令来实现。 而 ReentrantLock 就是一个普通的类，它是基于 AQS(AbstractQueuedSynchronizer)来实现的。 是一个重入锁：一个线程获得了锁之后仍然可以反复的加锁，不会出现自己阻塞自己的情况。 AQS 是 Java 并发包里实现锁、同步的一个重要的基...
【Java线程安全策略】：揭秘实现线程安全的8种模式，轻松应对多线程挑战
线程安全是多线程编程中的一个核心概念，指的是当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要额外的同步及协同，这个类都能表现出正确的行为。...
Java高频面试基础问题与知识点整理
热门推荐
张彦峰的博客
11-04 171万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
ReentrantrantLock 底层实现原理
快乐的小三菊的博客
07-26 1221
ReentrantrantLock 底层实现原理包括如何保证可重入、可打断、公平和非公平、条件变量底层实现原理等。
ReentrantLock 底层原理
weixin_54232666的博客
06-11 4373
想弄懂 ReentrantLock 底层原理，这一篇就够了！包含 AQS底层原理，ReentrantLock公平锁、可重入、可打断的实现原理。
ReentrantLock 实现原理（公平锁和非公平锁）
11-27 1218
使用 synchronized 来做同步处理时，锁的获取和释放都是隐式的，实现的原理是通过编译后加上不同的机器指令来实现。 而 ReentrantLock 就是一个普通的类，它是基于 AQS(AbstractQueuedSynchronizer)来实现的。 是一个重入锁：一个线程获得了锁之后仍然可以反复的加锁，不会出现自己阻塞自己的情况。 AQS 是 Java 并发包里实现锁、同步的一个重...
ReentrantLock的实现原理
盛夏温暖流年
09-30 4626
ReentrantLock 简介 ReentrantLock 实现了 Lock 接口，是一种可重入的独占锁。 相比于 synchronized 同步锁，ReentrantLock 更加灵活，拥有更加强大的功能，比如可以实现公平锁机制。 首先，先来了解一下什么是公平锁机制。 ReentrantLock 的公平锁机制 我们知道，ReentrantLock 分为公平锁和非公平锁，可以通过构造方法来指定具体类型： //默认非公平锁 public ReentrantLock() { sync =
ReentrantLock底层原理
weixin_45651194的博客
07-08 786
简介 一言以蔽之： ReentrantLock主要基于CAS和AQS实现，支持公平锁和非公平锁。 CAS：见CAS、悲观锁、乐观锁，看完直接骑脸输出 AQS：AbstractQueuedSynchronizer（抽象队列同步器）类的简称，是一个用于构建锁和同步容器的框架。concurrent包内许多类都是基于AQS实现的，例如ReentrantLock、Semaphore、ReentrantReadWriteLock（读写锁）等。 ReentrantLock的基本实现：一个线程通过CAS尝试获得锁，若此时已
ReentrantLock底层实现原理
03-21
### Java ReentrantLock 底层实现机制 #### 锁的核心概念 `ReentrantLock` 是基于 `AbstractQueuedSynchronizer (AQS)` 实现的一种可重入互斥锁。它支持公平和非公平两种模式，并且允许线程多次获取同一把锁而不会发生死锁[^3]。 #### AQS 的核心作用 AQS 提供了一个框架用于构建依赖于 FIFO 等待队列的阻塞锁和其他同步器。`ReentrantLock` 利用了 AQS 的独占模式，通过维护一个 `volatile int state` 变量来记录锁的状态。该变量表示当前锁被持有的次数[^4]。 #### 加锁过程 (`lock()` 方法) 当调用 `lock()` 方法时，`ReentrantLock` 会尝试获取锁。以下是其主要逻辑： 1. **状态检查** 调用 `nonfairTryAcquire(int acquires)` 方法检查锁是否已被其他线程持有。如果没有被占用，则尝试使用 CAS 操作设置 `state` 并标记当前线程为锁拥有者[^5]。 2. **可重入性处理** 如果锁已经被当前线程持有，则增加 `state` 计数以反映锁的嵌套级别。每次调用 `unlock()` 方法都会减少计数值，只有当计数归零时才会真正释放锁。 3. **排队等待** 若锁被其他线程持有且无法立即获取，则当前线程会被加入到 AQS 维护的 CLH 队列中并进入阻塞状态，直到轮到自己再次尝试获取锁[^1]。 #### 解锁过程 (`unlock()` 方法) 解锁操作相对简单，主要是减少 `state` 计数并唤醒下一个等待线程。具体流程如下： 1. 减少 `state` 值； 2. 当前线程确认不再持有锁后，通知后续节点重新竞争资源； 3. 如果有多个线程处于等待状态，按照 FIFO 或指定策略依次唤醒它们。 #### 公平与非公平锁的区别 - **非公平锁**：不考虑线程到达顺序，在任何情况下都可能直接尝试抢占锁，即使已有线程正在等待。这种方式提高了吞吐量但可能导致某些线程长期得不到执行机会（即饥饿现象）。 - **公平锁**：严格按照请求先后次序分配锁给线程，虽然更公正但也带来了额外开销，降低了整体性能[^2]。 ```java public class TestReentrantLock { private final ReentrantLock lock = new ReentrantLock(); public void testMethod() { lock.lock(); // 获取锁 try { System.out.println(Thread.currentThread().getName() + " acquired the lock."); } finally { lock.unlock(); // 释放锁 } } public static void main(String[] args) throws InterruptedException { TestReentrantLock test = new TestReentrantLock(); Thread t1 = new Thread(test::testMethod, "Thread-1"); Thread t2 = new Thread(test::testMethod, "Thread-2"); t1.start(); t2.start(); t1.join(); t2.join(); } } ``` 上述代码展示了如何创建以及管理基本的 `ReentrantLock` 实例，并演示了多线程环境下的锁定行为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值