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 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 void a() {
    lock.lock();
    try {
        b();          // b() 内部还要 lock.lock() —— 同一线程抢自己持有的锁
    } finally {
        lock.unlock();
    }
}
public void b() {
    lock.lock();      // 若锁不可重入：当前线程永远等不到"释放"，死锁
    try {
        // ...
    } finally {
        lock.unlock();
    }
}

outerThread:  lock.lock();   // state: 0 → 1（CAS 抢占，owner = outerThread）
outerThread:      lock.lock();  // state: 1 → 2（重入检查通过，owner 还是自己）
outerThread:      lock.unlock(); // state: 2 → 1 ★ 锁没真正释放，没人被唤醒
outerThread:  lock.unlock();   // state: 1 → 0 ★ 真正释放，unparkSuccessor 唤醒队首

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

// ① 可中断：等待锁的过程中响应中断（内部 acquireInterruptibly，
//    park 后检查中断状态并抛 InterruptedException）
try {
    lock.lockInterruptibly();
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();  // 惯例：恢复中断标记，交给上层决策
    return;                              // 本轮不抢了（比如任务已被取消）
}
try {
    // ...临界区
} finally {
    lock.unlock();
}

// ② 超时：最多等 N 秒，抢不到就走兜底
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // ...临界区
    } finally {
        lock.unlock();
    }
} else {
    log.warn("抢锁超时，走降级逻辑");
    // 返回缓存 / 降级数据 / 交给重试队列
}

// ③ 非阻塞：抢到就干，抢不到立刻走人
if (lock.tryLock()) {
    try {
        // ...临界区
    } finally {
        lock.unlock();
    }
}

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

final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {           // ★ 全队列只有队首这 1 个线程会发 CAS(state)
    setHead(node); ...
}
if (shouldParkAfterFailedAcquire(p, node) &&
    parkAndCheckInterrupt())                    // ★ 抢不到就去睡，不在这里自旋重试
    interrupted = true;

 * A thread may try to acquire if it is first in the queue. But being
 * first does not guarantee success; it only gives the right to contend.
   → 排到队首拿到的不是锁，只是「再抢一次」的资格。

 * ...while acquires do not "spin" in the usual sense, they may perform
 * multiple invocations of tryAcquire interspersed with other
 * computations before blocking. This gives most of the benefits of spins
 * when exclusive synchronization is only briefly held, without most of
 * the liabilities when it isn't.
   → 获取不是通常意义上的自旋：几次尝试之间穿插的是「建节点、挂 tail、改状态」这些记账动作。
     锁只被持有很短时间时，能吃到自旋的好处；持有时间长时，又不背上自旋的包袱。

 * // JDK 17 重写版补了一句更直接的：
 * Except in this case, AQS locks do not spin.
   → 除了队首那几次重试，AQS 的锁不自旋。

byte spins = 0, postSpins = 0;        // retries upon unpark of first thread
...
} else if (first && spins != 0) {
    --spins;                            // 只有队首允许多抢几次；reduce unfairness on rewaits
    Thread.onSpinWait();
} else if (node.status == 0) {
    node.status = WAITING;              // 登记「我要睡了」，再复查一次
} else {
    spins = postSpins = (byte)((postSpins << 1) | 1);   // 1,3,7,…,255 指数增长
    LockSupport.park(this);             // 这次是真睡了
}

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

class BoundedQueue<T> {
    private final Deque<T> deque = new ArrayDeque<>();
    private final int cap;
    private final Lock lock = new ReentrantLock();
    private final Condition notFull  = lock.newCondition();  // 生产者等
    private final Condition notEmpty = lock.newCondition();  // 消费者等

    public BoundedQueue(int cap) { this.cap = cap; }

    public void put(T v) throws InterruptedException {
        lock.lock();
        try {
            while (deque.size() == cap) notFull.await();   // ★ while 不是 if
            deque.addLast(v);
            notEmpty.signal();   // 精确唤醒一个消费者
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (deque.isEmpty()) notEmpty.await();
            T v = deque.removeFirst();
            notFull.signal();    // 精确唤醒一个生产者
            return v;
        } finally {
            lock.unlock();
        }
    }
}

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

lock.lock();
// 业务代码抛了异常（NPE / 超时 / DB 断了……）
doSomething();          // ← 这里炸了
lock.unlock();          // ← 永远执行不到！锁被永久占用

lock.lock();
try {
    // 临界区
} finally {
    lock.unlock();   // 无论成功失败、抛什么异常，必走
}