AQS 框架与 ReentrantLock：独占锁、公平锁、Condition

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
    // 同步状态：ReentrantLock 中 0=空闲，>0=重入次数；Semaphore 中=许可数
    private volatile int state;
    // CLH 变体队列的头尾节点
    private transient volatile Node head;
    private transient volatile Node tail;
    // 独占模式：子类重写
    protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); }
    protected boolean tryRelease(int arg) { throw new UnsupportedOperationException(); }
    // 共享模式：CountDownLatch / Semaphore 重写
    protected int tryAcquireShared(int arg) { ... }
    protected boolean tryReleaseShared(int arg) { ... }
}

static final class Node {
    static final int CANCELLED = 1;    // 已取消（超时/中断）
    static final int SIGNAL    = -1;   // 后继需要被 unpark
    static final int CONDITION = -2;   // 在 Condition 队列中
    static final int PROPAGATE = -3;   // 共享模式传播唤醒
    volatile int waitStatus;
    volatile Node prev;       // 前驱（取消时回溯找有效节点）
    volatile Node next;       // 后继（unpark 目标）
    volatile Thread thread;
    Node nextWaiter;          // Condition 后继 / 独占or共享标识
}

final void lock() {
    // ① 上来先 CAS 抢锁，不管队列有没有人 —— "插队"尝试
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);  // ② CAS 失败，走 AQS 标准流程
}

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();  // 等待中被中断过，补上中断标记
}

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // ③ state==0 锁空闲，CAS 抢占
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    } else if (current == getExclusiveOwnerThread()) {
        // ④ 当前线程已持有 → 重入，state+1
        int nextc = c + acquires;
        setState(nextc);  // 无需 CAS（只有自己能改）
        return true;
    }
    return false;  // ⑤ 被其他线程持有，获取失败
}

final boolean acquireQueued(Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            // 前驱是 head 才有资格尝试获取锁
            if (p == head && tryAcquire(arg)) {
                setHead(node);  // 成功，自己成为新 head
                p.next = null;  // 旧 head 断开，帮助 GC
                failed = false;
                return interrupted;
            }
            // 获取失败：判断是否应 park
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed) cancelAcquire(node);
    }
}

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

// FairSync 的 tryAcquire —— 比 NonfairSync 多了一个检查
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()) {
        setState(c + acquires);  // 重入
        return true;
    }
    return false;
}

// AQS 提供的判断方法
public final boolean hasQueuedPredecessors() {
    Node h = head, t = tail, s;
    // 队列非空 且 我不是第一个等待者 → 有人排在我前面
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

public void unlock() { sync.release(1); }

// AQS.release() 模板方法
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);  // 唤醒后继
        return true;
    }
    return false;
}

// ReentrantLock.Sync.tryRelease()
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = (c == 0);
    if (free) setExclusiveOwnerThread(null);
    setState(c);  // 无需 CAS：只有持有者会修改 state
    return free;
}

private void unparkSuccessor(Node node) {
    if (node.waitStatus < 0)
        compareAndSetWaitStatus(node, node.waitStatus, 0);
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0) s = t;
    }
    if (s != null) LockSupport.unpark(s.thread);
}

public final void await() throws InterruptedException {
    Node node = addConditionWaiter();      // ① 加入条件队列
    int savedState = fullyRelease(node);   // ② 完全释放锁（保存重入次数）
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);            // ③ park 阻塞
    }
    acquireQueued(node, savedState);        // ④ 回到 sync 队列重新竞争锁
}
public final void signal() {
    Node first = firstWaiter;
    if (first != null) doSignal(first);    // 唤醒条件队列第一个节点
}
private void doSignal(Node first) {
    do {
        if ((firstWaiter = first.nextWaiter) == null) lastWaiter = null;
        first.nextWaiter = null;
    } while (!transferForSignal(first) &&   // 转移到 sync 队列
             (first = firstWaiter) != null);
}

Sync(int count) { setState(count); }  // state = 初始计数值
protected int tryAcquireShared(int arg) {
    return (getState() == 0) ? 1 : -1;  // state==0 成功，否则阻塞
}
protected boolean tryReleaseShared(int arg) {
    for (;;) {
        int c = getState();
        if (c == 0) return false;
        if (compareAndSetState(c, c - 1))
            return c - 1 == 0;  // 减到 0 才释放所有等待线程
    }
}

protected int tryAcquireShared(int acquires) {
    for (;;) {
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 || compareAndSetState(available, remaining))
            return remaining;  // <0 表示许可不够，获取失败
    }
}
protected boolean tryReleaseShared(int releases) {
    for (;;) {
        int c = getState(), next = c + releases;
        if (compareAndSetState(c, next)) return true;
    }
}

static final int SHARED_SHIFT = 16;
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;  // 0x0000FFFF
// 读锁计数 = state 高 16 位（无符号右移）
static int sharedCount(int c) { return c >>> SHARED_SHIFT; }
// 写锁计数 = state 低 16 位（位与掩码）
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }