Java并发编程：ReentrantLock与AQS源码解析

1. ReentrantLock与AQS源码深度解析

作为Java并发编程的核心组件，ReentrantLock和AbstractQueuedSynchronizer（AQS）构成了JDK锁机制的基石。我第一次阅读这部分源码时，花了整整三天时间才理清其设计脉络。本文将带你用工程师的视角，逐层拆解这两个关键类的实现细节。

提示：阅读本文需要基本的多线程知识，了解synchronized关键字的使用。建议边看边用IDEA打开JDK源码对照阅读。

1.1 为什么需要ReentrantLock

在早期Java版本中，synchronized是唯一的同步机制。但在实际开发中我们发现几个痛点：

• 无法中断等待锁的线程
• 必须按获取顺序释放锁
• 没有超时获取锁的机制
• 单一条件变量不够灵活

ReentrantLock的出现正是为了解决这些问题。它通过AQS实现了：

• 可中断的锁获取（lockInterruptibly）
• 公平/非公平两种模式
• 尝试获取锁（tryLock）
• 多条件变量支持

java复制// 典型使用示例
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();

lock.lock();
try {
    while(!conditionMet) {
        condition.await();
    }
    // 业务逻辑
} finally {
    lock.unlock();
}

1.2 AQS的设计哲学

AQS采用模板方法模式，将同步器的实现分为两部分：

1. 原子状态管理（volatile int state）
2. 线程排队与唤醒机制（CLH队列变体）

其核心思想是：

• 通过CAS操作原子更新state
• 获取失败时进入FIFO队列等待
• 释放时唤醒后继节点

这种设计使得基于AQS可以实现：

• 独占锁（ReentrantLock）
• 共享锁（Semaphore/CountDownLatch）
• 混合模式（ReentrantReadWriteLock）

2. ReentrantLock源码实现

2.1 锁的公平性与非公平性

ReentrantLock内部有两个同步器实现：

• NonfairSync（默认）
• FairSync

关键区别在于tryAcquire的实现：

java复制// 非公平锁尝试获取
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {  // 直接抢锁
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 重入逻辑...
}

// 公平锁尝试获取
protected final boolean tryAcquire(int acquires) {
    if (getState() == 0 && !hasQueuedPredecessors()) {  // 检查队列
        // 获取逻辑...
    }
    // 重入逻辑...
}

实测数据：在激烈竞争场景下，非公平锁的吞吐量比公平锁高5-10倍，但可能导致线程饥饿。

2.2 锁的可重入实现

重入机制通过记录当前持有线程和重入次数实现：

java复制protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 首次获取逻辑...
    }
    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;
}

解锁时需要匹配获取次数：

java复制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;
}

3. AQS核心机制解析

3.1 CLH队列变体

AQS使用改进的CLH队列管理等待线程：

• 每个节点保存前驱节点的引用
• 通过前驱节点的状态决定是否阻塞
• 自旋+CAS实现无锁入队

节点定义关键字段：

java复制static final class Node {
    volatile int waitStatus;
    volatile Node prev;
    volatile Node next;
    volatile Thread thread;
    Node nextWaiter;  // 条件队列专用
}

waitStatus包含以下状态：

• CANCELLED(1)：线程已取消
• SIGNAL(-1)：后继节点需要唤醒
• CONDITION(-2)：在条件队列等待
• PROPAGATE(-3)：共享模式下传播唤醒

3.2 独占模式获取流程

java复制public final void acquire(int arg) {
    if (!tryAcquire(arg) &&  // 子类实现
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  // 入队并等待
        selfInterrupt();
}

关键步骤解析：

1. addWaiter：用CAS快速入队
2. acquireQueued：在队列中自旋检查
3. shouldParkAfterFailedAcquire：清理取消的节点并设置SIGNAL
4. parkAndCheckInterrupt：最终挂起线程

3.3 条件变量实现

ConditionObject是AQS的内部类，其实现要点：

• 每个条件有自己的等待队列
• await()会释放锁并进入条件队列
• signal()将节点转移到同步队列

java复制public final void await() throws InterruptedException {
    Node node = addConditionWaiter();  // 加入条件队列
    int savedState = fullyRelease(node);  // 完全释放锁
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);  // 挂起
        // 被唤醒后检查中断
    }
    acquireQueued(node, savedState);  // 重新竞争锁
}

4. 实战问题与调优经验

4.1 锁泄漏检测

常见错误场景：

java复制lock.lock();
try {
    if(condition) {
        return;  // 忘记解锁！
    }
    // 正常逻辑
} finally {
    lock.unlock();
}

解决方案：

1. 使用代码检查工具（如Sonar）
2. 实现锁持有监控：

java复制class MonitoringReentrantLock extends ReentrantLock {
    @Override
    public void lock() {
        super.lock();
        monitorLockAcquire();
    }
    
    private void monitorLockAcquire() {
        if(监控阈值) {
            Thread.dumpStack();
        }
    }
}

4.2 性能优化技巧

1. 减少锁粒度：对不同的数据使用不同的锁
2. 锁分段：如ConcurrentHashMap的实现
3. 乐观读取：在读多写少场景使用StampedLock
4. 避免嵌套锁：容易导致死锁

4.3 死锁排查方法

1. jstack检测：

bash复制jstack <pid> | grep -A 1 "BLOCKED"

2. 预防性编码：

java复制// 尝试获取所有需要的锁
while(true) {
    if(lock1.tryLock()) {
        try {
            if(lock2.tryLock(100, TimeUnit.MILLISECONDS)) {
                try {
                    // 执行业务
                    break;
                } finally {
                    lock2.unlock();
                }
            }
        } finally {
            lock1.unlock();
        }
    }
    Thread.sleep(100);  // 避免活锁
}

5. AQS的衍生实现

5.1 CountDownLatch

核心实现：

java复制protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

protected boolean tryReleaseShared(int releases) {
    // 自旋CAS减1
    for (;;) {
        int c = getState();
        if (c == 0)
            return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

5.2 Semaphore

许可控制实现：

java复制protected int tryAcquireShared(int acquires) {
    for (;;) {
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}

5.3 ReentrantReadWriteLock

读写锁分离：

• 高16位表示读锁
• 低16位表示写锁
• 写锁可降级为读锁

java复制static final int SHARED_SHIFT   = 16;
static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

6. 现代并发工具对比

6.1 性能基准测试

测试场景：100线程并发执行100万次

6.2 选型建议

1. 简单同步：优先用synchronized
2. 需要高级功能：选择ReentrantLock
3. 读多写少：考虑StampedLock
4. 需要组合操作：使用Phaser

在JDK15+中，虚拟线程（Virtual Thread）的出现改变了锁的使用范式。当遇到线程阻塞时，虚拟线程可以更高效地挂起，使得简单的synchronized在多数场景下重新成为优选方案。