ReentrantLock实现原理深度解析

一、核心架构设计

1.1 基于AQS的同步框架

ReentrantLock底层通过AbstractQueuedSynchronizer (AQS) 实现同步控制，其核心结构包含：

• 同步状态（state）：记录锁重入次数（0表示未锁定）
• 双向链表队列（CLH队列）：管理等待线程
• 独占模式：同一时刻仅允许一个线程持有锁

// AQS核心状态定义
private volatile int state;
transient volatile Node head;  // 队列头节点
transient volatile Node tail;  // 队列尾节点

1.2 锁类型实现

通过继承AQS实现两种锁策略：

static final class FairSync extends Sync { /* 公平锁实现 */ }
static final class NonfairSync extends Sync { /* 非公平锁实现 */ }

二、锁获取与释放流程

2.1 非公平锁获取流程

graph TD
    A[调用lock()] --> B{CAS尝试获取}
    B -->|成功| C[设置独占线程]
    B -->|失败| D[加入等待队列]
    D --> E[自旋等待]
    E -->|队列头节点| F[尝试获取锁]

关键代码（NonfairSync）：

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {  // 直接CAS抢锁
            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;
}

2.2 公平锁获取流程

graph TD
    A[调用lock()] --> B{检查等待队列}
    B -->|队列为空| C[尝试CAS获取]
    B -->|队列非空| D[加入队列尾部]
    C -->|成功| E[设置独占线程]
    D --> F[阻塞等待]

关键代码（FairSync）：

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

三、核心机制详解

3.1 可重入性实现

• 计数器机制：每次获取锁state+1，释放时-1
• 线程绑定：通过exclusiveOwnerThread记录持有线程
• 重入限制：无硬性限制（受内存限制）

3.2 条件变量（Condition）

通过独立Condition对象实现精准线程控制：

Condition notEmpty = lock.newCondition();

// 生产者线程
lock.lock();
try {
    while (queue.isEmpty()) {
        notEmpty.await();  // 释放锁并等待
    }
    queue.add(item);
    notEmpty.signal();   // 唤醒特定条件线程
} finally {
    lock.unlock();
}

3.3 锁竞争优化

• 自旋等待：未获取锁时短暂自旋（默认10次）
• 队列管理：使用CAS操作维护FIFO队列
• 线程中断：支持响应中断（lockInterruptibly()）

四、性能对比分析

4.1 基准测试数据

4.2 性能影响因素

• 上下文切换：公平锁队列管理增加调度开销
• CAS竞争：非公平锁允许插队减少CAS冲突
• 内存屏障：公平锁需要额外内存屏障保证顺序

五、源码关键点

5.1 锁升级机制

// AQS的acquire方法
public final void acquire(int arg) {
    if (!tryAcquire(arg) && 
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

5.2 队列操作

• 入队：通过CAS将节点添加到队列尾部
• 出队：头节点线程唤醒后尝试获取锁
• 自旋等待：队列尾节点优先尝试获取锁

六、应用场景建议

6.1 推荐使用场景

1. 高并发读写：配合读写锁（ReentrantReadWriteLock）
2. 资源池管理：数据库连接池/线程池
3. 任务调度：需要严格顺序执行的任务
4. 超时控制：结合tryLock实现限时获取

6.2 避免使用场景

• 简单方法同步：优先使用synchronized
• 低并发环境：锁开销可能超过收益
• 无序场景：无需公平性保障时

七、演进与优化

7.1 JDK版本改进

• JDK1.6：引入AQS框架
• JDK1.7：优化队列节点结构
• JDK1.8：支持CompletableFuture集成
• JDK19+：虚拟线程兼容性优化

7.2 最佳实践

// 推荐锁使用模式
ReentrantLock lock = new ReentrantLock(true);  // 公平锁
lock.lock();
try {
    // 临界区操作
} finally {
    lock.unlock();  // 确保释放
}

// 尝试获取锁（带超时）
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // 限时获取成功
    } finally {
        lock.unlock();
    }
}