读写锁 ReentrantReadWriteLock 与 StampedLock

// 位运算常量
static final int SHARED_SHIFT   = 16;
static final int SHARED_UNIT    = 1 << SHARED_SHIFT; // 0x00010000 = 65536
static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1; // 0x0000FFFF = 65535
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1; // 同上，低16位掩码

// 从 state 中提取读锁计数（高 16 位无符号右移）
static int sharedCount(int c) {
    return c >>> SHARED_SHIFT;
}

// 从 state 中提取写锁计数（低 16 位 & 掩码）
static int exclusiveCount(int c) {
    return c & EXCLUSIVE_MASK;
}

protected final boolean tryAcquire(int acquires) {
    Thread current = Thread.currentThread();
    int c = getState();
    int w = exclusiveCount(c); // 提取低 16 位：写锁计数

    if (c != 0) {
        // c != 0 说明有人持锁（读或写）
        // w == 0 说明写锁计数为 0 → 那就是有读者 → 写者必须等
        // current != getExclusiveOwnerThread() → 不是自己重入 → 也等
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        setState(c + acquires); // 写锁重入
        return true;
    }
    // c == 0 → 无人持锁，尝试 CAS 抢占写锁
    if (writerShouldBlock() || !compareAndSetState(c, c + acquires))
        return false;
    setExclusiveOwnerThread(current);
    return true;
}

ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

// ① 获取写锁
rwl.writeLock().lock();
try {
    // 修改共享数据
    data.update(newValue);
} finally {
    // ③ 释放写锁（在此之前必须先获取读锁！）
    rwl.writeLock().unlock();
}

// ② 在释放写锁之前获取读锁
rwl.readLock().lock();
try {
    // 以只读方式使用刚写入的数据
    return data.get();
} finally {
    rwl.readLock().unlock(); // ④ 最终释放读锁
}

// 在 tryAcquire 中有这个判断：
if (c != 0) {
    if (w == 0 || current != getExclusiveOwnerThread())
        return false; // ← 如果有读者（w==0 但 c!=0），直接失败
}
// 即使当前线程持有读锁，w == 0 依然成立 → 获取写锁失败

final boolean tryReadLock() {
    Thread current = Thread.currentThread();
    for (;;) {
        int c = getState();
        // 关键判断：写锁被别的线程持有时，读者才需要排队
        if (exclusiveCount(c) != 0 &&
            getExclusiveOwnerThread() != current)
            return false; // 有写者 → 读者阻塞

        int r = sharedCount(c);
        if (r == MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        if (compareAndSetState(c, c + SHARED_UNIT)) {
            // CAS 成功，读锁 +1
            ...
            return true;
        }
    }
}

// 公平模式的写锁获取 —— 前面有人排队就阻塞
final boolean writerShouldBlock() {
    return hasQueuedPredecessors(); // AQS 队列中有人在我前面
}

// 公平模式的读锁获取 —— 前面有写者在排队就阻塞
final boolean readerShouldBlock() {
    return hasQueuedPredecessors(); // 队列中有写者排在我前面 → 读者也让路
}

public class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();

    // 写操作
    public void move(double deltaX, double deltaY) {
        long stamp = sl.writeLock(); // 获取写锁
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp); // 释放写锁
        }
    }

    // 乐观读 —— 零锁开销
    public double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead(); // ① 获取版本号，不加锁
        double currentX = x, currentY = y; // ② 直接读数据

        if (!sl.validate(stamp)) { // ③ 验证：期间是否有写操作？
            // 验证失败 → 升级为悲观读锁
            stamp = sl.readLock(); // ④ 加悲观读锁
            try {
                currentX = x;
                currentY = y; // ⑤ 重新读取
            } finally {
                sl.unlockRead(stamp); // ⑥ 释放读锁
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

StampedLock sl = new StampedLock();

long stamp = sl.writeLock();
try {
    doSomething(); // 这个方法内部又调用了 sl.writeLock()
    // → 死锁！StampedLock 不支持重入！
} finally {
    sl.unlockWrite(stamp);
}

void doSomething() {
    long s = sl.writeLock(); // 同一个线程再次获取写锁 → 阻塞
    try { ... } finally { sl.unlockWrite(s); }
}