面试八股之从Java到JVM层面深入解析ReentrantLock实现原理

一、ReentrantLock概述

ReentrantLock是Java并发包(java.util.concurrent.locks)中的一个重要组件，它是一个可重入的互斥锁，具有与synchronized关键字类似的功能，但提供了更灵活的锁操作。

基本特性

• 可重入性：同一个线程可以多次获取同一把锁
• 可中断：支持获取锁的过程中响应中断
• 公平性选择：支持公平锁和非公平锁两种模式
• 条件变量：支持多个条件队列

基本用法示例

ReentrantLock lock = new ReentrantLock();public void criticalSection() {lock.lock();  // 获取锁try {// 临界区代码} finally {lock.unlock();  // 释放锁}
}

二、ReentrantLock的JVM层面实现

1. 核心类结构

ReentrantLock的实现主要依赖于以下几个核心类：

• AbstractQueuedSynchronizer (AQS)：同步器框架基类
• NonfairSync：非公平锁实现
• FairSync：公平锁实现

public class ReentrantLock implements Lock, java.io.Serializable {private final Sync sync;abstract static class Sync extends AbstractQueuedSynchronizer {// 实现AQS的核心方法}static final class NonfairSync extends Sync {// 非公平锁实现}static final class FairSync extends Sync {// 公平锁实现}
}

2. AQS核心机制

AQS是ReentrantLock实现的核心，它维护了一个volatile int state变量和一个FIFO线程等待队列。

state变量含义

• 0：锁未被任何线程持有

0：锁被某个线程持有，数值表示重入次数

等待队列

• CLH队列的变种，用于实现线程的排队等待
• 每个节点代表一个等待线程

3. 加锁过程分析

非公平锁实现

final void lock() {if (compareAndSetState(0, 1))  // 直接尝试CAS获取锁setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);  // 获取失败则进入AQS排队流程
}protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);
}final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {if (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {  // 重入检查int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;
}

公平锁实现

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;}}else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;
}

4. 解锁过程分析

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;
}

三、JVM层面的关键实现细节

1. CAS操作

ReentrantLock大量使用了CAS(Compare-And-Swap)操作，这是通过Unsafe类实现的：

protected final boolean compareAndSetState(int expect, int update) {return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

在JVM层面，CAS操作会被编译为特定平台的原子指令，如x86的cmpxchg指令。

2. 内存可见性

AQS中的state变量使用volatile修饰，保证了内存可见性：

private volatile int state;

在JVM层面：

• 写volatile变量会插入StoreStore和StoreLoad内存屏障
• 读volatile变量会插入LoadLoad和LoadStore内存屏障

3. 线程阻塞与唤醒

当线程获取锁失败时，会被park(阻塞)：

LockSupport.park(this);

在JVM层面，这最终会调用到操作系统的线程调度机制：

• Linux下使用pthread_cond_wait
• Windows下使用WaitForSingleObject

当锁释放时，会unpark(唤醒)等待线程：

LockSupport.unpark(node.thread);

四、性能优化分析

1. 非公平锁的性能优势

非公平锁之所以性能更好，是因为：

1. 减少了线程切换的开销
2. 利用了线程的局部性原理
3. 避免了频繁的上下文切换

2. 自旋优化

在进入park前，AQS会进行有限次数的自旋尝试，减少线程挂起的开销。

五、与synchronized的对比

六、最佳实践

1. 总是使用try-finally释放锁：

lock.lock();
try {// 临界区代码
} finally {lock.unlock();
}

1. 合理选择公平策略：默认使用非公平锁，除非有特殊需求
2. 避免锁泄漏：确保锁在finally块中释放
3. 考虑使用tryLock：避免死锁

if (lock.tryLock(1, TimeUnit.SECONDS)) {try {// 获取锁成功} finally {lock.unlock();}
} else {// 获取锁超时处理
}

七、总结

ReentrantLock是Java并发编程中的重要工具，它通过AQS框架实现了高效的可重入锁机制。从JVM层面看，它充分利用了CAS操作、volatile变量和线程调度机制，在保证线程安全的同时提供了良好的性能。