在 Java 并发编程中，`ReentrantLock` 是一个非常重要的可重入互斥锁，它提供了比内置锁（synchronized）更强大的功能，如尝试获取锁、超时获取锁、支持中断等。本文将从源码角度深入分析 `ReentrantLock` 的底层实现机制，重点探讨其基于 AQS（
AbstractQueuedSynchronizer） 的工作原理。

一、ReentrantLock 的基本特性

`ReentrantLock` 是 `
java.util.concurrent.locks` 包下的类，具有以下主要特性：

● 可重入性：同一个线程可以多次获取同一把锁。

● 公平/非公平策略：支持构造参数选择是否为公平锁，默认是非公平的。

● 支持中断响应：在等待锁的过程中可以响应线程中断。

● 支持超时获取：可以在指定时间内尝试获取锁。

二、核心结构：Sync 抽象类继承 AQS

`ReentrantLock` 内部通过静态抽象类 `Sync` 继承 `
AbstractQueuedSynchronizer`（AQS），作为同步控制的基础：

abstract static class Sync extends AbstractQueuedSynchronizer {
    ...
}

子类 `NonfairSync` 和 `FairSync` 分别实现了非公平和公平的锁获取逻辑。

三、AQS 简要回顾

AQS 是构建锁和同步器的基础框架，其核心在于：

● 使用 `state` 表示同步状态；

● 提供 FIFO 同步队列管理阻塞线程；

● 支持独占模式和共享模式；

● 提供模板方法如 `tryAcquire`、`tryRelease` 供子类实现具体逻辑。

四、非公平锁的 tryAcquire 实现

以非公平锁为例，其 `tryAcquire` 方法简化如下：

protected final boolean tryAcquire(int acquires) {
    if (getState() == 0) {
        if (compareAndSetState(0, 1)) { // CAS 尝试获取锁
            setExclusiveOwnerThread(Thread.currentThread()); // 设置当前线程为持有者
            return true;
        }
    } else if (currentThread() == getExclusiveOwnerThread()) {
        int nextc = getState() + 1; // 重入计数增加
        setState(nextc);
        return true;
    }
    return false;
}

该方法逻辑清晰：

● 如果锁未被占用（`state == 0`），使用 CAS 获取锁并设置持有线程；

● 如果当前线程已持有锁，则增加重入计数；

● 否则返回 `false`，表示获取失败，需进入等待队列。

五、线程入队与等待机制

当 `tryAcquire` 返回 `false` 时，线程需要加入同步队列等待唤醒：

1. addWaiter(Node mode)

该方法负责创建节点并将其插入同步队列尾部：

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); // 队列为空时初始化
    return node;
}

2. acquireQueued(final Node node, int arg)

该方法让线程在队列中自旋等待获取锁，并处理中断：

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

其中：

● `
shouldParkAfterFailedAcquire(p, node)` 判断是否应阻塞当前线程；

● `parkAndCheckInterrupt()` 调用 `LockSupport.park()` 挂起线程，并返回是否被中断。

六、公平锁与非公平锁的区别

公平锁在 `tryAcquire` 中会额外判断是否有前驱节点：

if (!hasQueuedPredecessors() && compareAndSetState(0, 1)) {
    ...
}

即只有当前线程是队列头节点后继时才允许获取锁，确保先进先出。

而非公平锁跳过此判断，直接尝试 CAS 获取锁，可能造成“插队”。

七、释放锁与传播唤醒机制

当线程调用 `unlock()` 时，最终调用 AQS 的 `release(int arg)` 方法：

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

其中 `tryRelease` 由 `Sync` 子类实现，用于减少重入计数或释放锁；若完全释放，则唤醒后继节点。

八、总结

`ReentrantLock` 基于 AQS 构建了一个灵活且高效的同步机制，其关键点包括：

通过对 AQS 的合理利用，`RentrantLock` 不仅提供了 synchronized 所不具备的功能，还保持了良好的性能和扩展性，是现代并发编程中的重要工具。

> 参考资料：

> - 《Java并发编程实战》

> - JDK 源码（`
java.util.concurrent.locks.ReentrantLock`）

> - Doug Lea 的论文《AQS》