跟 Synchronized 相比，可重入锁 ReentrantLock 其实现原理有什么不同？

最新推荐文章于 2025-11-19 19:19:43 发布
原创 最新推荐文章于 2025-11-19 19:19:43 发布 · 505 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #java

与Synchronized相比，可重入锁ReentrantLock在实现原理上存在显著的区别。以下是对这两者的实现原理的详细对比：

一、底层机制与实现方式

  1. Synchronized

    • 属于JVM内置锁，通过JVM隐式实现。
    • 每个Java对象都隐式包含一个监视器（Monitor）对象，加锁的过程就是竞争这个监视器对象的过程。
    • 当线程进入synchronized代码块或方法时，会尝试获取对象的监视器锁。如果获取成功，则线程可以执行同步代码；如果获取失败，则线程会被阻塞，直到锁被释放。

  2. ReentrantLock

    • 是基于AQS（AbstractQueuedSynchronizer，队列同步器）实现的。
    • AQS是一个用于构建锁或其他同步组件的基础框架，它内部实现了两个队列：同步队列和条件队列，用于管理线程的等待和唤醒状态。
    • ReentrantLock通过重写AQS的tryAcquire和tryRelease等方法来实现锁的获取和释放。
    • ReentrantLock默认实现为非公平锁，但也可以配置为公平锁。

二、锁的获取与释放

  1. Synchronized

    • 隐式获取和释放锁。线程在进入synchronized代码块或方法时自动获取锁，离开时自动释放锁。
    • 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生。

  2. ReentrantLock

    • 显式获取和释放锁。需要程序员手动调用lock()方法来获取锁，调用unlock()方法来释放锁。
    • 在发生异常时，如果没有主动通过unlock()去释放锁，则很可能造成死锁现象。因此，使用ReentrantLock时需要在finally块中释放锁。

三、锁的特性与功能

  1. Synchronized

    • 不可响应中断。一个线程在获取不到锁时会一直等待下去，不能响应中断。
    • 锁是非公平的，即锁的分配是随机的，不保证按照线程请求锁的顺序来分配。

  2. ReentrantLock

    • 可以响应中断。线程在等待锁时可以选择放弃等待，响应中断。
    • 提供公平锁和非公平锁两种模式。公平锁按照线程请求锁的顺序来分配锁，非公平锁则可能允许插队。
    • 提供Condition接口，允许线程在获得锁后等待特定的条件满足后再执行。
    • 可以绑定多个条件变量，通过Condition对象实现更复杂的线程同步需求。

四、性能与适用场景

  1. Synchronized

    • 由于是JVM内置锁，性能通常较高，且使用简单。
    • 适用于不需要特别高的灵活性和控制能力的场景。

  2. ReentrantLock

    • 性能可能因实现细节和锁类型（公平锁/非公平锁）而有所不同。
    • 提供了更多的控制和功能，适用于需要更高灵活性和控制能力的场景。
    • 在高竞争情况下，ReentrantLock的性能可能更好，因为它提供了更多的高级功能，如公平锁、可中断锁等。

综上所述，Synchronized和ReentrantLock在实现原理上存在显著的区别，主要体现在底层机制与实现方式、锁的获取与释放、锁的特性与功能以及性能与适用场景等方面。开发者在选择使用哪种锁时，应根据具体的应用场景和需求进行权衡和选择。

2401_87715607
关注
Java基础篇--synchronized 和 ReentrantLock 的实现原理是什么？它们有什么区别？
爱分享的淘金达人
06-21 403
在 JDK 1.5 之前共享对象的协调机制只有 synchronized 和 volatile，在 JDK 1.5 中增加了新的机制 ReentrantLock，该机制的诞生并不是为了替代 synchronized，而是在 synchronized 不适用的情况下，提供一种可以选择的高级功能。 我们本课时的面试题是，synchronized 和 ReentrantLock 是如何实现的？它们有什么区别？ 典型回答 synchronized 属于独占式悲观锁，是通过 JVM 隐式实现的，synchron
synchronized 和 ReentrantLock 的实现原理
w1061217723的博客
03-15 911
两者区别 synchronized 属于独占式悲观锁，是通过 JVM 隐式实现的，synchronized 只允许同一时刻只有一个线程操作资源。 在 Java 中每个对象都隐式包含一个 monitor（监视器）对象，加锁的过程其实就是竞争 monitor 的过程，当线程进入字节码 monitor enter 指令之后，线程将持有 monitor 对象，执行 monitor exit 时释放 monitor 对象，当其他线程没有拿到 monitor 对象时，则需要阻塞等待获取该对象。 ReentrantLoc
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 1218
ReentrantLock 是 Java 并发包（java.util.concurrent.locks）中的一个可重入锁实现，它提供了比 synchronized 关键字更灵活、功能更丰富的线程同步机制。ReentrantLock类内部总共存在Sync、NonfairSync、FairSync三个类，NonfairSync（非公平锁）与FairSync（公平锁）类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类。
ReentrantLock底层原理
最新发布
zhouyunjian的博客
11-19 583
ReentrantLock源码分析
synchronized和reentrantlock的底层实现及重入的底层原理
泗水长流的博客
06-28 2473
(1) synchronized的底层实现 synchronized是用来保证线程同步，用的锁存在java对象头中，利用monitorenter和monitorexit指令实现，monitorenter指令是在编译后插入到同步代码块开始位置，而monitorexit是插入到方法结束后和异常处。jdk1.6之后引入了大量的优化，这其中又涉及到锁的四种升级状态：new(无锁) →偏向锁→轻量级锁（自旋锁）→重量级锁。而底层，synchrnoized是利用操作系统的Mutex Lock(互斥锁)来实现的， （
synchronized和reentrantLock的底层实现
八荒六合唯我独尊
06-01 884
实现synchronized的基础: Java对象头 + Monitor 对象头的结构如下: 虚拟机位数 头对象结构 说明 32/64bit Mark Word 默认存储对象的hashcode，分代年龄，锁类型，锁标志位等信息。 32/64bit Class Metadata Address 类型指针指向对象的类元数据，JVM通过这个指针确定该对象是哪个类的数据。 Mark Word的说明图: 而对于Monitor，每个Java对象天生自带一把.
可重入锁ReentrantLock的原理及使用
apple_51673523的博客
08-09 1918
在公平模式下，锁会按照线程的请求顺序分配，遵循先进先出的原则。构造方法接受一个可选的公平参数（默认非公平锁），当设置为true时，表示公平锁，否则为非公平锁。公平锁的效率往往没有非公平锁的效率高，在许多线程访问的情况下，公平锁表现出较低的吞吐量。ReentrantLock是一个强大而灵活的同步工具，它提供了更多的控制选项和功能，适用于各种复杂的同步需求。方法，它可以尝试获取锁，如果锁当前不可用，则立即返回结果。，因此在使用时需要谨慎，并确保正确处理锁的获取和释放，以避免死锁和其他并发问题。
ReentrantLock的实现原理
盛夏温暖流年
09-30 4647
ReentrantLock 简介 ReentrantLock 实现了 Lock 接口，是一种可重入的独占锁。 相比于 synchronized 同步锁，ReentrantLock 更加灵活，拥有更加强大的功能，比如可以实现公平锁机制。 首先，先来了解一下什么是公平锁机制。 ReentrantLock 的公平锁机制 我们知道，ReentrantLock 分为公平锁和非公平锁，可以通过构造方法来指定具体类型： //默认非公平锁 public ReentrantLock() { sync =
ReentrantLock可重入锁的实现原理
张毅的博客
06-11 1474
ReentrantLock可重入锁的实现原理1. Lock接口2. 公平锁和非公平锁的实现2.1 公平锁2.2 非公平锁3.总结 首先先介绍Lock接口，然后通过分析ReentrantLock的lock方法和unlock方法，来解释ReentrantLock的内部原理. 1. Lock接口 Lock接口，是对控制并发的工具的抽象。它比使用synchronized关键词更灵活，并且能够支持条件变量。 它是一种控制并发的工具，一般来说，它控制对某种共享资源的独占。也就是说，同一时间内只有一个线程可以获取这个锁
ReentrantLock锁
weixin_46121031的博客
05-14 7363
1. 简介 ReentrantLock，可重入锁，是一种递归无阻塞的同步机制。它可以等同于 synchronized 的使用，但是 ReentrantLock 提供了比 synchronized 更强大、灵活的锁机制，可以减少死锁发生的概率
【面试必问系列】之ReentrantLock详解
一个喜欢诗和远方的程序媛
01-08 8185
的队列，可以用于构建锁的基础框架，内部通过原子变量state来表示锁的状态，当state大于0的时候表示锁被占用，如果state等于0时表示没有占用锁，ReentrantLock是一个重入锁，表现在state上，如果持有锁的线程重复获取锁时，它会将state状态进行递增，也就是获得一个信号量，当释放锁时，同时也是释放了信号量，信号量跟随减少，如果上一个线程还没有完成任务，则会进行入队等待操作。而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。
ReentrantLock介绍及使用(超详细)
热门推荐
Mr.绵羊的知识星球
02-17 2万+
1. Reentrantlock介绍及使用 2. 公平锁和非公平锁 3. Reentrantlock的使用案例 4. Reentrantlock使用时注意事项
ReentrantLock 锁详解
m0_37235955的博客
04-27 3604
ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantLock 默认实现的是公平还是非公平锁.
ReentrantLock并发锁使用详解
Huangjiazhen711的博客
10-13 1688
进入源码可以看到，其实现了公平锁和非公平锁内部实现了加锁的操作，并且支持重入锁。不用我们再重写解锁操作。
Java：Java学习笔记之ReentrantLock的简单理解和使用
JMW1407的博客
01-21 6827
ReentrantLock ReentrantLock1、相关知识1.1 公平锁和非公平锁1.2 可重入锁1.3、CAS算法2、背景、定义和特征2.1、背景2.2、定义2.3、特征3、基本结构4、基本使用4.1、解决背景问题4.2、重入锁 使用4.3、公平锁使用5、源码分析5.1、AQS5.2、非公平锁的实现原理5.2.1、lock方法获取锁:tryAcquire5.2.2、锁的释放:tryRelease5.3、公平锁的实现原理5.3.1、lock方法获取锁:tryAcquire5.3.2、锁的释放:try
ReentrantLock简单理解
qq_36138652的博客
06-14 2584
ReentrantLock
重入锁ReentrantLock
08-08
<think>我们重点讨论ReentrantLock，它是Java中一个重要的可重入锁实现，基于AQS（AbstractQueuedSynchronizer）框架。 根据引用[1][2][3]，我们将从底层原理、实现机制、使用场景和代码示例几个方面展开。 一、底层原理 ReentrantLock的核心是AQS（AbstractQueuedSynchronizer），它使用一个整型的volatile变量（state）来表示锁的状态，以及一个FIFO线程等待队列（CLH队列的变体）来管理未获取到锁的线程。 1.1 可重入性实现 当线程第一次获取锁时，通过CAS操作将state从0设置为1，并记录当前锁的持有者（exclusiveOwnerThread）。同一线程再次获取锁时，state递增，释放时递减，直到state为0时完全释放锁。 1.2 公平锁与非公平锁（引用[2]） - 非公平锁（默认模式）：新线程尝试获取锁时，不管等待队列中是否有其他线程在等待，直接尝试CAS抢锁。如果失败，则加入队列等待。这种方式可能导致线程饥饿，但性能高。 - 公平锁：新线程尝试获取锁时，先检查等待队列中是否有等待线程，如果有则直接加入队列末尾，按顺序获取锁。保证公平性，但性能较低。 二、实现步骤（以非公平锁为例） 1. lock()方法： - 尝试通过CAS将state从0设置为1（快速获取） - 如果成功，设置当前线程为锁持有者 - 如果失败，调用acquire(1)方法（该方法在AQS中） 2. acquire(1)方法： - 首先调用tryAcquire(1)（由子类实现）再次尝试获取锁（此时可能由于锁重入而成功） - 如果失败，则调用addWaiter将当前线程加入等待队列（节点模式为独占模式） - 然后调用acquireQueued方法，在队列中自旋或阻塞等待 3. unlock()方法： - 调用tryRelease(1)（由子类实现）释放锁（state减1，如果减到0则完全释放） - 唤醒队列中的下一个线程（如果有） 三、使用场景 - 需要可重入锁特性的场景（例如递归调用加锁） - 需要尝试非阻塞获取锁（tryLock） - 需要可中断的锁获取（lockInterruptibly） - 需要公平锁机制（防止线程饥饿） - 需要绑定多个条件（Condition，比Object的wait/notify更灵活） 四、代码示例 4.1 基本使用 ```java import java.util.concurrent.locks.ReentrantLock; public class ReentrantLockExample { private final ReentrantLock lock = new ReentrantLock(); public void criticalSection() { lock.lock(); // 获取锁 try { // 临界区代码 System.out.println(Thread.currentThread().getName() + " 进入临界区"); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); // 释放锁 System.out.println(Thread.currentThread().getName() + " 离开临界区"); } } public static void main(String[] args) { final ReentrantLockExample example = new ReentrantLockExample(); // 创建多个线程测试 for (int i = 0; i < 5; i++) { new Thread(example::criticalSection).start(); } } } ``` 4.2 可中断锁 ```java public void interruptibleLock() { try { lock.lockInterruptibly(); // 可中断加锁 try { // 临界区 } finally { lock.unlock(); } } catch (InterruptedException e) { // 处理中断 Thread.currentThread().interrupt(); } } ``` 4.3 尝试获取锁（tryLock） ```java public void tryLockExample() { if (lock.tryLock()) { // 尝试获取锁，立即返回结果 try { // 临界区 } finally { lock.unlock(); } } else { // 执行其他操作 } } // 带超时的tryLock public void tryLockWithTimeout() throws InterruptedException { if (lock.tryLock(2, TimeUnit.SECONDS)) { // 最多等待2秒 try { // 临界区 } finally { lock.unlock(); } } else { // 超时未获取锁 } } ``` 4.4 公平锁 ```java // 创建公平锁 ReentrantLock fairLock = new ReentrantLock(true); public void fairLockExample() { fairLock.lock(); try { // 临界区 } finally { fairLock.unlock(); } } ``` 五、原理总结 - 可重入性：通过记录持有锁的线程和重入次数（state）实现。 - 公平性：公平锁严格按照等待队列顺序获取锁；非公平锁允许插队，提高吞吐量。 - 锁释放：必须由持有锁的线程释放，且次数匹配（state归零）。 注意：必须将unlock()放在finally块中，以确保锁的释放。 相关问题： 1. ReentrantLock的公平锁和非公平锁在性能上有何差异？为什么？ 2. ReentrantLock的Condition机制是如何实现的？ 3. ReentrantLock与synchronized关键字相比有哪些优势？ 4. 为什么ReentrantLock的tryLock方法是非公平的？ 5. 在哪些场景下应该使用ReentrantLock而不是synchronized？</think>### Java ReentrantLock 深度解析 #### 一、底层原理 ReentrantLock 的核心是 **AQS（AbstractQueuedSynchronizer）框架**[^1]，其实现基于三个关键组件： 1. **volatile int state**：锁状态标记（0=未锁定，≥1=锁定/重入次数） 2. **CLH队列**：双向链表实现的线程等待队列（FIFO） 3. **CAS操作**：通过 `Unsafe.compareAndSwapInt()` 实现原子状态变更 ```mermaid graph LR A[lock.lock] --> B[尝试CAS设置state] B -->|成功| C[设置持有线程=当前线程] B -->|失败| D[加入CLH队列尾部] D --> E[LockSupport.park 阻塞] ``` **公平锁 vs 非公平锁** 实现差异[^2]： - **非公平锁**（默认）：新线程直接尝试抢锁（可能插队） - **公平锁**：严格按CLH队列顺序获取锁 #### 二、功能实现步骤 ##### 1. 加锁流程 ```java final void lock() { // 非公平锁实现 if (compareAndSetState(0, 1)) // CAS尝试快速获取锁 setExclusiveOwnerThread(Thread.currentThread()); // 成功则记录持有线程 else acquire(1); // 进入AQS排队流程 } ``` **重入机制**：同一线程重复获取时，state 值递增（state=2 表示重入1次） ##### 2. 解锁流程 ```java public void unlock() { sync.release(1); // 释放锁资源 } protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); // 非持有线程禁止解锁 boolean free = false; if (c == 0) { // 完全释放锁 free = true; setExclusiveOwnerThread(null); } setState(c); // 更新状态 return free; } ``` #### 三、使用场景与代码实例 ##### 场景1：基础锁保护 ```java ReentrantLock lock = new ReentrantLock(); private int balance = 100; void transfer(int amount) { lock.lock(); // 获取锁 try { if (balance >= amount) { balance -= amount; System.out.println("转账成功，余额：" + balance); } } finally { lock.unlock(); // 必须finally释放 } } ``` ##### 场景2：可中断锁（应对任务取消）[^3] ```java ReentrantLock lock = new ReentrantLock(); void criticalTask() throws InterruptedException { try { lock.lockInterruptibly(); // 可中断加锁 // 执行敏感操作 } finally { if (lock.isHeldByCurrentThread()) lock.unlock(); } } // 调用线程可执行：thread.interrupt() 中断等待 ``` ##### 场景3：公平锁（防止线程饥饿） ```java ReentrantLock fairLock = new ReentrantLock(true); // 启用公平模式 void fairAccess() { fairLock.lock(); try { // 资源访问（按请求顺序执行） } finally { fairLock.unlock(); } } ``` ##### 场景4：尝试锁（避免死锁） ```java if (lock.tryLock(2, TimeUnit.SECONDS)) { // 最多等待2秒 try { // 成功获取锁 } finally { lock.unlock(); } } else { System.out.println("获取锁超时，执行备用方案"); } ``` #### 四、与synchronized对比 | **特性** | `ReentrantLock` | `synchronized` | |------------------------|----------------------------------|--------------------------| | 锁获取方式 | 显式调用 `lock()`/`unlock()` | 隐式（代码块/方法） | | 可中断性 | ✅ 支持 `lockInterruptibly()` | ❌ 不支持 | | 公平锁 | ✅ 可配置公平策略 | ❌ 仅非公平 | | 条件变量 | ✅ 支持多个 `Condition` | ❌ 单条件等待 | | 锁释放 | 必须手动释放（易出错） | 自动释放 | | 性能 | 高竞争场景更优 | Java 6+优化后接近 | #### 五、最佳实践 1. **必须**在 `finally` 块中释放锁 2. 避免锁嵌套，防止死锁（可用 `tryLock` 超时机制） 3. 读多写少场景考虑 `ReadWriteLock` 4. 锁粒度尽量细化，减少临界区代码 > ⚠️ **典型错误**： > ```java > lock.lock(); > try { > // 可能抛出异常的代码 > } finally { > // 忘记调用 unlock() > } > ``` --- ### 原理总结 1. **可重入性**：通过记录持有线程和重入计数（state）实现[^1] 2. **公平性**：公平锁严格按CLH队列顺序获取，非公平锁允许插队[^2] 3. **中断响应**：通过 `Thread.interrupt()` 唤醒等待线程[^3] 4. **性能优化**：CAS操作减少内核态切换，CLH队列降低竞争
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值