AQS框架 ⭐⭐⭐

// AQS 继承自 AbstractOwnableSynchronizer,
// 后者仅提供了 exclusiveOwnerThread 字段（记录当前独占锁的持有线程）
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
 
    // ==================== 核心字段 ====================
 
    // 同步状态变量, volatile 保证可见性
    private volatile int state;
 
    // CLH 队列的头节点（虚拟节点, 即哨兵节点）
    private transient volatile Node head;
 
    // CLH 队列的尾节点
    private transient volatile Node tail;
 
    // ==================== state 操作方法 ====================
 
    // 获取当前 state 值
    protected final int getState() { return state; }
 
    // 直接设置 state 值（仅在持有锁时使用, 因为不保证原子性）
    protected final void setState(int newState) { state = newState; }
 
    // CAS 原子更新 state（竞争场景下使用）
    protected final boolean compareAndSetState(int expect, int update) {
        // 底层调用 Unsafe.compareAndSwapInt
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }
 
    // ==================== 模板方法（子类必须覆写） ====================
 
    // 独占模式: 尝试获取资源（由子类定义"获取"的语义）
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException(); // 默认抛异常, 强制子类覆写
    }
 
    // 独占模式: 尝试释放资源
    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }
 
    // 共享模式: 尝试获取资源, 返回值 >= 0 表示成功
    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }
 
    // 共享模式: 尝试释放资源
    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }
 
    // 判断当前线程是否独占持有同步器
    protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }
 
    // ==================== 框架固定流程（不可覆写） ====================
 
    // 独占模式获取（对外公开的 API）
    public final void acquire(int arg) { /* ... */ }
 
    // 独占模式释放
    public final boolean release(int arg) { /* ... */ }
 
    // 共享模式获取
    public final void acquireShared(int arg) { /* ... */ }
 
    // 共享模式释放
    public final boolean releaseShared(int arg) { /* ... */ }
 
    // ... 还有支持超时、可中断的变体方法
}

// AQS 中的核心状态字段
// volatile 保证多线程之间的可见性
private volatile int state;

// ==================== state 的三大操作方法 ====================
 
// 1. 普通读取：直接读取 volatile 变量，保证读到最新值
//    由于 state 是 volatile 的，JMM 保证了 happens-before 语义
protected final int getState() {
    return state;  // volatile read，对所有线程可见
}
 
// 2. 普通写入：直接写入 volatile 变量
//    适用于已经持有锁、不存在竞争的场景（如重入时递增 state）
protected final void setState(int newState) {
    state = newState;  // volatile write，对后续 volatile read 可见
}
 
// 3. CAS 写入：原子性地 [比较并交换]
//    这是并发竞争场景下修改 state 的唯一安全方式
//    底层调用 Unsafe.compareAndSwapInt，是一条 CPU 级原子指令
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

// 典型的 CAS 自旋模式（以 ReentrantLock 非公平锁为例）
// 这段伪代码展示了 state 在获取锁时的使用方式
final void lock() {
    // 第一次尝试：直接 CAS 将 state 从 0 改为 1
    // 如果成功，说明锁空闲，当前线程直接获取
    if (compareAndSetState(0, 1)) {
        // 记录当前持有锁的线程（用于可重入判断）
        setExclusiveOwnerThread(Thread.currentThread());
    } else {
        // CAS 失败，说明有竞争，进入 AQS 的完整 acquire 流程
        // 内部会再次尝试获取，失败则入队等待
        acquire(1);
    }
}

// ==================== ReentrantReadWriteLock 的 state 位分割 ====================
 
// state 是一个 32 位的 int
// 高 16 位：读锁的持有线程数（shared count）
// 低 16 位：写锁的重入次数（exclusive count）
 
static final int SHARED_SHIFT   = 16;                    // 位移量
static final int SHARED_UNIT    = (1 << SHARED_SHIFT);   // 65536，读锁的计数单位
static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1; // 65535，最大计数
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1; // 0x0000FFFF，低16位掩码
 
// 提取读锁持有数：state 无符号右移 16 位
static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
// 提取写锁重入数：state 与低 16 位掩码做 AND
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

// ==================== AQS.Node 核心字段（简化版） ====================
static final class Node {
    
    // -------- 模式标记 --------
    static final Node SHARED = new Node();   // 共享模式标记（哨兵对象）
    static final Node EXCLUSIVE = null;      // 独占模式标记（null）
 
    // -------- waitStatus 常量 --------
    static final int CANCELLED  =  1;   // 线程已取消，是唯一 > 0 的状态
    static final int SIGNAL     = -1;   // 后继节点需要被唤醒
    static final int CONDITION  = -2;   // 节点在 Condition 等待队列中
    static final int PROPAGATE  = -3;   // 共享模式下的传播唤醒
 
    // -------- 实例字段 --------
    volatile int waitStatus;     // 当前节点的等待状态
    volatile Node prev;          // 前驱节点引用
    volatile Node next;          // 后继节点引用
    volatile Thread thread;      // 该节点关联的线程
    Node nextWaiter;             // Condition 队列中的下一个等待者，或模式标记
}

// 出队操作：无竞争，直接赋值
// 只有获取锁成功的线程才会调用此方法
private void setHead(Node node) {
    head = node;           // 直接赋值，不需要 CAS
    node.thread = null;    // 清除线程引用（变成哨兵节点）
    node.prev = null;      // 断开与旧 head 的链接，帮助 GC
}

// ==================== 独占模式的核心流程（伪代码视角） ====================
 
// 获取资源
public final void acquire(int arg) {
    // 第一步：tryAcquire 由子类实现，尝试直接获取资源
    // 第二步：失败则 addWaiter 创建独占节点入队
    // 第三步：acquireQueued 在队列中自旋/阻塞等待
    if (!tryAcquire(arg) &&                          // 尝试获取
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 入队 + 排队获取
        selfInterrupt();  // 如果在等待期间被中断过，补上中断标记
}
 
// 释放资源
public final boolean release(int arg) {
    if (tryRelease(arg)) {           // 子类实现，尝试释放
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);      // 唤醒队列中的下一个线程
        return true;
    }
    return false;
}

// ==================== 共享模式的核心流程（伪代码视角） ====================
 
// 获取共享资源
public final void acquireShared(int arg) {
    // tryAcquireShared 返回值：
    //   < 0  → 获取失败
    //   == 0 → 获取成功，但没有剩余资源
    //   > 0  → 获取成功，且还有剩余资源（可以继续唤醒后续线程）
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);  // 入队 + 排队获取（共享版本）
}
 
// 释放共享资源
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();     // 唤醒后继 + 传播唤醒
        return true;
    }
    return false;
}

// AQS 的静态内部类 Node —— 同步队列的基本节点
static final class Node {
 
    // ==================== 模式常量 ====================
    
    // 标记：表示该节点在共享模式下等待
    static final Node SHARED = new Node();
    
    // 标记：表示该节点在独占模式下等待（值为 null）
    static final Node EXCLUSIVE = null;
 
    // ==================== waitStatus 状态常量 ====================
    
    // 表示线程已取消（因超时或中断），该节点不会再参与竞争
    static final int CANCELLED  =  1;
    
    // 表示后继节点的线程需要被唤醒（unpark）
    static final int SIGNAL     = -1;
    
    // 表示节点在 Condition 条件队列中等待
    static final int CONDITION  = -2;
    
    // 表示下一次 acquireShared 应该无条件传播
    static final int PROPAGATE  = -3;
 
    // ==================== 核心字段 ====================
 
    // 当前节点的等待状态，取值为上述常量之一，或初始值 0
    volatile int waitStatus;
 
    // 指向前驱节点 —— 用于检查前驱的 waitStatus
    volatile Node prev;
 
    // 指向后继节点 —— 用于在释放时唤醒后继线程
    volatile Node next;
 
    // 封装在该节点中的线程引用
    volatile Thread thread;
 
    // 指向条件队列中的下一个等待节点，或者用 SHARED/EXCLUSIVE 标记模式
    Node nextWaiter;
 
    // 判断当前节点是否为共享模式
    final boolean isShared() {
        return nextWaiter == SHARED; // nextWaiter 指向 SHARED 常量即为共享模式
    }
 
    // 返回前驱节点，如果为 null 则抛出 NPE
    final Node predecessor() throws NullPointerException {
        Node p = prev;            // 读取 prev 引用
        if (p == null)            // 前驱不存在则抛异常（不应出现此情况）
            throw new NullPointerException();
        else
            return p;             // 返回前驱节点
    }
 
    // 三个构造方法
    Node() {}                     // 用于创建 head 哨兵节点或 SHARED 标记
 
    Node(Thread thread, Node mode) {  // addWaiter 使用
        this.nextWaiter = mode;       // 设置模式（SHARED 或 EXCLUSIVE）
        this.thread = thread;         // 绑定当前线程
    }
 
    Node(Thread thread, int waitStatus) { // Condition 队列使用
        this.waitStatus = waitStatus;     // 直接设置 waitStatus
        this.thread = thread;             // 绑定当前线程
    }
}

/*
 *   ┌─────────────────────────────────────┐
 *   │           Node 对象                  │
 *   ├─────────────────────────────────────┤
 *   │  waitStatus : volatile int          │  ← 节点状态 (0, SIGNAL, CANCELLED...)
 *   │  prev       : volatile Node         │  ← 指向前驱节点
 *   │  next       : volatile Node         │  ← 指向后继节点
 *   │  thread     : volatile Thread       │  ← 持有的线程引用
 *   │  nextWaiter : Node                  │  ← 条件队列后继 / 模式标记
 *   └─────────────────────────────────────┘
 *
 *   所有指针字段都声明为 volatile，保证多线程间的可见性
 */

/*
 * 协作信号机制示意：
 *
 *   [Node-A]              [Node-B]             [Node-C]
 *   ws = SIGNAL    ←--    ws = SIGNAL   ←--    ws = 0     (刚入队)
 *     ↑                      ↑                     ↑
 *   "释放时必须              "释放时必须           "暂时没有后继
 *    唤醒 B"                 唤醒 C"               要求唤醒我"
 *
 *   Node-C 入队后会检查前驱 Node-B 的 waitStatus：
 *   - 如果是 SIGNAL，直接 park 自己
 *   - 如果是 0，CAS 设为 SIGNAL，再循环一次后 park
 *   - 如果是 CANCELLED，跳过已取消节点，找到有效前驱
 */

/*
 *   取消节点被跳过的过程：
 *
 *   Before:
 *   [Head] <--> [A:CANCELLED] <--> [B:CANCELLED] <--> [C:0]
 *
 *   After (C 入队时调用 shouldParkAfterFailedAcquire):
 *   [Head] <--> [C:0]        (A、B 被跳过)
 *                              Head.waitStatus 被 CAS 设为 SIGNAL
 *
 *   被跳过的 A、B 节点失去引用后，等待 GC 回收
 */

// 负值 = 线程处于有效等待状态
if (ws < 0) { /* 节点有效 */ }
 
// 正值 = 线程已取消
if (ws > 0) { /* 节点已取消，跳过 */ }
 
// 等于0 = 刚入队或刚被唤醒的中间态
if (ws == 0) { /* 需要进一步设置 */ }

// 将当前线程以指定模式包装为 Node 并加入同步队列尾部
private Node addWaiter(Node mode) {
    // 1. 创建新节点，绑定当前线程和模式（EXCLUSIVE 或 SHARED）
    Node node = new Node(Thread.currentThread(), mode);
 
    // 2. 快速路径：尝试直接在尾部追加（不进入完整的 enq 循环）
    Node pred = tail;          // 读取当前尾节点
    if (pred != null) {        // 队列已初始化（tail 不为 null）
        node.prev = pred;      // 新节点的 prev 指向当前尾节点（先设 prev）
        if (compareAndSetTail(pred, node)) {  // CAS 尝试将 tail 从 pred 更新为 node
            pred.next = node;  // CAS 成功后，将旧尾节点的 next 指向新节点
            return node;       // 入队成功，直接返回
        }
    }
 
    // 3. 快速路径失败：队列未初始化 或 CAS 竞争失败，进入完整入队逻辑
    enq(node);
    return node;               // 返回已入队的节点
}

// 通过自旋 + CAS 保证节点一定能入队；同时负责队列的惰性初始化
private Node enq(final Node node) {
    for (;;) {                            // 无限循环（自旋），直到入队成功
        Node t = tail;                    // 读取当前尾节点
        if (t == null) {                  // 【情况1】队列尚未初始化
            // 创建一个空的哨兵节点作为 head（dummy node）
            if (compareAndSetHead(new Node())) // CAS 设置 head
                tail = head;              // tail 也指向 head，完成初始化
            // 注意：这里没有 return，继续下一轮循环去追加真正的节点
        } else {                          // 【情况2】队列已初始化
            node.prev = t;                // 新节点的 prev 指向当前尾节点
            if (compareAndSetTail(t, node)) { // CAS 尝试更新 tail 为新节点
                t.next = node;            // 成功后，旧尾节点的 next 指向新节点
                return t;                 // 返回旧尾节点（即新节点的前驱）
            }
            // CAS 失败说明有并发竞争，继续下一轮自旋重试
        }
    }
}

/*
 *   多线程并发入队过程（假设 T1, T2, T3 几乎同时竞争失败）：
 *
 *   时刻 t0: 队列为空
 *   =============================================
 *
 *   时刻 t1: T1 进入 enq，发现 tail==null
 *            → CAS 创建哨兵节点，head = tail = Dummy
 *
 *   时刻 t2: T1 第二轮自旋，成功 CAS tail
 *            [Dummy] <--> [T1]
 *             head          tail
 *
 *   时刻 t3: T2 进入 addWaiter 快速路径
 *            → node.prev = tail (即 T1)
 *            → CAS tail: T1 → T2  (成功!)
 *            → T1.next = T2
 *            [Dummy] <--> [T1] <--> [T2]
 *             head                    tail
 *
 *   时刻 t4: T3 也进入 addWaiter 快速路径
 *            → node.prev = tail (即 T2)
 *            → CAS tail: T2 → T3  (成功!)
 *            → T2.next = T3
 *            [Dummy] <--> [T1] <--> [T2] <--> [T3]
 *             head                              tail
 *
 *   若 T2 和 T3 同时 CAS，只有一个成功，失败者进入 enq 自旋重试
 */

// 将指定节点设置为新的 head（出队操作的核心）
private void setHead(Node node) {
    head = node;              // 将 head 指针指向该节点
    node.thread = null;       // 清空 thread 引用（head 不保留线程信息）
    node.prev = null;         // 清空 prev 引用（head 没有前驱）
}

// 已在同步队列中的线程以独占模式循环尝试获取同步状态
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;                // 标记是否获取失败（用于 finally 取消）
    try {
        boolean interrupted = false;      // 标记等待过程中是否被中断
        for (;;) {                        // 无限循环（自旋）
            final Node p = node.predecessor();  // 获取当前节点的前驱
            
            // 【关键判断】只有前驱是 head 时，才有资格尝试获取
            if (p == head && tryAcquire(arg)) {
                // 获取成功！执行出队操作
                setHead(node);            // 当前节点成为新的 head
                p.next = null;            // 断开旧 head 的 next 引用，帮助 GC
                failed = false;           // 标记获取成功
                return interrupted;       // 返回中断状态
            }
 
            // 获取失败：检查是否应该阻塞（park）
            if (shouldParkAfterFailedAcquire(p, node) &&  // 检查前驱状态
                parkAndCheckInterrupt())                    // 阻塞并检查中断
                interrupted = true;       // 记录曾被中断
        }
    } finally {
        if (failed)                       // 如果因异常退出循环
            cancelAcquire(node);          // 取消该节点
    }
}

/*
 *   出队的引用变化总结：
 *
 *   ┌─ head ──┐      ┌─ Node-A ─┐      ┌─ Node-B ─┐
 *   │ th=null │ next  │ th=T1    │ next  │ th=T2    │
 *   │ pr=null │──────>│ pr=head  │──────>│ pr=A     │
 *   │ ws=SIG  │<──────│ ws=SIG   │<──────│ ws=0     │
 *   └─────────┘ prev  └──────────┘ prev  └──────────┘
 *
 *   ===== T1 获取锁，Node-A 出队 =====
 *
 *                     ┌─ head(A) ─┐      ┌─ Node-B ─┐
 *   [GC 回收]         │ th=null   │ next  │ th=T2    │
 *   旧 head           │ pr=null   │──────>│ pr=A     │
 *                     │ ws=SIG    │<──────│ ws=0     │
 *                     └───────────┘ prev  └──────────┘
 *
 *   注意：Node-A 的 waitStatus 并不会被主动清零
 *   它仍保留 SIGNAL 状态，因为 Node-B 还需要它在释放时唤醒自己
 */

// ===== AQS#acquire —— 独占模式获取锁的顶层入口 =====
public final void acquire(int arg) {
    // 第一步：调用子类实现的 tryAcquire 尝试直接获取锁
    // 如果成功（返回 true），短路求值，整个方法直接返回
    // 如果失败（返回 false），进入第二步
    if (!tryAcquire(arg) &&
        // 第二步：addWaiter 将当前线程封装成 EXCLUSIVE 类型的 Node，加入队尾
        // 第三步：acquireQueued 让该节点在队列中自旋或阻塞，直到获取到锁
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 如果 acquireQueued 返回 true，说明线程在等待过程中被中断过
        // 此处重新设置中断标志位（因为 park 被唤醒后中断标志会被清除）
        selfInterrupt();
}

// ===== AQS#tryAcquire —— 模板方法，子类必须覆写 =====
protected boolean tryAcquire(int arg) {
    // 默认实现直接抛异常，迫使子类提供自己的获取逻辑
    throw new UnsupportedOperationException();
}

// ===== ReentrantLock.NonfairSync#tryAcquire =====
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);  // 委托给 Sync 的非公平获取方法
}
 
// ===== ReentrantLock.Sync#nonfairTryAcquire =====
final boolean nonfairTryAcquire(int acquires) {
    // 获取当前尝试获取锁的线程
    final Thread current = Thread.currentThread();
    // 读取 AQS 的 state 值（volatile 读，保证可见性）
    int c = getState();
 
    if (c == 0) {
        // state == 0 表示锁空闲，尝试 CAS 将 state 从 0 改为 acquires（通常为 1）
        if (compareAndSetState(0, acquires)) {
            // CAS 成功，设置当前线程为独占所有者
            setExclusiveOwnerThread(current);
            return true;  // 获取成功
        }
    }
    // 如果锁不空闲，检查持锁线程是否是自己（可重入判断）
    else if (current == getExclusiveOwnerThread()) {
        // 重入：state 累加
        int nextc = c + acquires;
        // 溢出检查（int 最大值后变负数）
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        // 因为只有持锁线程才能走到这里，不存在竞争，直接 set 即可
        setState(nextc);
        return true;  // 重入获取成功
    }
 
    return false;  // 获取失败
}

// ===== AQS#addWaiter —— 将当前线程封装为 Node 并加入队尾 =====
private Node addWaiter(Node mode) {
    // 创建新节点：持有当前线程引用，模式为 EXCLUSIVE（独占）或 SHARED（共享）
    Node node = new Node(Thread.currentThread(), mode);
 
    // ---- 快速尝试（Fast Path）----
    // 先尝试直接 CAS 到队尾，如果队列已经初始化且竞争不激烈，一次就能成功
    Node pred = tail;            // 读取当前尾节点
    if (pred != null) {          // 尾节点不为空，说明队列已经初始化过
        node.prev = pred;        // 新节点的 prev 指向旧的尾节点
        if (compareAndSetTail(pred, node)) {  // CAS 将 tail 指向新节点
            pred.next = node;    // 旧尾节点的 next 指向新节点，双向链表形成
            return node;         // 入队成功，直接返回
        }
    }
 
    // ---- 完整入队（Slow Path）----
    // 走到这里有两种情况：
    // 1. 队列尚未初始化（tail == null）
    // 2. CAS 竞争失败（多个线程同时入队）
    enq(node);
    return node;
}

// ===== AQS#enq —— 自旋 + CAS 确保节点一定入队成功 =====
private Node enq(final Node node) {
    // 无限循环（自旋），直到入队成功才退出
    for (;;) {
        Node t = tail;           // 每次循环都重新读取 tail（volatile 读）
 
        if (t == null) {
            // ---- 队列尚未初始化 ----
            // 创建一个"哨兵节点"（dummy node）作为 head
            // 这个节点不代表任何线程，仅用于简化队列操作
            if (compareAndSetHead(new Node()))
                tail = head;     // 初始时 head 和 tail 指向同一个哨兵节点
            // 注意：这里没有 return！初始化完成后会再次循环，将 node 接到尾部
        } else {
            // ---- 队列已初始化，执行入队 ----
            node.prev = t;       // 新节点的 prev 指向当前尾节点
            if (compareAndSetTail(t, node)) {  // CAS 尝试更新 tail
                t.next = node;   // 成功后将旧尾节点的 next 指向新节点
                return t;        // 返回旧的尾节点（即当前节点的前驱）
            }
            // CAS 失败则继续循环重试
        }
    }
}

// ===== AQS#acquireQueued —— 已入队的节点在队列中自旋/阻塞，直到获取锁 =====
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;       // 标记是否获取失败（用于异常时取消节点）
    try {
        boolean interrupted = false;  // 标记等待过程中是否被中断过
 
        // 无限循环（自旋）
        for (;;) {
            // 获取当前节点的前驱节点
            final Node p = node.predecessor();
 
            // ★ 核心判断：只有前驱是 head 的节点才有资格尝试获取锁
            // 这保证了 FIFO 的公平性——排在最前面的线程优先获取
            if (p == head && tryAcquire(arg)) {
                // 获取成功！将当前节点设为新的 head（出队）
                setHead(node);
                // 断开旧 head 的 next 引用，帮助 GC 回收
                p.next = null;   // help GC
                failed = false;  // 标记获取成功
                return interrupted; // 返回中断标志
            }
 
            // 走到这里说明：前驱不是 head，或者 tryAcquire 失败了
            // shouldParkAfterFailedAcquire：判断当前线程是否应该阻塞
            // parkAndCheckInterrupt：真正执行阻塞（LockSupport.park）
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 如果线程是被中断唤醒的，记录中断标志
                interrupted = true;
        }
    } finally {
        // 如果因异常退出循环（如 tryAcquire 抛异常），取消该节点
        if (failed)
            cancelAcquire(node);
    }
}

// ===== AQS#shouldParkAfterFailedAcquire =====
// 判断获取失败后是否应该阻塞当前线程
// 返回 true 表示"可以安全阻塞"，返回 false 表示"再给一次机会自旋"
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取前驱节点的等待状态
    int ws = pred.waitStatus;
 
    if (ws == Node.SIGNAL) {
        // ---- 前驱状态已经是 SIGNAL（-1）----
        // 意味着前驱释放锁时一定会唤醒自己
        // 可以安心阻塞了
        return true;
    }
 
    if (ws > 0) {
        // ---- 前驱状态 > 0，即 CANCELLED（1）----
        // 前驱节点已经被取消，需要跳过所有连续的已取消节点
        // 从当前节点往前遍历，找到第一个未取消的节点作为新前驱
        do {
            node.prev = pred = pred.prev;  // 向前跳跃
        } while (pred.waitStatus > 0);
        pred.next = node;  // 将有效前驱的 next 指向当前节点
        // 注意：这里返回 false，让外层循环再跑一轮
    } else {
        // ---- 前驱状态为 0 或 PROPAGATE（-3）----
        // CAS 将前驱状态设为 SIGNAL，为下一轮阻塞做准备
        // 这里不直接阻塞，而是返回 false 让外层再尝试一次 tryAcquire
        // 这给了线程"最后一次获取锁的机会"，减少不必要的 park/unpark 开销
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
 
    return false;
}

// ===== AQS#parkAndCheckInterrupt —— 阻塞当前线程并检查中断 =====
private final boolean parkAndCheckInterrupt() {
    // 调用 LockSupport.park 阻塞当前线程
    // 传入 this（即 AQS 实例）作为 blocker，便于诊断工具（如 jstack）显示阻塞原因
    LockSupport.park(this);
    // 线程被唤醒后执行到这里（两种可能：unpark 或 interrupt）
    // Thread.interrupted() 返回中断标志，并清除它
    return Thread.interrupted();
}

// ===== AQS#release —— 独占模式释放锁的顶层入口 =====
public final boolean release(int arg) {
    // 第一步：调用子类实现的 tryRelease 尝试释放锁
    if (tryRelease(arg)) {
        // 释放成功，检查队列中是否有等待的线程需要唤醒
        Node h = head;
        // head != null：队列已初始化
        // waitStatus != 0：说明后续有节点设置过 SIGNAL（需要唤醒后继）
        // 如果 waitStatus == 0，说明没有后继节点在等待，无需唤醒
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);  // 唤醒 head 的后继节点
        return true;
    }
    return false;  // tryRelease 返回 false（如可重入锁还没完全释放）
}

// ===== ReentrantLock.Sync#tryRelease =====
protected final boolean tryRelease(int releases) {
    // state 减去 releases（通常为 1）
    int c = getState() - releases;
 
    // 安全检查：只有持锁线程才能释放锁
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
 
    boolean free = false;
    if (c == 0) {
        // state 减到 0，说明锁完全释放（所有重入都退出了）
        free = true;
        // 清除独占线程标记
        setExclusiveOwnerThread(null);
    }
    // 更新 state（这里不需要 CAS，因为只有持锁线程才会调用 release）
    setState(c);
    // 返回 true 表示锁已完全释放，false 表示还有重入层次未释放
    return free;
}

// ===== AQS#unparkSuccessor —— 唤醒指定节点的后继线程 =====
private void unparkSuccessor(Node node) {
    // node 参数通常是 head 节点
 
    // 读取 node 的等待状态
    int ws = node.waitStatus;
    if (ws < 0)
        // 将 head 的 waitStatus 重置为 0
        // 这是一个"尽力而为"的操作，CAS 失败也没关系
        // 目的是让后续线程在 shouldParkAfterFailedAcquire 中看到 0 而非 SIGNAL
        // 从而多获得一次自旋机会
        compareAndSetWaitStatus(node, ws, 0);
 
    // 获取 head 的后继节点
    Node s = node.next;
 
    // ★ 如果后继为 null 或已被取消，需要从 tail 往前找
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 从 tail 开始，向前遍历，找到离 head 最近的未取消节点
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;  // 不断更新 s，最终 s 是最靠近 head 的有效节点
    }
 
    // 找到了有效的后继节点，唤醒它
    if (s != null)
        LockSupport.unpark(s.thread);
}

// 入队代码的三步操作（非原子）：
node.prev = t;              // ① 先链接 prev
compareAndSetTail(t, node);  // ② CAS 更新 tail
t.next = node;               // ③ 最后链接 next

// ===== AQS#setHead —— 将获取到锁的节点设为新的 head =====
private void setHead(Node node) {
    head = node;             // head 指向当前节点
    node.thread = null;      // 清空线程引用（head 节点不需要保存线程信息）
    node.prev = null;        // 断开与旧 head 的连接
}

// 自定义一个基于 AQS 的互斥锁（仅允许一个线程持有）
public class SimpleMutex {
    private final Sync sync = new Sync();
 
    // AQS 子类实现
    private static class Sync extends AbstractQueuedSynchronizer {
        // 独占获取：CAS 将 state 从 0 改为 1
        protected boolean tryAcquire(int arg) {
            return compareAndSetState(0, 1);
        }
        // 独占释放：直接将 state 设为 0
        protected boolean tryRelease(int arg) {
            setState(0);
            return true;
        }
    }
 
    public void lock()   { sync.acquire(1); }
    public void unlock() { sync.release(1); }
 
    public static void main(String[] args) throws InterruptedException {
        SimpleMutex mutex = new SimpleMutex();
        mutex.lock();       // 主线程第一次加锁
        System.out.println("First lock acquired");
        mutex.lock();       // 主线程第二次加锁（重入）
        System.out.println("Second lock acquired");
        mutex.unlock();
        mutex.unlock();
    }
}

// AQS 中的 acquireShared 方法 —— 共享模式获取同步状态的入口
public final void acquireShared(int arg) {
    // 1. 首先尝试以共享模式获取同步状态
    //    tryAcquireShared 是模板方法，由子类实现
    //    返回值含义：
    //      负数 → 获取失败
    //      零   → 获取成功，但后续线程不能再获取（资源刚好用完）
    //      正数 → 获取成功，且后续线程也可能成功（还有剩余资源）
    if (tryAcquireShared(arg) < 0)
        // 2. 获取失败，进入等待队列并自旋阻塞
        doAcquireShared(arg);
}

// AQS 中的 doAcquireShared —— 共享模式的排队与自旋获取
private void doAcquireShared(int arg) {
    // 1. 以 SHARED 模式创建节点并加入队列尾部
    //    注意这里传入的是 Node.SHARED（一个静态标记节点）
    //    独占模式传入的是 Node.EXCLUSIVE（即 null）
    final Node node = addWaiter(Node.SHARED);
 
    // 2. 标记是否获取失败（用于异常时取消节点）
    boolean failed = true;
    try {
        // 3. 中断标记，记录等待过程中是否被中断过
        boolean interrupted = false;
 
        // 4. 经典自旋循环 —— 与 acquireQueued 结构一致
        for (;;) {
            // 5. 获取当前节点的前驱节点
            final Node p = node.predecessor();
 
            // 6. 只有前驱是 head 时，才有资格尝试获取
            //    这保证了 FIFO 的公平性
            if (p == head) {
                // 7. 尝试以共享模式获取同步状态
                int r = tryAcquireShared(arg);
 
                // 8. r >= 0 表示获取成功
                if (r >= 0) {
                    // 9. ★ 核心区别 ★
                    //    独占模式只是简单的 setHead(node)
                    //    共享模式调用 setHeadAndPropagate
                    //    → 设置新 head + 尝试唤醒后续共享节点
                    setHeadAndPropagate(node, r);
 
                    // 10. 断开旧 head 的 next 引用，帮助 GC
                    p.next = null; // help GC
 
                    // 11. 如果等待过程中被中断过，补一个自我中断
                    if (interrupted)
                        selfInterrupt();
 
                    // 12. 标记获取成功
                    failed = false;
                    return;
                }
            }
 
            // 13. 前驱不是 head，或者 tryAcquireShared 失败
            //     判断是否应该挂起（与独占模式逻辑完全相同）
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 14. 记录中断状态（不立即抛出，只记录）
                interrupted = true;
        }
    } finally {
        // 15. 如果因为异常导致没有成功获取，取消当前节点
        if (failed)
            cancelAcquire(node);
    }
}

╔══════════════════════════════════════════════════════════════════════╗
║                独占模式 acquireQueued 成功后                         ║
║                                                                      ║
║   获取成功 → setHead(node) → 结束                                   ║
║   仅设置新 head，不唤醒任何后继                                      ║
╠══════════════════════════════════════════════════════════════════════╣
║                共享模式 doAcquireShared 成功后                       ║
║                                                                      ║
║   获取成功 → setHeadAndPropagate(node, r) → 可能唤醒后继 → 结束    ║
║   设置新 head + 若还有剩余资源，继续唤醒后续 SHARED 节点           ║
╚══════════════════════════════════════════════════════════════════════╝

// AQS 中的 setHeadAndPropagate
// 参数 node: 刚刚获取成功的节点（将成为新 head）
// 参数 propagate: tryAcquireShared 的返回值（剩余资源数）
private void setHeadAndPropagate(Node node, int propagate) {
    // 1. 保存旧的 head（后面判断条件时需要）
    Node h = head;
 
    // 2. 将当前节点设为新的 head
    //    setHead 会清空 node 的 thread 和 prev 引用
    setHead(node);
 
    // 3. ★ 判断是否需要继续唤醒后续节点 ★
    //    这个 if 条件看起来复杂，但每一项都有深意：
    //
    //    条件 A: propagate > 0
    //      → tryAcquireShared 返回正数，说明还有剩余资源
    //      → 后续线程也可能获取成功，应该唤醒
    //
    //    条件 B: h == null
    //      → 旧 head 为 null（理论上不会发生，防御性编程）
    //
    //    条件 C: h.waitStatus < 0
    //      → 旧 head 的 waitStatus 为负数（SIGNAL 或 PROPAGATE）
    //      → 说明有后继节点在等待唤醒
    //
    //    条件 D: (h = head) == null
    //      → 重新读取 head（可能已被其他线程更新）
    //      → 为 null 则防御性唤醒
    //
    //    条件 E: h.waitStatus < 0
    //      → 新 head 的 waitStatus 为负数
    //      → 说明新 head 后面还有节点在等待
    //
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
 
        // 4. 获取当前新 head 的后继节点
        Node s = node.next;
 
        // 5. 如果后继为 null（可能正在入队，尚未链接完成）
        //    或者后继是 SHARED 模式的节点
        //    → 调用 doReleaseShared 执行释放传播
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

// Node 类中的共享模式标记
static final Node SHARED = new Node();    // 共享模式标记（非 null）
static final Node EXCLUSIVE = null;       // 独占模式标记（null）
 
// Node 内部通过 nextWaiter 字段来区分模式
// 共享模式: node.nextWaiter == SHARED
// 独占模式: node.nextWaiter == null (EXCLUSIVE)
 
// 判断是否为共享模式的方法
final boolean isShared() {
    return nextWaiter == SHARED;           // 简单的引用比较
}

// AQS 中的 releaseShared —— 共享模式释放同步状态的入口
public final boolean releaseShared(int arg) {
    // 1. 尝试释放同步状态（模板方法，子类实现）
    //    例如 Semaphore: state += arg (CAS)
    //    例如 CountDownLatch: state -= 1, 当 state==0 时返回 true
    if (tryReleaseShared(arg)) {
        // 2. 释放成功，执行唤醒传播
        doReleaseShared();
        return true;
    }
    // 3. 释放未完成（如 CountDownLatch 计数还没到 0）
    return false;
}

// AQS 中的 doReleaseShared —— 共享模式唤醒传播的核心引擎
private void doReleaseShared() {
    // 1. 自旋循环 —— 直到成功完成一次有效操作或确认无需操作
    for (;;) {
        // 2. 每次循环开始时读取当前 head
        //    注意：head 可能在循环过程中被其他线程更改
        Node h = head;
 
        // 3. 检查队列是否非空（head != null && head != tail）
        //    head == tail 表示队列为空（只有哨兵节点）
        if (h != null && h != tail) {
 
            // 4. 读取 head 的 waitStatus
            int ws = h.waitStatus;
 
            // 5. 情况一：waitStatus == SIGNAL (-1)
            //    说明后继节点正在等待唤醒
            if (ws == Node.SIGNAL) {
                // 6. CAS 将 waitStatus 从 SIGNAL 改为 0
                //    为什么要先改为 0？
                //    → 防止多个线程同时 unpark 同一个后继节点
                //    → CAS 失败说明有其他线程抢先处理了，重新循环
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;  // CAS 失败，重新检查
 
                // 7. CAS 成功，唤醒后继节点
                unparkSuccessor(h);
            }
 
            // 8. 情况二：waitStatus == 0
            //    说明后继节点刚入队但还没来得及将前驱设为 SIGNAL
            //    或者刚刚被上面的 CAS 从 SIGNAL 改成了 0
            //    → 尝试 CAS 设为 PROPAGATE (-3)
            //    → 为 setHeadAndPropagate 中的 waitStatus < 0 检查埋下伏笔
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;  // CAS 失败，重新检查
        }
 
        // 9. ★ 关键退出条件 ★
        //    如果执行到这里，head 没有发生变化
        //    → 说明没有新的线程获取成功并更新 head
        //    → 当前线程的唤醒传播工作完成，可以退出
        //
        //    如果 head 发生了变化（被唤醒的线程已获取成功成为新 head）
        //    → 需要继续循环，尝试唤醒新 head 的后继
        //    → 这就是"传播"的核心所在！
        if (h == head)
            break;
    }
}

╔═══════════════════════════════════════════════════════════════╗
║  PROPAGATE 状态的作用链:                                      ║
║                                                               ║
║  doReleaseShared 中:                                          ║
║    ws==0 → CAS设为PROPAGATE                                  ║
║              ↓                                                ║
║  setHeadAndPropagate 中:                                      ║
║    检测到旧head.waitStatus < 0 (即PROPAGATE)                 ║
║              ↓                                                ║
║    即使 propagate==0, 仍然触发 doReleaseShared               ║
║              ↓                                                ║
║    避免信号丢失!                                              ║
╚═══════════════════════════════════════════════════════════════╝

// CountDownLatch 的 tryAcquireShared 实现
// state == 0 时返回 1 (正数)，表示有"剩余资源"（概念上的）
// state != 0 时返回 -1，表示获取失败
protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;  // 巧妙！state=0后所有线程都能获取
}

// ==================== Semaphore ====================
// tryAcquireShared: CAS 减少 state (可用许可数)
//   返回 remaining (剩余许可数, >= 0 成功, < 0 失败)
// tryReleaseShared: CAS 增加 state, 始终返回 true
//   → 每次 release 都触发 doReleaseShared
 
// ==================== CountDownLatch ====================
// tryAcquireShared: 检查 state == 0
//   state==0 返回 1 (成功), 否则返回 -1 (失败)
// tryReleaseShared: CAS 将 state 减 1
//   只有 state 从 1 变为 0 时才返回 true
//   → 只触发一次 doReleaseShared, 但会链式传播唤醒所有等待线程
 
// ==================== ReadWriteLock (读锁) ====================
// tryAcquireShared: 检查是否有写锁被持有 (排斥)
//   无写锁时 CAS 增加读锁计数 (state 高 16 位)
//   返回 1 (成功) 或 -1 (失败)
// tryReleaseShared: CAS 减少读锁计数
//   只有读锁计数变为 0 时返回 true
//   → 唤醒可能在等待的写锁线程

// ==================== AQS 源码：默认实现 ====================
 
// 独占获取 —— 默认抛异常，强制子类重写
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException(); // 子类不重写就直接报错
}
 
// 独占释放 —— 默认抛异常
protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}
 
// 共享获取 —— 默认抛异常
protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}
 
// 共享释放 —— 默认抛异常
protected boolean tryReleaseShared(int arg) {
    throw new UnsupportedOperationException();
}
 
// 是否独占持有 —— 默认抛异常
protected boolean isHeldExclusively() {
    throw new UnsupportedOperationException();
}

// ==================== AQS 骨架：acquire 中对 tryAcquire 的调用 ====================
public final void acquire(int arg) {
    // 第一步：调用子类实现的 tryAcquire 尝试快速获取
    if (!tryAcquire(arg) &&
        // 第二步：快速获取失败，包装成 Node 加入等待队列，然后自旋+阻塞
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 第三步：如果在排队过程中被中断过，重新设置中断标志
        selfInterrupt();
}

// ==================== 非公平锁的 tryAcquire ====================
// ReentrantLock.NonfairSync（实际委托给 Sync.nonfairTryAcquire）
 
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires); // 委托给父类 Sync 的通用方法
}
 
// Sync.nonfairTryAcquire —— 非公平获取的核心逻辑
final boolean nonfairTryAcquire(int acquires) {
    // 获取当前请求锁的线程
    final Thread current = Thread.currentThread();
    // 读取 AQS 的 state 值（0 表示未被持有，>0 表示已被持有）
    int c = getState();
 
    if (c == 0) {
        // ========== 锁空闲 ==========
        // 非公平：不检查队列中是否有等待者，直接 CAS 抢锁
        if (compareAndSetState(0, acquires)) {
            // CAS 成功，将当前线程设置为独占拥有者
            setExclusiveOwnerThread(current);
            return true; // 获取成功
        }
        // CAS 失败说明被其他线程抢先了，继续往下返回 false
    }
    else if (current == getExclusiveOwnerThread()) {
        // ========== 重入场景 ==========
        // 当前线程就是锁的持有者，执行重入逻辑
        int nextc = c + acquires; // state 累加
        if (nextc < 0) // 溢出检查（极端情况下重入次数超过 int 最大值）
            throw new Error("Maximum lock count exceeded");
        // 此处无需 CAS：只有持有锁的线程才能走到这里，不存在竞争
        setState(nextc);
        return true; // 重入获取成功
    }
 
    return false; // 锁被其他线程持有，获取失败
}

// ==================== 公平锁的 tryAcquire ====================
// ReentrantLock.FairSync
 
protected final boolean tryAcquire(int acquires) {
    // 获取当前请求锁的线程
    final Thread current = Thread.currentThread();
    // 读取 state
    int c = getState();
 
    if (c == 0) {
        // ========== 锁空闲 ==========
        // 公平锁的关键差异：先检查队列中是否有排在前面的等待者
        if (!hasQueuedPredecessors() &&  // 队列中没有比当前线程等待更久的
            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; // 获取失败
}

// ==================== AQS 骨架：release 中对 tryRelease 的调用 ====================
public final boolean release(int arg) {
    // 调用子类实现的 tryRelease
    if (tryRelease(arg)) {
        // tryRelease 返回 true —— 同步状态已完全释放
        Node h = head; // 拿到队列的头节点（即当前持有锁的虚拟节点）
        if (h != null && h.waitStatus != 0)
            // 头节点存在且 waitStatus 不为 0，唤醒后继节点
            unparkSuccessor(h);
        return true;  // 释放成功
    }
    return false; // 释放未完成（例如重入锁还需要多次 release）
}

// ==================== ReentrantLock.Sync.tryRelease ====================
protected final boolean tryRelease(int releases) {
    // 计算释放后的 state 值
    int c = getState() - releases;
 
    // 安全检查：只有持有锁的线程才能释放锁
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException(); // 非法释放，直接抛异常
 
    // free 标记：本次释放后锁是否完全自由
    boolean free = false;
 
    if (c == 0) {
        // state 降为 0，说明所有重入层次都已释放
        free = true;
        // 清空独占拥有者（锁变为可用状态）
        setExclusiveOwnerThread(null);
    }
 
    // 更新 state（此处无需 CAS，因为只有持锁线程能执行到这里）
    setState(c);
 
    // 返回 true 表示锁已完全释放，AQS 应唤醒后继
    // 返回 false 表示还有重入层次未释放，暂不唤醒
    return free;
}

// ==================== 可重入释放的 state 变化过程（示意） ====================
//
//  lock()  → state: 0 → 1  (首次获取)
//  lock()  → state: 1 → 2  (第一次重入)
//  lock()  → state: 2 → 3  (第二次重入)
//
//  unlock() → state: 3 → 2  → tryRelease returns false (不唤醒)
//  unlock() → state: 2 → 1  → tryRelease returns false (不唤醒)
//  unlock() → state: 1 → 0  → tryRelease returns true  (唤醒后继!)
//                               setExclusiveOwnerThread(null)

// ==================== AQS 骨架：acquireShared 中对 tryAcquireShared 的调用 ====================
public final void acquireShared(int arg) {
    // 返回值 < 0 表示获取失败
    if (tryAcquireShared(arg) < 0)
        // 失败则进入共享模式的排队逻辑
        doAcquireShared(arg);
}

// ==================== Semaphore.NonfairSync.tryAcquireShared ====================
// 非公平信号量：尝试获取 acquires 个许可
 
protected int tryAcquireShared(int acquires) {
    for (;;) { // 自旋 + CAS（可能需要多次重试）
        // 读取当前可用的许可数
        int available = getState();
        // 计算获取后的剩余许可数
        int remaining = available - acquires;
 
        if (remaining < 0 ||                    // 许可不足，直接返回负数（获取失败）
            compareAndSetState(available, remaining)) { // 许可充足，CAS 扣减
            // remaining < 0: 返回负数，AQS 安排线程排队
            // remaining >= 0 且 CAS 成功: 返回剩余数（>=0 均表示成功）
            return remaining;
        }
        // CAS 失败（其他线程抢先修改了 state），自旋重试
    }
}

// ==================== Semaphore.FairSync.tryAcquireShared ====================
// 公平信号量：在非公平版本基础上增加队列检查
 
protected int tryAcquireShared(int acquires) {
    for (;;) {
        // 公平性检查：如果队列中有先到的等待者，直接返回 -1（获取失败）
        if (hasQueuedPredecessors())
            return -1;
 
        int available = getState();
        int remaining = available - acquires;
 
        if (remaining < 0 ||
            compareAndSetState(available, remaining)) {
            return remaining;
        }
    }
}

// ==================== CountDownLatch.Sync.tryAcquireShared ====================
// CountDownLatch 的逻辑极其简单：state == 0 时放行，否则阻塞
 
protected int tryAcquireShared(int acquires) {
    // state == 0 意味着倒计时结束，所有等待线程都可以通过
    // 返回 1（正数）表示获取成功且后续线程也能成功 → 触发传播唤醒
    // 返回 -1（负数）表示获取失败，线程需要等待
    return (getState() == 0) ? 1 : -1;
}

// ==================== AQS 骨架：releaseShared ====================
public final boolean releaseShared(int arg) {
    // 调用子类实现的 tryReleaseShared
    if (tryReleaseShared(arg)) {
        // 释放成功，执行共享模式的唤醒传播逻辑
        doReleaseShared();
        return true;
    }
    return false;
}

// ==================== Semaphore.Sync.tryReleaseShared ====================
// 信号量释放：归还许可
 
protected final boolean tryReleaseShared(int releases) {
    for (;;) { // CAS 自旋：多个线程可能同时释放许可
        // 读取当前许可数
        int current = getState();
        // 计算归还后的许可数
        int next = current + releases;
 
        // 溢出检查（理论上不应发生，防御性编程）
        if (next < current)
            throw new Error("Maximum permit count exceeded");
 
        // CAS 更新 state
        if (compareAndSetState(current, next))
            return true; // 释放成功，AQS 将唤醒等待的线程
        // CAS 失败，自旋重试
    }
}

// ==================== CountDownLatch.Sync.tryReleaseShared ====================
// CountDownLatch 释放：每次调用 countDown() 将 state 减 1
 
protected boolean tryReleaseShared(int releases) {
    for (;;) { // CAS 自旋
        // 读取当前计数
        int c = getState();
 
        if (c == 0)
            return false; // 已经是 0 了，无需再释放，返回 false（不触发唤醒）
 
        // 计数减 1
        int nextc = c - 1;
 
        if (compareAndSetState(c, nextc))
            // 只有当计数从 1 降到 0 时才返回 true（触发唤醒所有等待者）
            return nextc == 0;
        // CAS 失败，自旋重试
    }
}

// ==================== AQS 内部：Condition 中对 isHeldExclusively 的使用 ====================
 
// ConditionObject.signal() 方法中的校验
public final void signal() {
    // 调用 isHeldExclusively 检查当前线程是否持有独占锁
    if (!isHeldExclusively())
        // 如果没持有锁就调用 signal()，抛出 IllegalMonitorStateException
        // 这与 Object.notify() 在未持有 monitor 时抛异常是同一语义
        throw new IllegalMonitorStateException();
    // ... 后续唤醒逻辑
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);
}
 
// ConditionObject.await() 方法中同样有类似校验
public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    // 将当前线程加入 Condition 等待队列
    Node node = addConditionWaiter();
    // 完全释放锁（savedState 保存重入次数以便后续恢复）
    int savedState = fullyRelease(node);
    // fullyRelease 内部也会间接依赖锁的持有状态
    // ...
}

// ==================== ReentrantLock.Sync.isHeldExclusively ====================
protected final boolean isHeldExclusively() {
    // 简单直接：判断当前线程是否就是独占拥有者
    return getExclusiveOwnerThread() == Thread.currentThread();
}

// ReentrantLock 构造函数
public ReentrantLock() {
    sync = new NonfairSync();  // 默认非公平锁，性能更优
}
 
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();  // 由调用者选择公平策略
}

┌─────────────────────────────────────────────┐
│            AQS state 语义映射                │
├──────────────┬──────────────────────────────┤
│  state == 0  │  锁空闲，无线程持有            │
│  state == 1  │  锁被线程 T 首次获取           │
│  state == 2  │  线程 T 重入了一次（共持有2次） │
│  state == N  │  线程 T 重入了 N-1 次          │
├──────────────┴──────────────────────────────┤
│  exclusiveOwnerThread == T                   │
│  → 标识当前持有锁的线程                       │
└─────────────────────────────────────────────┘

// ReentrantLock#lock() —— 用户调用的入口
public void lock() {
    sync.acquire(1);  // 委托给 sync 对象，参数 1 表示获取一次锁
}

// NonfairSync —— 非公平同步器
static final class NonfairSync extends Sync {
 
    // 非公平锁的 lock 入口
    final void lock() {
        // 第一步：上来就直接 CAS 尝试将 state 从 0 改为 1（插队抢锁）
        if (compareAndSetState(0, 1))
            // CAS 成功，说明锁原本空闲，当前线程直接获得锁
            setExclusiveOwnerThread(Thread.currentThread());
        else
            // CAS 失败，说明锁已被占用，走 AQS 标准 acquire 流程
            acquire(1);
    }
 
    // 重写 AQS 的模板方法 tryAcquire
    protected final boolean tryAcquire(int acquires) {
        // 委托给父类 Sync 的 nonfairTryAcquire 方法
        return nonfairTryAcquire(acquires);
    }
}

// AQS#acquire —— 独占模式获取资源的骨架方法
public final void acquire(int arg) {
    // 1. 先调用子类实现的 tryAcquire 尝试获取
    // 2. 若失败，创建独占节点加入等待队列
    // 3. 在队列中自旋 + 阻塞，直到获取成功
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 如果在等待过程中被中断过，补一个中断标记
        selfInterrupt();
}