Javajava
Java 重入锁（ReentrantLock）核心特性与源码剖析
Java 重入锁（ReentrantLock）是 Java 并发包中功能强大的同步工具。相比 synchronized，它支持可重入、公平/非公平模式、可中断等待、超时获取及多条件变量。深入解析其基础用法、核心特性、与 synchronized 的对比，并基于 AQS 和 CAS 机制剖析源码实现原理，涵盖加锁、入队、释放流程及实战最佳实践，帮助开发者在高并发场景下选择合适的同步策略。
Java 重入锁（ReentrantLock）是 Java 并发包中功能强大的同步工具。相比 synchronized，它支持可重入、公平/非公平模式、可中断等待、超时获取及多条件变量。深入解析其基础用法、核心特性、与 synchronized 的对比，并基于 AQS 和 CAS 机制剖析源码实现原理，涵盖加锁、入队、释放流程及实战最佳实践，帮助开发者在高并发场景下选择合适的同步策略。
在多线程编程的世界里，锁是最核心的同步工具之一。Java 从语言层面提供了 synchronized 关键字来实现线程同步，简单而有效。然而，随着并发需求的复杂化，synchronized 的局限性逐渐显现——它无法响应中断、无法设置超时、默认非公平且灵活性不足。为了解决这些问题，Java 在 java.util.concurrent.locks 包中提供了 ReentrantLock（重入锁），一个功能更强大、使用更灵活的锁工具。
本文将带你全方位地认识 ReentrantLock，从基本概念到高级特性，从使用方式到源码剖析，从底层原理到实际应用。无论你是初学者还是希望深入理解并发编程的开发者，相信都能从中获得启发。
重入锁（Reentrant Lock），顾名思义，就是支持重入特性的锁。重入是指：同一个线程在持有锁的情况下，可以多次获取同一把锁而不会被阻塞。
举个例子：如果一个线程已经获得了某个对象的锁，当它再次请求该对象的锁时，会直接成功，而不是死锁等待。这种机制在递归方法调用或嵌套同步块中至关重要。
public class ReentrantExample {
private final Object lock = new Object();
public void methodA() {
synchronized (lock) {
// 已经持有锁
methodB(); // 再次请求同一把锁
}
}
public void methodB() {
synchronized (lock) {
// 这里不会死锁，因为 synchronized 是可重入的
System.out.println("methodB 执行");
}
}
}
ReentrantLock 同样支持这种重入特性，但它提供了比 synchronized 更丰富的功能。
synchronized 作为 Java 内置的关键字，使用简单，由 JVM 自动加锁和解锁，且经过多年的优化（偏向锁、轻量级锁、重量级锁升级），性能已经不逊色于 ReentrantLock。既然如此，为什么还需要 ReentrantLock？
这是因为 ReentrantLock 弥补了 synchronized 的几个功能性缺陷：
| 特性 | synchronized | ReentrantLock |
|---|---|---|
| 使用方式 | 关键字，自动释放 | API 调用，需手动释放 |
| 锁获取响应中断 | 不支持 | 支持（lockInterruptibly()） |
| 尝试获取锁 | 不支持 | 支持（tryLock()） |
| 超时获取锁 | 不支持 | 支持（tryLock(long, TimeUnit)） |
| 公平锁 | 非公平 | 可设置公平/非公平 |
| 条件变量 | 每个对象一个等待集 | 一个锁可绑定多个 Condition |
| 获取锁状态 | 无法得知 | 可查询持有线程、等待队列等 |
简单来说，当需要更精细的控制同步行为时，ReentrantLock 是更好的选择。
在深入原理之前，我们先来看看 ReentrantLock 的标准使用模式：
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private final ReentrantLock lock = new ReentrantLock();
private int count = 0;
public void increment() {
lock.lock(); // 获取锁
try {
count++;
} finally {
lock.unlock(); // 必须在 finally 中释放锁！
}
}
public int getCount() {
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
}
核心要点：
lock() 和 unlock() 必须成对出现finally 块中，确保无论是否发生异常都能释放锁try 块中调用 lock()，因为 lock() 本身可能抛出异常可重入性是 ReentrantLock 命名中的核心特性。它通过计数机制实现：
public class ReentrantDemo {
private final ReentrantLock lock = new ReentrantLock();
public void outer() {
lock.lock();
try {
System.out.println("外层方法获取锁");
inner();
} finally {
lock.unlock();
}
}
public void inner() {
lock.lock(); // 同一线程再次获取锁
try {
System.out.println("内层方法再次获取锁");
} finally {
lock.unlock();
}
}
}
内部原理：每个锁关联一个持有线程和一个计数器。当线程第一次获取锁时，计数器置为 1；同一个线程再次获取锁时，计数器递增；每释放一次，计数器递减；当计数器归零时，锁完全释放，其他线程才能获取。
ReentrantLock 默认使用非公平锁，但可以通过构造器参数设置为公平锁：
ReentrantLock fairLock = new ReentrantLock(true); // 公平锁
ReentrantLock unfairLock = new ReentrantLock(false); // 非公平锁
ReentrantLock defaultLock = new ReentrantLock(); // 默认非公平锁
非公平锁虽然可能导致线程饥饿，但性能更高。原因在于：
我们来看看非公平锁的 lock() 方法：
// NonfairSync 的 lock 方法
final void lock() {
// 直接尝试抢占锁（插队）
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
} else {
acquire(1);
}
}
而公平锁的 lock() 方法：
// FairSync 的 lock 方法
final void lock() {
acquire(1); // 直接进入队列，没有抢占机会
}
公平锁的 tryAcquire 方法中多了一个关键判断：
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 公平锁的额外判断：队列中是否有前驱节点
if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// ... 重入逻辑
return false;
}
hasQueuedPredecessors() 检查队列中是否有等待时间更长的线程，确保严格 FIFO。
synchronized 在等待锁的过程中无法响应中断，而 ReentrantLock 提供了可中断的获取锁方式：
public class InterruptibleDemo {
private final ReentrantLock lock = new ReentrantLock();
public void performTask() throws InterruptedException {
// 可响应中断的锁获取
lock.lockInterruptibly();
try {
// 执行需要同步的操作
System.out.println(Thread.currentThread().getName() + " 获得锁");
Thread.sleep(5000);
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws Exception {
InterruptibleDemo demo = new InterruptibleDemo();
Thread t1 = new Thread(() -> {
try {
demo.performTask();
} catch (InterruptedException e) {
System.out.println("线程 1 被中断");
}
});
Thread t2 = new Thread(() -> {
try {
demo.performTask();
} catch (InterruptedException e) {
System.out.println();
}
});
t1.start();
Thread.sleep();
t2.start();
t2.interrupt();
}
}
当 t2 在等待锁时被中断，会立即抛出 InterruptedException，从而有机会响应中断，而不是无限阻塞。
在实际开发中，无限等待锁可能导致系统死锁或响应延迟。ReentrantLock 提供了带超时的锁获取方法：
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class TimeoutDemo {
private final ReentrantLock lock = new ReentrantLock();
public boolean tryExecute() {
try {
// 尝试在 3 秒内获取锁
if (lock.tryLock(3, TimeUnit.SECONDS)) {
try {
System.out.println(Thread.currentThread().getName() + " 获得锁");
Thread.sleep(2000); // 模拟业务操作
return true;
} finally {
lock.unlock();
}
} else {
System.out.println(Thread.currentThread().getName() + " 获取锁超时");
return false;
}
} catch (InterruptedException e) {
System.out.println("线程被中断");
return false;
}
}
}
tryLock() 还有无参版本：如果锁可用则立即获取，否则立即返回 false，不会阻塞。
Condition 将 Object 的 wait()、notify()、notifyAll() 方法分解为不同的条件对象，使得一个锁可以支持多个等待集，实现更精细的线程协作。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class BoundedBuffer {
private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
private final Object[] items = new Object[10];
private int putIndex, takeIndex, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
// 当队列满时，等待 notFull 条件
while (count == items.length) {
notFull.await(); // 释放锁，进入等待
}
items[putIndex] = x;
if (++putIndex == items.length) putIndex = 0;
count++;
// 通知等待 notEmpty 条件的线程
notEmpty.signal();
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
(count == ) {
notEmpty.await();
}
items[takeIndex];
(++takeIndex == items.length) takeIndex = ;
count--;
notFull.signal();
x;
} {
lock.unlock();
}
}
}
优势：与 synchronized 相比，Condition 可以创建多个等待集，更灵活地控制线程协作。
| 比较维度 | synchronized | ReentrantLock |
|---|---|---|
| 实现方式 | JVM 内置关键字 | Java API 实现，基于 AQS |
| 锁释放 | 自动释放（退出同步块） | 手动释放（需 finally 中 unlock） |
| 可重入性 | 支持 | 支持 |
| 公平性 | 非公平 | 可公平可非公平 |
| 响应中断 | 不支持 | 支持（lockInterruptibly） |
| 超时获取 | 不支持 | 支持（tryLock 带超时） |
| 尝试获取 | 不支持 | 支持（tryLock 无参） |
| 条件变量 | 每个对象一个等待集 | 一个锁可多个 Condition |
| 锁状态查询 | 无法查询 | 可查询持有线程、等待队列长度等 |
| 性能 | JDK6 后优化良好 | 高竞争场景表现更优 |
根据实际场景选择：
ReentrantLock 在高并发下表现更好。要理解 ReentrantLock，必须先理解AQS（AbstractQueuedSynchronizer）。AQS 是 Java 并发包的基石，ReentrantLock、Semaphore、CountDownLatch 等工具都基于它实现。
AQS 维护了两个核心元素：
ReentrantLock，state 表示锁的持有次数（0 表示未持有，≥1 表示持有次数）。核心操作：通过 CAS（Compare And Swap）原子性地修改 state 值，成功则获得锁，失败则进入等待队列。
| 方法 | 描述 |
|---|---|
tryAcquire(int arg) | 尝试获取锁，由子类实现 |
tryRelease(int arg) | 尝试释放锁，由子类实现 |
acquire(int arg) | 获取锁的模板方法 |
release(int arg) | 释放锁的模板方法 |
ReentrantLock 内部类 Sync 继承 AQS，并实现了 tryAcquire 和 tryRelease。
// ReentrantLock.NonfairSync
final void lock() {
// 第一步：直接尝试抢占锁（插队）
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
} else {
acquire(1); // 抢占失败，进入 AQS 流程
}
}
compareAndSetState(0, 1)：通过 CAS 尝试将 state 从 0 改为 1。如果成功，表示当前线程直接抢到了锁，设置独占线程为当前线程。acquire(1) 进入 AQS 的获取流程。// AbstractQueuedSynchronizer.acquire
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
这里的 tryAcquire 调用的是 NonfairSync 实现的 nonfairTryAcquire：
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// state 为 0，说明锁空闲，再次尝试 CAS 抢占
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
} else if (current == getExclusiveOwnerThread()) {
// 重入：同一线程再次获取锁
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
非公平的体现：即使线程已经进入等待队列，在 tryAcquire 阶段仍然会尝试 CAS 抢占，而不是严格排队。
如果 tryAcquire 失败，则执行 addWaiter 将当前线程封装成 Node 加入等待队列尾部：
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node); // 入队失败或有并发时，通过自旋 CAS 入队
return node;
}
然后执行 acquireQueued，在队列中自旋等待：
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
// 如果前驱是头节点，再次尝试获取锁
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 检查是否需要挂起线程
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
当线程获取锁失败时，会被 park（挂起），等待前驱线程释放锁时 unpark 唤醒。
// ReentrantLock.Sync
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;
}
释放锁时递减 state，直到 state 归零才真正释放锁。然后 AQS 会唤醒队列中的下一个节点。
公平锁的 lock() 方法直接调用 acquire(1)，没有抢占尝试：
// FairSync.lock
final void lock() {
acquire(1);
}
公平锁的 tryAcquire 与非公平锁的核心区别在于多了 hasQueuedPredecessors() 判断：
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 公平锁：检查队列中是否有前驱节点
if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// ... 重入逻辑
return false;
}
hasQueuedPredecessors() 判断当前线程之前是否有等待的线程，确保 FIFO 顺序。
tryLock(long timeout, TimeUnit unit) 的底层通过 doAcquireNanos 实现：
private boolean doAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {
long lastTime = System.nanoTime();
final Node node = addWaiter(Node.EXCLUSIVE);
// ...
for (;;) {
// 尝试获取锁
// 计算剩余时间，超时则返回 false
nanosTimeout -= System.nanoTime() - lastTime;
if (nanosTimeout <= 0) {
cancelAcquire(node);
return false;
}
// 如果超时时间短，自旋；否则挂起
if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
// ...
}
}
通过 LockSupport.parkNanos 实现限时阻塞，超时后自动唤醒并返回失败。
CAS（Compare And Swap）是并发编程中实现无锁算法的核心技术。它是一条 CPU 原子指令，包含三个操作数：
仅当 V 的值等于 A 时，才将 V 更新为 B，整个过程原子完成。
在 Java 中，Unsafe 类提供了 CAS 操作，ReentrantLock 通过 CAS 修改 AQS 的 state 字段。
ABA 问题：线程 1 读取变量值为 A，此时线程 2 将 A 改为 B 再改回 A，线程 1 CAS 时发现仍是 A，于是更新成功。但实际上变量已经被修改过。
解决方案：使用版本号或时间戳。Java 提供了 AtomicStampedReference 来解决 ABA 问题。
AQS 的核心设计理念包括：
state 表示同步状态。public class SafeCounter {
private final ReentrantLock lock = new ReentrantLock();
private int count = 0;
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
// 带超时的获取
public boolean tryIncrement(long timeout, TimeUnit unit) {
try {
if (lock.tryLock(timeout, unit)) {
try {
count++;
return true;
} finally {
lock.unlock();
}
}
return false;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return false;
}
}
}
ReentrantLock 提供了监控锁状态的方法：
ReentrantLock lock = new ReentrantLock();
// 查询锁状态
System.out.println("锁持有线程：" + lock.getOwner());
System.out.println("等待线程数：" + lock.getQueueLength());
System.out.println("是否被当前线程持有：" + lock.isHeldByCurrentThread());
System.out.println("是否公平锁：" + lock.isFair());
这些方法对调试死锁、监控系统状态非常有帮助。
ReentrantLock 作为 Java 并发包中的核心工具，以其强大的功能和灵活的机制，成为高并发编程中不可或缺的利器。通过本文的学习，我们深入理解了：
掌握 ReentrantLock 不仅仅是学会使用一个类，更是理解 Java 并发编程思想的重要一步。在实际开发中，根据场景选择合适的同步工具，平衡功能与性能，才能写出高质量的多线程程序。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online