// 基于 JDK 25 (本地 D:/1ForCode/JAVA_Source), java.util.concurrent.locks.ReentrantReadWriteLock.Sync
// 读锁获取: 共享语义, 走 AQS 的 tryAcquireShared, 返回 >=0 表示成功
protected final long tryAcquireShared(long unused) {
    Thread current = Thread.currentThread();
    long c = getState();
    if (exclusiveCount(c) != 0 &&
        getExclusiveOwnerThread() != current)
        return -1L;                     // 别人持写锁 → 读失败; 写锁是自己的则放行 —— 锁降级的入口就在这个条件里
    int r = sharedCount(c);
    if (!readerShouldBlock() &&
        r < MAX_COUNT &&
        compareAndSetState(c, c + SHARED_UNIT)) {   // 整个 long 一起 CAS, 读计数 +1 的同时天然校验了"写计数没变"
        if (r == 0) {
            firstReader = current;      // 第一个读者: 最快路径, 零 ThreadLocal 开销
            firstReaderHoldCount = 1;
        } else if (firstReader == current) {
            firstReaderHoldCount++;     // 第一个读者重入
        } else {
            HoldCounter rh = cachedHoldCounter;
            if (rh == null ||
                rh.tid != LockSupport.getThreadId(current))
                cachedHoldCounter = rh = readHolds.get();   // 缓存未命中才查 ThreadLocal
            else if (rh.count == 0)
                readHolds.set(rh);      // 缓存里是自己但 ThreadLocal 已被 remove 过, 补回去
            rh.count++;
        }
        return 1L;
    }
    return fullTryAcquireShared(current);   // 快路径失败(该让/CAS 输/计数满), 转完整版重试循环
}

final long fullTryAcquireShared(Thread current) {
    HoldCounter rh = null;
    for (;;) {
        long c = getState();
        if (exclusiveCount(c) != 0) {
            if (getExclusiveOwnerThread() != current)
                return -1;
            // else we hold the exclusive lock; blocking here
            // would cause deadlock.          // 持写锁的自己若在这被挡, 就没人能放写锁了 → 降级必须无条件放行
        } else if (readerShouldBlock()) {
            // Make sure we're not acquiring read lock reentrantly
            if (firstReader == current) {     // 重入的读者即使"该让"也放行: 它可能挡着后面的写者, 让它阻塞同样会死锁
                // assert firstReaderHoldCount > 0;
            } else {
                if (rh == null) {
                    rh = cachedHoldCounter;
                    if (rh == null ||
                        rh.tid != LockSupport.getThreadId(current)) {
                        rh = readHolds.get();
                        if (rh.count == 0)
                            readHolds.remove();   // 白查了一次, 立刻清掉, 别给线程留一个空 HoldCounter
                    }
                }
                if (rh.count == 0)
                    return -1L;               // 首次获取且政策要求让路 → 老实进队
            }
        }
        if (sharedCount(c) == MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        if (compareAndSetState(c, c + SHARED_UNIT)) {
            // ... 与 tryAcquireShared 相同的 firstReader/cachedHoldCounter 记账, 略
            return 1L;
        }
    }
}

protected final boolean tryReleaseShared(long unused) {
    Thread current = Thread.currentThread();
    if (firstReader == current) {
        // assert firstReaderHoldCount > 0;
        if (firstReaderHoldCount == 1)
            firstReader = null;
        else
            firstReaderHoldCount--;
    } else {
        HoldCounter rh = cachedHoldCounter;
        if (rh == null ||
            rh.tid != LockSupport.getThreadId(current))
            rh = readHolds.get();
        int count = rh.count;
        if (count <= 1) {
            readHolds.remove();               // 重入数归零就从 ThreadLocal 移除, 防内存泄漏
            if (count <= 0)
                throw unmatchedUnlockException();   // 没拿过读锁却来解锁
        }
        --rh.count;
    }
    for (;;) {
        long c = getState();
        long nextc = c - SHARED_UNIT;
        if (compareAndSetState(c, nextc))     // 多个读者并发释放, 必须 CAS 自旋(对比写锁释放的普通写)
            // Releasing the read lock has no effect on readers,
            // but it may allow waiting writers to proceed if
            // both read and write locks are now free.
            return nextc == 0;                // 只有读写全空才返回 true 去唤醒后继 —— 唤醒的通常是等疯了的写者
    }
}

// 基于 JDK 25 (本地 D:/1ForCode/JAVA_Source), java.util.concurrent.locks.ReentrantReadWriteLock
static final class NonfairSync extends Sync {
    final boolean writerShouldBlock() {
        return false; // writers can always barge      // 写者永远可以插队
    }
    final boolean readerShouldBlock() {
        /* As a heuristic to avoid indefinite writer starvation,
         * block if the thread that momentarily appears to be head
         * of queue, if one exists, is a waiting writer. ... */
        return apparentlyFirstQueuedIsExclusive();     // 队头等着的是写者 → 新读者让路。防写饥饿的启发式, 不是保证
    }
}

static final class FairSync extends Sync {
    final boolean writerShouldBlock() {
        return hasQueuedPredecessors();                // 公平版读写一视同仁: 前面有人排队就不抢
    }
    final boolean readerShouldBlock() {
        return hasQueuedPredecessors();
    }
}