读写锁与Condition ⭐⭐

import java.util.concurrent.locks.ReentrantReadWriteLock;
 
public class CacheExample {
 
    // 创建读写锁实例
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
 
    // 分别获取读锁和写锁对象
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
 
    // 模拟共享数据：缓存值
    private volatile String cachedData = "initial";
 
    /**
     * 读操作：多个线程可同时进入
     */
    public String readData() {
        // 获取读锁——如果此时没有线程持有写锁，则立即成功
        readLock.lock();
        try {
            // 在读锁保护下安全地读取共享数据
            System.out.println(Thread.currentThread().getName()
                    + " 正在读取数据: " + cachedData);
            // 模拟读取耗时（例如遍历大集合、计算哈希等）
            Thread.sleep(100);
            // 返回读到的数据
            return cachedData;
        } catch (InterruptedException e) {
            // 恢复中断标记，遵循最佳实践
            Thread.currentThread().interrupt();
            return null;
        } finally {
            // 无论是否异常，必须在 finally 中释放读锁
            readLock.unlock();
        }
    }
}

/**
 * 写操作：同一时刻只能有一个线程进入
 */
public void writeData(String newData) {
    // 获取写锁——如果此时有任何线程持有读锁或写锁，则阻塞等待
    writeLock.lock();
    try {
        // 在写锁保护下安全地修改共享数据
        System.out.println(Thread.currentThread().getName()
                + " 正在写入数据: " + newData);
        // 模拟写入耗时（例如写数据库、刷磁盘等）
        Thread.sleep(200);
        // 执行实际的数据修改
        cachedData = newData;
        System.out.println(Thread.currentThread().getName()
                + " 写入完成");
    } catch (InterruptedException e) {
        // 恢复中断标记
        Thread.currentThread().interrupt();
    } finally {
        // 无论是否异常，必须在 finally 中释放写锁
        writeLock.unlock();
    }
}

import java.util.concurrent.locks.ReentrantReadWriteLock;
 
public class ReadWriteLockDemo {
 
    // 读写锁实例
    private static final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    // 共享数据
    private static int sharedData = 0;
 
    public static void main(String[] args) {
        // 启动 3 个读线程——它们应该能并行执行
        for (int i = 1; i <= 3; i++) {
            final int id = i;
            new Thread(() -> {
                // 获取读锁
                rwLock.readLock().lock();
                try {
                    System.out.println("读线程-" + id + " 获得读锁, 时间="
                            + System.currentTimeMillis() % 10000);
                    // 模拟读操作耗时 1 秒
                    Thread.sleep(1000);
                    // 读取共享数据
                    System.out.println("读线程-" + id + " 读到: " + sharedData);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    // 释放读锁
                    rwLock.readLock().unlock();
                    System.out.println("读线程-" + id + " 释放读锁");
                }
            }, "Reader-" + i).start();
        }
 
        // 启动 1 个写线程——它必须等所有读锁释放后才能获得写锁
        new Thread(() -> {
            // 获取写锁
            rwLock.writeLock().lock();
            try {
                System.out.println("写线程 获得写锁, 时间="
                        + System.currentTimeMillis() % 10000);
                // 修改共享数据
                sharedData = 42;
                // 模拟写操作耗时
                Thread.sleep(500);
                System.out.println("写线程 写入完成: " + sharedData);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 释放写锁
                rwLock.writeLock().unlock();
                System.out.println("写线程 释放写锁");
            }
        }, "Writer").start();
    }
}

import java.util.concurrent.locks.ReentrantReadWriteLock;
 
public class LockDowngradeDemo {
 
    // 创建读写锁
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
 
    // 共享数据
    private volatile boolean cacheValid = false;
    private int data = 0;
 
    public void processCachedData() {
        // ① 先尝试获取读锁检查缓存
        readLock.lock();
        // 检查缓存是否有效
        if (!cacheValid) {
            // 缓存无效，需要更新——必须获取写锁
            // ② 释放读锁（读锁不能直接升级为写锁，否则可能死锁）
            readLock.unlock();
 
            // ③ 获取写锁来更新数据
            writeLock.lock();
            try {
                // ④ 双重检查：可能其他线程已在此期间更新了缓存
                if (!cacheValid) {
                    // 执行实际的数据计算/加载
                    data = loadFromDatabase();
                    // 标记缓存为有效
                    cacheValid = true;
                    System.out.println("缓存已更新, data=" + data);
                }
 
                // ⑤ 【锁降级的核心】在持有写锁的同时获取读锁
                readLock.lock();
                // 此时当前线程同时持有：写锁 + 读锁
 
            } finally {
                // ⑥ 释放写锁，完成降级——现在只持有读锁
                writeLock.unlock();
            }
        }
 
        // ⑦ 此时一定持有读锁（无论走了哪个分支）
        try {
            // 安全地使用缓存数据
            System.out.println("使用缓存数据: " + data);
        } finally {
            // ⑧ 最终释放读锁
            readLock.unlock();
        }
    }
 
    /**
     * 模拟从数据库加载数据
     */
    private int loadFromDatabase() {
        return 42; // 模拟返回值
    }
}

// ❌ 错误示范：单线程锁升级也会死锁
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
 
// 获取读锁
rwLock.readLock().lock();
 
// 尝试获取写锁——此线程自身持有读锁
// 写锁要求 readCount == 0，但当前 readCount == 1（自己持有）
// 而自己又无法释放读锁（因为正在等写锁获取完成后才会执行后续代码）
// 结果：永远等待，线程挂起——死锁！
rwLock.writeLock().lock(); // ← 程序永远卡在这里

// === 以下是 ReentrantReadWriteLock.Sync 内部类中的核心常量 ===
 
// SHARED_SHIFT = 16，表示读锁计数器从第 16 位开始
static final int SHARED_SHIFT   = 16;
 
// SHARED_UNIT = 1 << 16 = 65536 = 0x00010000
// 每获取一次读锁，state 增加 SHARED_UNIT（即高 16 位加 1）
static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
 
// MAX_COUNT = (1 << 16) - 1 = 65535
// 读锁和写锁各自的最大持有数
static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
 
// EXCLUSIVE_MASK = 0x0000FFFF（低 16 位全为 1）
// 通过 state & EXCLUSIVE_MASK 可以提取出写锁的重入次数
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

/**
 * 提取读锁数量：将 state 无符号右移 16 位
 * 例如 state = 0x00030002
 *   >>> 16 → 0x00000003 → 读锁数量 = 3
 */
static int sharedCount(int c) {
    return c >>> SHARED_SHIFT;
}
 
/**
 * 提取写锁重入次数：用掩码取低 16 位
 * 例如 state = 0x00030002
 *   & 0x0000FFFF → 0x00000002 → 写锁重入次数 = 2
 */
static int exclusiveCount(int c) {
    return c & EXCLUSIVE_MASK;
}

// ========== 写锁获取：tryAcquire ==========
protected final boolean tryAcquire(int acquires) {
    // 获取当前线程引用
    Thread current = Thread.currentThread();
    // 读取当前 state 值
    int c = getState();
    // 提取写锁重入次数
    int w = exclusiveCount(c);
 
    if (c != 0) {
        // state != 0 说明有锁被持有
        // 如果写锁计数为 0（说明只有读锁），或者持有写锁的不是当前线程
        // → 获取失败，返回 false（将进入 AQS 等待队列）
        if (w == 0 || current != getExclusiveOwnerThread()) {
            return false;
        }
        // 走到这里说明当前线程已持有写锁，检查重入是否溢出
        if (w + exclusiveCount(acquires) > MAX_COUNT) {
            throw new Error("Maximum lock count exceeded");
        }
        // 写锁重入：直接修改 state 低 16 位
        setState(c + acquires);
        return true;
    }
 
    // c == 0：当前无任何锁
    // writerShouldBlock()：公平模式下检查等待队列是否有前驱节点
    if (writerShouldBlock() || !compareAndSetState(c, c + acquires)) {
        // CAS 失败或需要排队 → 获取失败
        return false;
    }
    // CAS 成功，设置当前线程为写锁持有者
    setExclusiveOwnerThread(current);
    return true;
}
 
// ========== 读锁获取：tryAcquireShared（简化版）==========
protected final int tryAcquireShared(int unused) {
    Thread current = Thread.currentThread();
    // 读取当前 state
    int c = getState();
 
    // 如果写锁被持有 (exclusiveCount != 0)
    // 且持有者不是当前线程 → 获取失败（读写互斥）
    // 如果持有者就是当前线程 → 允许（支持锁降级）
    if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) {
        return -1; // 获取失败
    }
 
    // 提取当前读锁数量
    int r = sharedCount(c);
 
    // readerShouldBlock()：公平模式下检查是否需要让位给写锁
    if (!readerShouldBlock() && r < MAX_COUNT
            && compareAndSetState(c, c + SHARED_UNIT)) {
        // CAS 成功：高 16 位加 1
        // 此处省略了读锁重入计数的 ThreadLocal 更新逻辑
        // firstReader / firstReaderHoldCount 用于优化第一个读者的计数
        // cachedHoldCounter / readHolds(ThreadLocal) 用于其他读者
        return 1; // 获取成功
    }
 
    // CAS 失败或需要排队，进入完整版的获取逻辑（自旋重试）
    return fullTryAcquireShared(current);
}

// 每个线程的读锁重入计数器
static final class HoldCounter {
    int count = 0;          // 重入次数
    final long tid = getThreadId(Thread.currentThread()); // 线程 ID
}
 
// 使用 ThreadLocal 为每个线程维护独立的 HoldCounter
static final class ThreadLocalHoldCounter
        extends ThreadLocal<HoldCounter> {
    public HoldCounter initialValue() {
        return new HoldCounter();
    }
}

ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
 
// 线程 A 执行：
rwLock.readLock().lock();
System.out.println("线程A: 持有读锁, 尝试获取写锁...");
rwLock.writeLock().lock();    // ← 关注此行
System.out.println("线程A: 获得写锁");
rwLock.writeLock().unlock();
rwLock.readLock().unlock();

// StampedLock 的三种模式一览
StampedLock lock = new StampedLock();
 
// 1. 写锁 (Writing Mode) —— 独占，类似 ReentrantReadWriteLock 的写锁
long stamp = lock.writeLock();       // 获取写锁，返回 stamp
try {
    // ... 写操作 ...
} finally {
    lock.unlockWrite(stamp);         // 释放写锁时必须传入同一个 stamp
}
 
// 2. 悲观读锁 (Reading Mode) —— 共享，类似 ReentrantReadWriteLock 的读锁
long stamp = lock.readLock();        // 获取悲观读锁，返回 stamp
try {
    // ... 读操作 ...
} finally {
    lock.unlockRead(stamp);          // 释放读锁时必须传入同一个 stamp
}
 
// 3. 乐观读 (Optimistic Reading) —— 无锁！这是 StampedLock 的灵魂
long stamp = lock.tryOptimisticRead(); // 不加锁，仅获取一个 stamp 快照
// ... 读取共享变量到局部变量 ...
if (!lock.validate(stamp)) {           // 验证期间是否有写操作发生
    // stamp 失效，说明数据可能已脏，需要回退到悲观读
}

public class Point {
    private double x, y;                             // 共享的可变状态
    private final StampedLock sl = new StampedLock(); // StampedLock 实例
 
    /**
     * 移动点的坐标（写操作）
     */
    public void move(double deltaX, double deltaY) {
        long stamp = sl.writeLock();                 // 获取写锁（独占）
        try {
            x += deltaX;                             // 修改 x 坐标
            y += deltaY;                             // 修改 y 坐标
        } finally {
            sl.unlockWrite(stamp);                   // 释放写锁，传入 stamp
        }
    }
 
    /**
     * 计算到原点的距离（读操作 —— 使用乐观读策略）
     */
    public double distanceFromOrigin() {
        // ① 尝试乐观读：不加锁，仅获取当前 stamp 快照
        long stamp = sl.tryOptimisticRead();
 
        // ② 将共享变量拷贝到线程栈上的局部变量
        //    这一步必须在 validate 之前完成
        double currentX = x;                         // 读取 x 到局部变量
        double currentY = y;                         // 读取 y 到局部变量
 
        // ③ 验证：在读取期间，是否有其他线程获取了写锁？
        if (!sl.validate(stamp)) {
            // ④ 验证失败！说明 x, y 可能已被修改，数据不一致
            //    回退策略：升级为悲观读锁，重新读取
            stamp = sl.readLock();                   // 获取悲观读锁（阻塞写线程）
            try {
                currentX = x;                        // 重新读取 x
                currentY = y;                        // 重新读取 y
            } finally {
                sl.unlockRead(stamp);                // 释放悲观读锁
            }
        }
 
        // ⑤ 此时 currentX 和 currentY 保证是一致的快照
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

public class InventoryService {
    private final StampedLock sl = new StampedLock();
    private Map<String, Integer> stock = new HashMap<>();  // 库存数据
 
    /**
     * 生成完整库存报表（读操作耗时较长，直接用悲观读）
     */
    public Map<String, Integer> generateReport() {
        long stamp = sl.readLock();                // 获取悲观读锁
        try {
            // 遍历整个库存 Map，耗时操作
            // 在此期间写线程会被阻塞，保证数据快照一致
            Map<String, Integer> snapshot = new HashMap<>();  // 创建快照容器
            for (Map.Entry<String, Integer> entry : stock.entrySet()) {
                snapshot.put(entry.getKey(), entry.getValue());  // 逐条复制
            }
            return snapshot;                       // 返回一致性快照
        } finally {
            sl.unlockRead(stamp);                  // 释放悲观读锁
        }
    }
 
    /**
     * 更新库存（写操作）
     */
    public void updateStock(String item, int quantity) {
        long stamp = sl.writeLock();               // 获取写锁
        try {
            stock.put(item, quantity);             // 更新库存
        } finally {
            sl.unlockWrite(stamp);                 // 释放写锁
        }
    }
}

// ❌ 危险！StampedLock 不可重入，以下代码可能死锁
long stamp1 = sl.readLock();       // 第一次获取读锁 → 成功
long stamp2 = sl.readLock();       // 第二次获取读锁 → 如果此时有写线程在排队，可能永远阻塞！
sl.unlockRead(stamp2);
sl.unlockRead(stamp1);

public class SharedConfig {
    private final StampedLock sl = new StampedLock();
    private volatile String configValue;               // 共享配置
 
    /**
     * 原子性地更新配置（需要先读后写的场景）
     */
    public String updateIfAbsent(String key, String newValue) {
        long stamp = sl.writeLock();                   // 获取独占写锁
        try {
            if (configValue == null) {                 // 先读取当前值
                configValue = newValue;                // 仅在为空时写入
                return newValue;                       // 返回新写入的值
            }
            return configValue;                        // 已有值，返回现有值
        } finally {
            sl.unlockWrite(stamp);                     // 释放写锁
        }
    }
}

StampedLock state (64-bit long) 内部布局示意：
 
 63                             8  7  6         0
 ┌────────────────────────────────┬──┬───────────┐
 │     版本号 (每次写锁释放 +1)     │WB│  读锁计数  │
 │         (高 56 位)              │IT│  (低 7 位) │
 └────────────────────────────────┴──┴───────────┘
                                   │
                          写锁标志位 (第 8 位)
                          0 = 无写锁
                          1 = 写锁被持有

// ❌ 绝对死锁！StampedLock 写锁不可重入
long stamp1 = sl.writeLock();     // 获取写锁 → 成功
long stamp2 = sl.writeLock();     // 再次获取写锁 → 永远阻塞！死锁！

public class CachedData {
    private final StampedLock sl = new StampedLock();
    private Object data;                               // 缓存数据
    private boolean cacheValid;                        // 缓存是否有效
 
    /**
     * 获取数据：优先从缓存读取，缓存失效时重新加载
     * 这是 JDK 官方文档推荐的 StampedLock 经典使用模式
     */
    public Object getData() {
        // ① 先用乐观读尝试
        long stamp = sl.tryOptimisticRead();           // 无锁快照
        Object currentData = data;                     // 拷贝数据到局部变量
        boolean valid = cacheValid;                    // 拷贝缓存标志到局部变量
 
        // ② 验证乐观读
        if (!sl.validate(stamp)) {
            // ③ 乐观读失败 → 升级为悲观读
            stamp = sl.readLock();                     // 获取悲观读锁
            try {
                currentData = data;                    // 重新安全读取
                valid = cacheValid;                    // 重新安全读取
            } finally {
                // 注意：这里不直接释放！因为后面可能需要升级为写锁
                // 但如果缓存有效，就直接返回了，所以需要更精细的控制
            }
        }
 
        // 如果缓存有效，直接返回（如果持有读锁需要先释放）
        if (valid) {
            if (StampedLock.isReadLockStamp(stamp)) {  // Java 10+ 提供的工具方法
                sl.unlockRead(stamp);                  // 释放悲观读锁
            }
            return currentData;                        // 返回缓存数据
        }
 
        // ④ 缓存无效，需要写入新数据
        //    尝试将悲观读锁 → 写锁（锁升级）
        long ws = sl.tryConvertToWriteLock(stamp);     // 尝试原子升级
        if (ws == 0L) {
            // ⑤ 升级失败（可能有其他读线程），只能手动释放读锁再获取写锁
            sl.unlockRead(stamp);                      // 先释放读锁
            ws = sl.writeLock();                       // 再获取写锁（可能阻塞）
        }
        // 现在 ws 是有效的写锁 stamp
        stamp = ws;                                    // 更新 stamp 为写锁的
 
        try {
            data = loadFromDatabase();                 // 从数据库加载新数据
            cacheValid = true;                         // 标记缓存有效
            currentData = data;                        // 更新局部变量
        } finally {
            sl.unlockWrite(stamp);                     // 释放写锁
        }
 
        return currentData;                            // 返回新数据
    }
 
    private Object loadFromDatabase() {
        return new Object();                           // 模拟数据库加载
    }
}

/**
 * 写入数据后立即基于新数据执行读取计算
 * 使用锁降级避免释放写锁后数据被其他写线程覆盖
 */
public double writeAndCompute(double newX, double newY) {
    long stamp = sl.writeLock();                       // 获取写锁
    try {
        x = newX;                                      // 写入新的 x
        y = newY;                                      // 写入新的 y
 
        // 写入完成，但还需要基于新值做计算
        // 降级为读锁：允许其他读线程进入，但保证数据不会被其他写线程修改
        long readStamp = sl.tryConvertToReadLock(stamp);  // 写锁 → 读锁（必定成功）
        if (readStamp != 0L) {
            stamp = readStamp;                         // 更新 stamp 为读锁
        }
        // 此时持有读锁，可以安全读取
        return Math.sqrt(x * x + y * y);              // 基于一致的新值计算
    } finally {
        sl.unlock(stamp);                              // 通用释放方法，根据 stamp 类型自动判断
    }
}

StampedLock sl = new StampedLock();
double x = 0, y = 0;
 
// 线程 A：读取坐标
public double read() {
    long stamp = sl.tryOptimisticRead();
    if (!sl.validate(stamp)) {
        stamp = sl.readLock();
        try {
            double cx = x;
            double cy = y;
            return Math.sqrt(cx * cx + cy * cy);
        } finally {
            sl.unlockRead(stamp);
        }
    }
    return Math.sqrt(x * x + y * y);
}

// ==================== 传统方式：synchronized + wait/notify ====================
public class OldStyleBuffer {
    private final Object lock = new Object();  // 监视器对象，充当锁
    private int count = 0;                     // 缓冲区当前元素数量
 
    public void produce() throws InterruptedException {
        synchronized (lock) {                  // 获取内置锁
            while (count >= 10) {              // 缓冲区满，需要等待
                lock.wait();                   // 释放锁，进入 lock 对象的【唯一】等待队列
            }
            count++;                           // 放入一个元素
            lock.notifyAll();                  // 只能 notifyAll，因为无法区分等待者类型
        }
    }
 
    public void consume() throws InterruptedException {
        synchronized (lock) {                  // 获取内置锁
            while (count <= 0) {               // 缓冲区空，需要等待
                lock.wait();                   // 释放锁，进入 lock 对象的【同一个】等待队列
            }
            count--;                           // 取出一个元素
            lock.notifyAll();                  // 只能 notifyAll，无法精确通知
        }
    }
}
 
// ==================== Condition 方式：Lock + Condition ====================
public class NewStyleBuffer {
    private final ReentrantLock lock = new ReentrantLock();     // 显式锁
    private final Condition notFull = lock.newCondition();      // 条件1：缓冲区不满
    private final Condition notEmpty = lock.newCondition();     // 条件2：缓冲区不空
    private int count = 0;                                      // 缓冲区当前元素数量
 
    public void produce() throws InterruptedException {
        lock.lock();                           // 获取显式锁
        try {
            while (count >= 10) {              // 缓冲区满，需要等待
                notFull.await();               // 释放锁，进入 notFull 的【独立】等待队列
            }
            count++;                           // 放入一个元素
            notEmpty.signal();                 // 精确唤醒 notEmpty 队列中的一个消费者
        } finally {
            lock.unlock();                     // 确保释放锁
        }
    }
 
    public void consume() throws InterruptedException {
        lock.lock();                           // 获取显式锁
        try {
            while (count <= 0) {               // 缓冲区空，需要等待
                notEmpty.await();              // 释放锁，进入 notEmpty 的【独立】等待队列
            }
            count--;                           // 取出一个元素
            notFull.signal();                  // 精确唤醒 notFull 队列中的一个生产者
        } finally {
            lock.unlock();                     // 确保释放锁
        }
    }
}

// ❌ 错误写法：使用 if
if (条件不满足) {
    condition.await();   // 虚假唤醒后直接往下执行，可能出错
}
 
// ✅ 正确写法：使用 while
while (条件不满足) {
    condition.await();   // 虚假唤醒后重新检查条件
}

public interface Condition {
 
    // 1. 基本等待：响应中断，被中断时抛出 InterruptedException
    void await() throws InterruptedException;
 
    // 2. 不可中断等待：即使被中断也不抛异常，唤醒后再设置中断标志
    void awaitUninterruptibly();
 
    // 3. 纳秒级限时等待：返回剩余纳秒数（<=0 表示超时）
    long awaitNanos(long nanosTimeout) throws InterruptedException;
 
    // 4. 带时间单位的限时等待：超时返回 false，被 signal 返回 true
    boolean await(long time, TimeUnit unit) throws InterruptedException;
 
    // 5. 绝对时间等待：等到指定日期时间，超时返回 false
    boolean awaitUntil(Date deadline) throws InterruptedException;
}

lock.lock();                                    // 获取锁
try {
    while (!资源准备就绪) {                       // 循环检查条件
        condition.awaitUninterruptibly();         // 不响应中断，坚持等待
        // 即使线程在等待期间被 interrupt()，也不会抛异常
        // 唤醒后，中断标志会被保留，可在后续自行检查
    }
    // 条件满足，执行关键操作
} finally {
    lock.unlock();                               // 释放锁
}

lock.lock();                                             // 获取锁
try {
    long remaining = TimeUnit.SECONDS.toNanos(5);        // 总计最多等待 5 秒
    while (!条件满足) {                                    // 循环检查
        if (remaining <= 0L) {                            // 检查是否已经超时
            throw new TimeoutException("等待超时");        // 超时，放弃
        }
        remaining = condition.awaitNanos(remaining);      // 等待剩余时间
        // 每次循环 remaining 都在递减，保证总等待时间不超过 5 秒
    }
} finally {
    lock.unlock();                                        // 释放锁
}

ReentrantLock lock = new ReentrantLock();       // 可重入锁
Condition condition = lock.newCondition();       // 条件变量
 
lock.lock();         // state = 1，第一次获取
lock.lock();         // state = 2，重入
lock.lock();         // state = 3，再次重入
 
condition.await();   // 此时 state 必须归零！
// 如果只释放一层（state 变为 2），其他线程永远获取不到锁
// 被唤醒后，state 恢复为 3（保持调用 await 之前的重入深度）

public class SignalDemo {
 
    private static final ReentrantLock lock = new ReentrantLock();       // 显式锁
    private static final Condition condition = lock.newCondition();      // 条件变量
    private static boolean dataReady = false;                           // 共享条件标志
 
    public static void main(String[] args) throws InterruptedException {
        // 等待线程：等待数据就绪
        Thread waiter = new Thread(() -> {
            lock.lock();                                                // 获取锁
            try {
                System.out.println("[Waiter] 获取锁，检查条件...");
                while (!dataReady) {                                    // 循环检查条件
                    System.out.println("[Waiter] 数据未就绪，调用 await()");
                    condition.await();                                  // 释放锁，进入等待
                    System.out.println("[Waiter] 被唤醒，重新检查条件...");
                }
                System.out.println("[Waiter] 数据已就绪，继续执行业务逻辑");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();                     // 恢复中断标志
            } finally {
                lock.unlock();                                          // 释放锁
            }
        }, "waiter-thread");
 
        // 通知线程：准备数据后通知
        Thread notifier = new Thread(() -> {
            lock.lock();                                                // 获取锁
            try {
                System.out.println("[Notifier] 获取锁，开始准备数据...");
                Thread.sleep(2000);                                     // 模拟数据准备耗时
                dataReady = true;                                       // 修改条件标志
                System.out.println("[Notifier] 数据准备完毕，调用 signal()");
                condition.signal();                                     // 唤醒等待队列中的一个线程
                System.out.println("[Notifier] signal() 调用完成，即将释放锁");
                // 注意：signal() 后不会立刻让出锁！
                // waiter 要等到 notifier 释放锁后才能真正从 await() 返回
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();                     // 恢复中断标志
            } finally {
                lock.unlock();                                          // 释放锁
                System.out.println("[Notifier] 锁已释放");
            }
        }, "notifier-thread");
 
        waiter.start();                                                 // 启动等待线程
        Thread.sleep(100);                                              // 确保 waiter 先运行
        notifier.start();                                               // 启动通知线程
    }
}

// 场景：多种不同条件混在一个 Condition 中（不推荐，但有时难以避免）
lock.lock();
try {
    // 线程A等待 x > 5
    while (x <= 5) condition.await();
 
    // 线程B等待 y > 10
    while (y <= 10) condition.await();
 
    // 当 x 和 y 都发生变化时，必须 signalAll()
    // 因为 signal() 可能只唤醒线程A，而线程B永远睡着
} finally {
    lock.unlock();
}

// signalAll 的典型用法
lock.lock();                              // 获取锁
try {
    // 执行某个导致状态变化的操作
    sharedState = newValue;               // 修改共享状态
    condition.signalAll();                // 唤醒所有等待该条件的线程
    // 所有被唤醒的线程会在 Sync Queue 中排队
    // 逐个获取锁后重新检查各自的条件
} finally {
    lock.unlock();                        // 释放锁
}

// 内存模型概览
//
// ReentrantLock (内含一个 AQS Sync 实例)
//    │
//    ├── AQS Sync Queue (双向链表，唯一)
//    │     HEAD ⟷ Node(ThreadX) ⟷ Node(ThreadY) ⟷ TAIL
//    │
//    ├── Condition_1 (notFull)
//    │     firstWaiter → Node(ThreadA) → Node(ThreadB) → null
//    │
//    └── Condition_2 (notEmpty)
//          firstWaiter → Node(ThreadC) → Node(ThreadD) → Node(ThreadE) → null

// AQS.Node 内部结构简化展示
// static final class Node {
//     volatile int waitStatus;     // 节点状态：CONDITION / SIGNAL / CANCELLED / PROPAGATE
//     volatile Node prev;          // Sync Queue 中的前驱指针
//     volatile Node next;          // Sync Queue 中的后继指针
//     Node nextWaiter;             // Condition Queue 中的下一个等待者
//     volatile Thread thread;      // 绑定的线程
// }

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * 基于 ReentrantLock + Condition 的有界阻塞队列
 * 实现了经典的生产者-消费者模式
 * 
 * @param <E> 元素类型
 */
public class BoundedBlockingQueue<E> {
 
    private final Object[] items;         // 底层存储数组（环形缓冲区）
    private int putIndex;                 // 下一个生产元素的存放位置
    private int takeIndex;                // 下一个消费元素的取出位置
    private int count;                    // 当前缓冲区中的元素数量
 
    private final ReentrantLock lock;     // 主锁，保护所有对共享状态的访问
    private final Condition notFull;      // 条件变量：缓冲区不满（生产者在此等待）
    private final Condition notEmpty;     // 条件变量：缓冲区不空（消费者在此等待）
 
    /**
     * 构造函数：初始化指定容量的有界队列
     * @param capacity 队列容量，必须大于 0
     */
    public BoundedBlockingQueue(int capacity) {
        if (capacity <= 0) {                              // 参数校验
            throw new IllegalArgumentException("容量必须大于0");
        }
        this.items = new Object[capacity];                // 分配存储空间
        this.lock = new ReentrantLock();                  // 创建可重入锁
        this.notFull = lock.newCondition();               // 从锁派生"不满"条件
        this.notEmpty = lock.newCondition();              // 从锁派生"不空"条件
    }
 
    /**
     * 生产方法：向队列放入一个元素
     * 如果队列已满，当前线程将阻塞等待，直到有空间
     * 
     * @param element 要放入的元素
     * @throws InterruptedException 如果等待过程中被中断
     */
    public void put(E element) throws InterruptedException {
        if (element == null) {                            // 不允许 null 元素
            throw new NullPointerException("不允许放入 null");
        }
        lock.lock();                                      // 获取锁
        try {
            // 【关键】使用 while 循环检查条件，防止虚假唤醒
            while (count == items.length) {               // 如果缓冲区已满
                System.out.println(Thread.currentThread().getName()
                    + " 缓冲区已满，等待 notFull...");
                notFull.await();                           // 释放锁，进入 notFull 等待队列
                // 被唤醒后会重新获取锁，然后回到 while 继续检查
            }
 
            items[putIndex] = element;                    // 将元素放入环形缓冲区的当前位置
            putIndex++;                                   // 移动写指针
            if (putIndex == items.length) {               // 如果到达数组末尾
                putIndex = 0;                             // 回绕到数组起始位置（环形）
            }
            count++;                                      // 元素总数 +1
 
            System.out.println(Thread.currentThread().getName()
                + " 放入: " + element + ", 当前数量: " + count);
 
            notEmpty.signal();                            // 精确唤醒 notEmpty 队列中的一个消费者
            // 此时消费者被从 Condition Queue 转移到 Sync Queue
            // 它需要等到本方法释放锁后才能真正获取锁
        } finally {
            lock.unlock();                                // 释放锁（finally 保证一定释放）
        }
    }
 
    /**
     * 消费方法：从队列取出一个元素
     * 如果队列为空，当前线程将阻塞等待，直到有元素
     * 
     * @return 取出的元素
     * @throws InterruptedException 如果等待过程中被中断
     */
    @SuppressWarnings("unchecked")
    public E take() throws InterruptedException {
        lock.lock();                                      // 获取锁
        try {
            // 【关键】使用 while 循环检查条件，防止虚假唤醒
            while (count == 0) {                          // 如果缓冲区为空
                System.out.println(Thread.currentThread().getName()
                    + " 缓冲区为空，等待 notEmpty...");
                notEmpty.await();                          // 释放锁，进入 notEmpty 等待队列
                // 被唤醒后会重新获取锁，然后回到 while 继续检查
            }
 
            E element = (E) items[takeIndex];             // 从环形缓冲区取出元素
            items[takeIndex] = null;                      // 清除引用，帮助 GC
            takeIndex++;                                  // 移动读指针
            if (takeIndex == items.length) {              // 如果到达数组末尾
                takeIndex = 0;                            // 回绕到数组起始位置（环形）
            }
            count--;                                      // 元素总数 -1
 
            System.out.println(Thread.currentThread().getName()
                + " 取出: " + element + ", 当前数量: " + count);
 
            notFull.signal();                             // 精确唤醒 notFull 队列中的一个生产者
            // 此时生产者被从 Condition Queue 转移到 Sync Queue
            // 它需要等到本方法释放锁后才能真正获取锁
 
            return element;                               // 返回取出的元素
        } finally {
            lock.unlock();                                // 释放锁
        }
    }
 
    /**
     * 获取当前队列中的元素数量（线程安全）
     */
    public int size() {
        lock.lock();                                      // 获取锁
        try {
            return count;                                 // 返回当前元素数量
        } finally {
            lock.unlock();                                // 释放锁
        }
    }
}

public class ProducerConsumerDemo {
 
    public static void main(String[] args) {
        // 创建容量为 3 的有界阻塞队列
        BoundedBlockingQueue<Integer> queue = new BoundedBlockingQueue<>(3);
 
        // 启动 2 个生产者线程
        for (int i = 1; i <= 2; i++) {
            final int producerId = i;                     // 生产者编号
            new Thread(() -> {
                try {
                    for (int j = 1; j <= 5; j++) {        // 每个生产者生产 5 个元素
                        int item = producerId * 100 + j;  // 生成唯一标识的元素
                        queue.put(item);                  // 放入队列（可能阻塞）
                        Thread.sleep(100);                // 模拟生产耗时
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();    // 恢复中断标志
                }
            }, "Producer-" + i).start();
        }
 
        // 启动 3 个消费者线程
        for (int i = 1; i <= 3; i++) {
            new Thread(() -> {
                try {
                    while (true) {                        // 消费者不断消费
                        Integer item = queue.take();      // 从队列取出（可能阻塞）
                        Thread.sleep(300);                // 模拟消费耗时（消费较慢）
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();    // 恢复中断标志
                }
            }, "Consumer-" + i).start();
        }
    }
}

// 环形缓冲区示意（容量 = 5）
//
// 初始状态:
//   items: [ null, null, null, null, null ]
//           ^putIndex=0
//           ^takeIndex=0
//   count = 0
//
// put(A), put(B), put(C):
//   items: [  A,    B,    C,   null, null ]
//                          ^putIndex=3
//           ^takeIndex=0
//   count = 3
//
// take() → A, take() → B:
//   items: [ null, null,  C,   null, null ]
//                          ^putIndex=3
//                          ^takeIndex=2
//   count = 1
//
// put(D), put(E), put(F):  ← putIndex 回绕！
//   items: [  F,   null,  C,    D,    E  ]
//               ^putIndex=1
//                          ^takeIndex=2
//   count = 4

public E take() throws InterruptedException {
    lock.lock();
    try {
        if (count == 0) {          // ← 此处改为 if
            notEmpty.await();
        }
        E e = (E) items[takeIndex];
        // ... 省略后续逻辑
    } finally {
        lock.unlock();
    }
}

// state 拆分示意（AQS 内部逻辑）
// ┌──────────────────┬──────────────────┐
// │   高16位 (读锁)    │   低16位 (写锁)    │
// │  shared count     │  exclusive count  │
// └──────────────────┴──────────────────┘
//
// 读锁数量 = state >>> 16           (无符号右移，取高16位)
// 写锁重入 = state & 0x0000FFFF     (掩码取低16位)

ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = rwl.readLock();
ReentrantReadWriteLock.WriteLock writeLock = rwl.writeLock();
 
// 线程 A 执行以下代码
readLock.lock();       // 第1步：先获取读锁
try {
    writeLock.lock();  // 第2步：尝试获取写锁（锁升级）
    try {
        // 写操作...
    } finally {
        writeLock.unlock();
    }
} finally {
    readLock.unlock();
}

StampedLock sl = new StampedLock();
 
// 读取操作
long stamp = sl.tryOptimisticRead();
int currentX = this.x;
int currentY = this.y;
// 直接使用 currentX 和 currentY，未做 validate
return Math.sqrt(currentX * currentX + currentY * currentY);