Lock体系——ReentrantLock ⭐⭐⭐

// Lock 接口定义在 java.util.concurrent.locks 包下
// 它提供了比 synchronized 更灵活的锁操作
public interface Lock {
    void lock();                                    // 阻塞式获取锁
    void unlock();                                  // 释放锁
    boolean tryLock();                              // 非阻塞式尝试获取锁
    boolean tryLock(long time, TimeUnit unit)        // 带超时的尝试获取锁
            throws InterruptedException;
    void lockInterruptibly()                        // 可响应中断的获取锁
            throws InterruptedException;
    Condition newCondition();                       // 创建条件变量
}

// 演示 lock() 的基本使用模式
public class LockDemo {
    // 创建一个 ReentrantLock 实例（Lock 接口的最常用实现）
    private final Lock lock = new ReentrantLock();
    // 共享资源：一个简单的计数器
    private int count = 0;
 
    public void increment() {
        // 获取锁——如果锁不可用，当前线程将阻塞在此处
        lock.lock();
        try {
            // 临界区代码：只有持有锁的线程才能执行到这里
            count++;
            // 可以安全地读写共享变量，不用担心竞态条件
            System.out.println(Thread.currentThread().getName()
                    + " -> count = " + count);
        } finally {
            // 无论临界区代码是否抛出异常，都必须释放锁
            // 这是 Lock 与 synchronized 的关键区别之一
            lock.unlock();
        }
    }
}

// 演示 "重入" 与 "配对释放"
public class ReentrantUnlockDemo {
    private final Lock lock = new ReentrantLock();
 
    public void outerMethod() {
        lock.lock();           // state: 0 -> 1，第一次获取锁
        try {
            System.out.println("进入外层方法");
            innerMethod();     // 在持有锁的情况下调用另一个需要同一把锁的方法
        } finally {
            lock.unlock();     // state: 1 -> 0，释放第一层，锁真正被释放
        }
    }
 
    public void innerMethod() {
        lock.lock();           // state: 1 -> 2，同一线程再次获取（重入）
        try {
            System.out.println("进入内层方法");
            // 如果这里抛出异常，finally 保证内层的 unlock 一定会执行
        } finally {
            lock.unlock();     // state: 2 -> 1，释放第二层，但锁仍被持有
        }
    }
}

Thread-A 调用链                      AQS state 变化
─────────────────────────────────────────────────────
outerMethod() → lock.lock()          state: 0 → 1   (Thread-A 持有锁)
  │
  ├─ innerMethod() → lock.lock()     state: 1 → 2   (重入, Thread-A 仍持有)
  │    │
  │    └─ lock.unlock()              state: 2 → 1   (退出内层, 锁未释放)
  │
  └─ lock.unlock()                   state: 1 → 0   (退出外层, 锁真正释放)
                                                      ↓
                                     唤醒等待队列中的下一个线程

// 使用 tryLock() 避免死锁的经典模式
public class DeadlockAvoidanceDemo {
    private final Lock lockA = new ReentrantLock(); // 第一把锁
    private final Lock lockB = new ReentrantLock(); // 第二把锁
 
    public void transferSafely() {
        // 无限重试，直到同时获取两把锁
        while (true) {
            boolean gotA = false; // 记录是否获取到 lockA
            boolean gotB = false; // 记录是否获取到 lockB
            try {
                gotA = lockA.tryLock(); // 非阻塞地尝试获取 lockA
                gotB = lockB.tryLock(); // 非阻塞地尝试获取 lockB
 
                if (gotA && gotB) {
                    // 两把锁都拿到了，安全地执行临界区操作
                    System.out.println("成功获取两把锁，执行转账操作");
                    return; // 操作完成，退出循环
                }
                // 如果只拿到了一把，或者都没拿到，会走到 finally 释放已持有的锁
            } finally {
                // 释放已经获取到的锁，避免占着一把锁等另一把
                if (gotA) lockA.unlock();
                if (gotB) lockB.unlock();
            }
            // 短暂让出 CPU，避免活锁（两个线程同步地拿锁又放锁）
            // 实际项目中可以使用随机退避（Random Backoff）策略
            Thread.yield();
        }
    }
}

// 演示带超时的锁获取——典型的资源池访问模式
public class TimeoutLockDemo {
    private final Lock lock = new ReentrantLock();
 
    /**
     * 尝试在指定时间内获取锁并执行操作
     * @return true 表示操作成功执行, false 表示因超时而放弃
     */
    public boolean performAction() throws InterruptedException {
        // 等待最多 3 秒来获取锁
        // 如果在 3 秒内获取到锁, 返回 true 并进入临界区
        // 如果 3 秒后仍未获取到, 返回 false, 线程不再等待
        if (lock.tryLock(3, TimeUnit.SECONDS)) {
            try {
                // 成功获取到锁, 执行临界区操作
                System.out.println("获取锁成功，正在执行操作...");
                Thread.sleep(1000); // 模拟耗时操作
                return true;        // 操作成功
            } finally {
                lock.unlock();      // 确保释放锁
            }
        } else {
            // 超时未获取到锁，执行降级/补偿逻辑
            System.out.println("获取锁超时，执行降级策略...");
            return false;           // 通知调用方操作未执行
        }
    }
}

// 演示 lockInterruptibly() 响应中断的能力
public class InterruptibleLockDemo {
    private final Lock lock = new ReentrantLock();
 
    /**
     * 可中断地获取锁执行操作
     * 如果等待过程中线程被中断, 会抛出 InterruptedException
     */
    public void cancellableTask() throws InterruptedException {
        System.out.println(Thread.currentThread().getName()
                + ": 尝试以可中断方式获取锁...");
 
        // 与 lock() 不同，lockInterruptibly() 可以响应中断
        // 如果线程在等待锁时被中断，将抛出 InterruptedException
        lock.lockInterruptibly();
        try {
            // 进入临界区
            System.out.println(Thread.currentThread().getName()
                    + ": 获取锁成功，执行任务...");
            Thread.sleep(5000); // 模拟长耗时操作
        } finally {
            lock.unlock(); // 无论如何都要释放锁
            System.out.println(Thread.currentThread().getName()
                    + ": 已释放锁");
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        InterruptibleLockDemo demo = new InterruptibleLockDemo();
 
        // 主线程先获取锁，让子线程需要等待
        demo.lock.lock();
 
        // 启动子线程——它会在 lockInterruptibly() 处等待
        Thread worker = new Thread(() -> {
            try {
                demo.cancellableTask();
            } catch (InterruptedException e) {
                // 捕获中断异常，线程可以正常退出
                System.out.println(Thread.currentThread().getName()
                        + ": 等待锁时被中断，任务取消！");
            }
        }, "Worker");
 
        worker.start();              // 启动工作线程
        Thread.sleep(1000);          // 让工作线程进入等待状态
        worker.interrupt();          // 中断工作线程
        Thread.sleep(500);           // 等待中断处理完成
        demo.lock.unlock();          // 主线程释放锁
    }
}

Worker: 尝试以可中断方式获取锁...
Worker: 等待锁时被中断，任务取消！

// 使用 Lock + Condition 实现线程安全的有界缓冲区
public class BoundedBuffer<T> {
    private final Lock lock = new ReentrantLock();     // 唯一的一把锁
    private final Condition notFull = lock.newCondition();  // 条件1: 缓冲区未满
    private final Condition notEmpty = lock.newCondition(); // 条件2: 缓冲区非空
 
    private final Object[] items;   // 内部数组存储元素
    private int putIndex;           // 下一个写入位置
    private int takeIndex;          // 下一个读取位置
    private int count;              // 当前元素数量
 
    public BoundedBuffer(int capacity) {
        items = new Object[capacity]; // 初始化指定容量的缓冲区
    }
 
    /**
     * 生产者放入元素——如果缓冲区满了就等待
     */
    public void put(T item) throws InterruptedException {
        lock.lock();                 // 获取锁
        try {
            // 如果缓冲区已满, 在 notFull 条件上等待
            // 用 while 而不是 if, 防止虚假唤醒(spurious wakeup)
            while (count == items.length) {
                notFull.await();     // 释放锁并等待, 直到被 signal 唤醒
            }
            // 缓冲区未满, 放入元素
            items[putIndex] = item;
            // 环形数组: 写指针到末尾后回到起点
            if (++putIndex == items.length) putIndex = 0;
            count++;                 // 元素数量加 1
            notEmpty.signal();       // 精准唤醒: 只通知在 notEmpty 上等待的消费者
        } finally {
            lock.unlock();           // 释放锁
        }
    }
 
    /**
     * 消费者取出元素——如果缓冲区空了就等待
     */
    @SuppressWarnings("unchecked")
    public T take() throws InterruptedException {
        lock.lock();                 // 获取锁
        try {
            // 如果缓冲区为空, 在 notEmpty 条件上等待
            while (count == 0) {
                notEmpty.await();    // 释放锁并等待, 直到被 signal 唤醒
            }
            // 缓冲区非空, 取出元素
            T item = (T) items[takeIndex];
            items[takeIndex] = null; // 帮助 GC, 清除引用
            // 环形数组: 读指针到末尾后回到起点
            if (++takeIndex == items.length) takeIndex = 0;
            count--;                 // 元素数量减 1
            notFull.signal();        // 精准唤醒: 只通知在 notFull 上等待的生产者
            return item;             // 返回取出的元素
        } finally {
            lock.unlock();           // 释放锁
        }
    }
}

// ===== 反例：危险的写法 =====
ReentrantLock lock = new ReentrantLock(); // 创建一把可重入锁
 
lock.lock();           // 获取锁
doSomething();         // 执行业务逻辑 —— 如果这里抛出异常...
lock.unlock();         // ...这一行永远不会执行！锁泄漏！

import java.util.concurrent.locks.ReentrantLock;
 
public class Counter {
 
    private int count = 0;                              // 共享可变状态
    private final ReentrantLock lock = new ReentrantLock(); // 守护该状态的锁（声明为 final 防止引用被篡改）
 
    public void increment() {
        lock.lock();             // 第一步：获取锁（阻塞直到成功）
        try {                    // 第二步：紧跟 try 块
            count++;             // 第三步：在 try 内执行所有临界区逻辑
        } finally {
            lock.unlock();       // 第四步：在 finally 中无条件释放锁
        }
    }
 
    public int getCount() {
        lock.lock();             // 读操作同样需要加锁以保证可见性
        try {
            return count;        // 读取共享状态
        } finally {
            lock.unlock();       // 读完即释放
        }
    }
}

// ===== 反例：lock() 放进了 try 块 =====
try {
    lock.lock();         // 如果 lock() 本身抛出异常（极罕见但理论存在）
    doSomething();
} finally {
    lock.unlock();       // 这里会对一把"没有成功加锁"的锁调用 unlock()
                         // 抛出 IllegalMonitorStateException！
}

// ===== 正例：标准写法 =====
lock.lock();             // 在 try 外部获取锁
try {
    // 只有 lock() 成功返回后，执行流才会到达这里
    doSomething();       // 临界区代码
} finally {
    lock.unlock();       // 此时一定持有锁，unlock() 安全调用
}

public class ReentrantDemo {
 
    private final ReentrantLock lock = new ReentrantLock();
 
    public void outer() {
        lock.lock();                     // hold count = 1
        try {
            System.out.println("outer: hold count = " + lock.getHoldCount()); // 输出 1
            inner();                     // 调用另一个需要同一把锁的方法
        } finally {
            lock.unlock();               // hold count 减回 1 → 0，锁真正释放
        }
    }
 
    public void inner() {
        lock.lock();                     // hold count = 2（同一线程再次获取，不会阻塞）
        try {
            System.out.println("inner: hold count = " + lock.getHoldCount()); // 输出 2
        } finally {
            lock.unlock();               // hold count = 1（减 1，但锁尚未释放）
        }
    }
 
    public static void main(String[] args) {
        ReentrantDemo demo = new ReentrantDemo();
        demo.outer();
        // 输出:
        // outer: hold count = 1
        // inner: hold count = 2
    }
}

线程 T1 执行流程:
 
outer()                     inner()
  │                           │
  ├─ lock()                   │
  │  state: 0 → 1             │
  │  owner: null → T1         │
  │                           │
  │──────── 调用 inner() ──────►│
  │                           ├─ lock()
  │                           │  state: 1 → 2 (重入!)
  │                           │  owner: T1 (不变)
  │                           │
  │                           ├─ unlock()
  │                           │  state: 2 → 1
  │                           │  owner: T1 (仍持有)
  │◄─────── inner()返回 ───────│
  │
  ├─ unlock()
  │  state: 1 → 0
  │  owner: T1 → null  ← 锁真正释放！
  │
  ▼ 其他等待线程可以竞争了

// synchronized：JVM 保证自动释放
public synchronized void doWork() {
    // 进入方法时自动获取 this 对象的 monitor
    riskyOperation();    // 即使这里抛出异常...
    // 退出方法时（无论正常 return 还是异常抛出）自动释放 monitor
}

// ReentrantLock：你的锁，你负责
public void doWork() {
    lock.lock();
    try {
        riskyOperation();    // 如果这里抛出异常
    } finally {
        lock.unlock();       // 必须由你显式调用 unlock()
    }
    // 如果忘了 finally 块中的 unlock()，锁就永远回不来了
}

public class LockLeakDisaster {
 
    private final ReentrantLock lock = new ReentrantLock();
    private List<String> dataList = new ArrayList<>();
 
    // ===== 反例：忘记 finally 释放锁 =====
    public void addData(String data) {
        lock.lock();                          // 获取锁
        
        // 假设某次调用时 data 为 null
        if (data.length() > 100) {            // NullPointerException！
            data = data.substring(0, 100);    // 不会执行
        }
        dataList.add(data);                   // 不会执行
        
        lock.unlock();                        // 不会执行 —— 锁泄漏！
    }
 
    // 此后所有线程调用 addData() 都会在 lock.lock() 处永久阻塞
    // 系统表现：线程池耗尽 → 请求堆积 → 服务不可用
}

// ===== 反例：多个 return 路径中忘记释放 =====
public String getData(String key) {
    lock.lock();
    
    if (key == null) {
        return null;              // 提前返回 —— 锁没释放！
    }
    
    try {
        String value = map.get(key);
        return value;
    } finally {
        lock.unlock();
    }
}

// ===== 正例：所有逻辑都在 try 块内 =====
public String getData(String key) {
    lock.lock();                   // 获取锁
    try {
        if (key == null) {
            return null;           // 这个 return 会先执行 finally 再返回
        }
        return map.get(key);       // 正常返回，同样先执行 finally
    } finally {
        lock.unlock();             // 无论哪条路径退出，锁都会被释放
    }
}

public class SafeExecutor {
 
    private final ReentrantLock lock = new ReentrantLock();
 
    /**
     * 在锁保护下执行任意操作（利用函数式接口封装 try-finally）
     * @param action 需要在临界区内执行的操作
     */
    public void executeWithLock(Runnable action) {
        lock.lock();                  // 获取锁
        try {
            action.run();             // 执行传入的业务逻辑
        } finally {
            lock.unlock();            // 确保释放
        }
    }
 
    /**
     * 在锁保护下执行有返回值的操作
     * @param supplier 需要在临界区内执行的计算
     * @return 计算结果
     */
    public <T> T computeWithLock(Supplier<T> supplier) {
        lock.lock();                  // 获取锁
        try {
            return supplier.get();    // 执行传入的计算并返回结果
        } finally {
            lock.unlock();            // 确保释放
        }
    }
}
 
// 使用方式 —— 调用者完全不需要关心锁的获取与释放
SafeExecutor executor = new SafeExecutor();
 
executor.executeWithLock(() -> {
    // 临界区逻辑
    sharedList.add("item");
});
 
String result = executor.computeWithLock(() -> {
    // 临界区计算
    return sharedMap.get("key");
});

public class BuggyService {
    private ReentrantLock lock = new ReentrantLock();
    private int balance = 1000;
 
    public void withdraw(int amount) {
        try {
            lock.lock();
            if (balance < amount) {
                throw new RuntimeException("余额不足");
            }
            balance -= amount;
        } finally {
            lock.unlock();
        }
    }
}

/**
 * 演示 synchronized 无法响应中断 vs ReentrantLock 可中断获取
 */
public class InterruptibleComparison {
 
    // ==================== synchronized 版本 ====================
    private static final Object monitorLock = new Object(); // 内置锁对象
 
    /**
     * synchronized 版本：线程在等待锁时不会响应中断
     */
    static void synchronizedDemo() throws InterruptedException {
        // 先让主线程持有锁，模拟锁被长期占用
        synchronized (monitorLock) {
            Thread waitingThread = new Thread(() -> {
                System.out.println("[synchronized] 尝试获取锁...");
                // 这里会进入 BLOCKED 状态，且无法被中断唤醒
                synchronized (monitorLock) {
                    System.out.println("[synchronized] 成功获取锁"); // 永远不会执行到
                }
            }, "syn-waiting");
 
            waitingThread.start();              // 启动等待线程
            Thread.sleep(1000);                 // 等待子线程进入 BLOCKED 状态
            waitingThread.interrupt();          // 尝试中断——无效！
            System.out.println("[synchronized] 已调用 interrupt(), 但线程状态: "
                    + waitingThread.getState()); // 输出: BLOCKED，不是 INTERRUPTED
            // waitingThread 将一直阻塞在 synchronized 上，无法脱身
        }
    }
 
    // ==================== ReentrantLock 版本 ====================
    private static final ReentrantLock reentrantLock = new ReentrantLock(); // 显式锁
 
    /**
     * ReentrantLock 版本：线程在等待锁时能响应中断
     */
    static void reentrantLockDemo() throws InterruptedException {
        reentrantLock.lock();  // 主线程先持有锁
        try {
            Thread waitingThread = new Thread(() -> {
                System.out.println("[ReentrantLock] 尝试可中断获取锁...");
                try {
                    // lockInterruptibly() 在等待过程中可以响应中断
                    reentrantLock.lockInterruptibly();
                    // 如果成功获取锁才会执行到这里
                    try {
                        System.out.println("[ReentrantLock] 成功获取锁");
                    } finally {
                        reentrantLock.unlock(); // 安全释放
                    }
                } catch (InterruptedException e) {
                    // 中断被成功响应！线程可以优雅退出
                    System.out.println("[ReentrantLock] 等待被中断，优雅退出！");
                }
            }, "lock-waiting");
 
            waitingThread.start();              // 启动等待线程
            Thread.sleep(1000);                 // 等待子线程进入 WAITING 状态
            waitingThread.interrupt();          // 发送中断信号——有效！
            waitingThread.join();               // 等待子线程结束
            System.out.println("[ReentrantLock] 等待线程已正常终止");
        } finally {
            reentrantLock.unlock();             // 主线程释放锁
        }
    }
}

/**
 * 演示超时获取锁的实际应用场景：
 * 模拟转账操作，同时获取两个账户的锁，避免死锁
 */
public class TimeoutLockTransfer {
 
    static class Account {
        private final String name;                                  // 账户名
        private final ReentrantLock lock = new ReentrantLock();     // 每个账户一把锁
        private int balance;                                        // 余额
 
        Account(String name, int balance) {                         // 构造方法
            this.name = name;
            this.balance = balance;
        }
    }
 
    /**
     * 使用 tryLock(timeout) 安全地同时获取两把锁
     * 如果在超时时间内无法同时获取，则释放已持有的锁并重试
     */
    static boolean transfer(Account from, Account to, int amount)
            throws InterruptedException {
 
        // 设定总的超时时间为 5 秒
        long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5);
 
        while (true) {
            // 尝试获取第一把锁，最多等待剩余时间
            if (from.lock.tryLock(calculateRemaining(deadline), TimeUnit.NANOSECONDS)) {
                try {
                    // 尝试获取第二把锁，最多等待剩余时间
                    if (to.lock.tryLock(calculateRemaining(deadline), TimeUnit.NANOSECONDS)) {
                        try {
                            // 两把锁都成功获取，执行转账
                            if (from.balance < amount) {            // 余额不足检查
                                System.out.println("余额不足！");
                                return false;
                            }
                            from.balance -= amount;                 // 扣款
                            to.balance += amount;                   // 入账
                            System.out.printf("转账成功: %s -> %s, 金额: %d%n",
                                    from.name, to.name, amount);
                            return true;                            // 转账成功
                        } finally {
                            to.lock.unlock();                       // 释放第二把锁
                        }
                    }
                    // 没拿到第二把锁，释放第一把，进入下一轮重试
                } finally {
                    from.lock.unlock();                             // 释放第一把锁
                }
            }
 
            // 检查是否已超过总截止时间
            if (System.nanoTime() >= deadline) {
                System.out.println("转账超时，无法获取所有必要的锁");
                return false;                                       // 超时放弃
            }
 
            // 短暂随机退避，降低活锁概率
            Thread.sleep(ThreadLocalRandom.current().nextInt(10, 50));
        }
    }
 
    /**
     * 计算距离截止时间还剩多少纳秒
     */
    private static long calculateRemaining(long deadline) {
        return Math.max(deadline - System.nanoTime(), 0);           // 最小值为0
    }
}

/**
 * 演示 tryLock 非阻塞获取的实际应用：
 * 缓存刷新场景——只需要一个线程去刷新，其他线程直接返回旧值
 */
public class CacheRefreshWithTryLock {
 
    private final ReentrantLock refreshLock = new ReentrantLock(); // 刷新专用锁
    private volatile Map<String, Object> cache = new HashMap<>();  // 缓存数据
    private volatile long lastRefreshTime = 0;                     // 上次刷新时间
 
    /**
     * 获取缓存数据，如果缓存过期则尝试刷新
     * 使用 tryLock 保证只有一个线程执行刷新，其余线程直接返回旧值
     */
    public Object get(String key) {
        Object value = cache.get(key);                              // 从缓存中获取
 
        // 检查缓存是否过期（超过 60 秒视为过期）
        if (System.currentTimeMillis() - lastRefreshTime > 60_000) {
            // tryLock()：非阻塞尝试获取锁
            if (refreshLock.tryLock()) {
                try {
                    // Double-check：防止多个线程同时检测到过期后重复刷新
                    if (System.currentTimeMillis() - lastRefreshTime > 60_000) {
                        System.out.println(Thread.currentThread().getName()
                                + " 正在刷新缓存...");
                        cache = loadFromDatabase();                 // 从数据库加载新数据
                        lastRefreshTime = System.currentTimeMillis(); // 更新刷新时间
                        value = cache.get(key);                     // 使用最新数据
                    }
                } finally {
                    refreshLock.unlock();                            // 释放刷新锁
                }
            } else {
                // 获取锁失败，说明其他线程正在刷新，直接返回旧缓存值
                System.out.println(Thread.currentThread().getName()
                        + " 缓存正在被其他线程刷新，返回旧值");
            }
        }
 
        return value;                                               // 返回缓存值
    }
 
    private Map<String, Object> loadFromDatabase() {                // 模拟数据库加载
        // ... 实际查询逻辑
        return new HashMap<>();
    }
}

// 非公平锁（默认）——新到达的线程可以插队
ReentrantLock unfairLock = new ReentrantLock();         // 等价于 new ReentrantLock(false)
 
// 公平锁——严格按照 FIFO 等待队列顺序获取锁
ReentrantLock fairLock = new ReentrantLock(true);       // fair = true

/**
 * 演示公平锁 vs 非公平锁的行为差异
 */
public class FairnessComparison {
 
    /**
     * 启动多个线程反复获取同一把锁，观察获取顺序
     */
    static void testFairness(boolean fair) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock(fair);    // 根据参数创建公平/非公平锁
        List<String> acquisitionOrder = new CopyOnWriteArrayList<>(); // 线程安全的记录列表
 
        // 创建 5 个线程，每个线程获取锁 3 次
        Runnable task = () -> {
            for (int i = 0; i < 3; i++) {
                lock.lock();                             // 获取锁
                try {
                    String record = Thread.currentThread().getName(); // 记录哪个线程获取到了
                    acquisitionOrder.add(record);
                    Thread.sleep(10);                    // 短暂持有锁，让其他线程排队
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    lock.unlock();                       // 释放锁
                }
            }
        };
 
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++) {
            threads[i] = new Thread(task, "T" + i);      // 创建线程 T0-T4
        }
        for (Thread t : threads) t.start();               // 启动所有线程
        for (Thread t : threads) t.join();                // 等待所有线程结束
 
        System.out.printf("公平=%s, 获取顺序: %s%n", fair, acquisitionOrder);
    }
 
    public static void main(String[] args) throws InterruptedException {
        testFairness(true);    // 公平锁：输出接近 T0,T1,T2,T3,T4,T0,T1,T2,T3,T4,...
        testFairness(false);   // 非公平锁：输出可能是 T0,T0,T0,T1,T1,T1,...（同一线程连续获取）
    }
}

/**
 * 使用 synchronized + wait/notify 的有界队列
 * 缺点：只有一个等待队列，notifyAll 会唤醒所有线程（包括不相关的）
 */
class BoundedQueueSync<E> {
    private final Object[] items;           // 存储元素的数组
    private int head, tail, count;          // 队首指针、队尾指针、元素计数
 
    BoundedQueueSync(int capacity) {
        items = new Object[capacity];       // 初始化固定容量数组
    }
 
    public synchronized void put(E item) throws InterruptedException {
        while (count == items.length) {     // 队列满了
            wait();                         // 生产者等待——但等在跟消费者同一个队列里！
        }
        items[tail] = item;                 // 放入元素
        tail = (tail + 1) % items.length;   // 环形队列指针前移
        count++;                            // 元素计数 +1
        notifyAll();                        // 必须用 notifyAll！因为要唤醒消费者
                                            // 但同时也唤醒了其他正在等待的生产者（浪费）
    }
 
    @SuppressWarnings("unchecked")
    public synchronized E take() throws InterruptedException {
        while (count == 0) {                // 队列空了
            wait();                         // 消费者等待——同一个队列
        }
        E item = (E) items[head];           // 取出元素
        items[head] = null;                 // 帮助 GC
        head = (head + 1) % items.length;   // 环形队列指针前移
        count--;                            // 元素计数 -1
        notifyAll();                        // 必须用 notifyAll！唤醒生产者
                                            // 但同时也唤醒了其他正在等待的消费者（浪费）
        return item;
    }
}

/**
 * 使用 ReentrantLock + 多 Condition 的有界队列
 * 优点：生产者和消费者在不同的条件队列上等待，互不干扰
 */
class BoundedQueueLock<E> {
    private final Object[] items;                           // 存储元素的数组
    private int head, tail, count;                          // 队首、队尾、计数
 
    private final ReentrantLock lock = new ReentrantLock(); // 一把锁
    private final Condition notFull = lock.newCondition();  // 条件1：队列未满（生产者等待）
    private final Condition notEmpty = lock.newCondition(); // 条件2：队列非空（消费者等待）
 
    BoundedQueueLock(int capacity) {
        items = new Object[capacity];                       // 初始化
    }
 
    public void put(E item) throws InterruptedException {
        lock.lock();                                        // 显式加锁
        try {
            while (count == items.length) {                 // 队列满了
                notFull.await();                            // 生产者在 notFull 条件上等待
            }
            items[tail] = item;                             // 放入元素
            tail = (tail + 1) % items.length;               // 环形指针前移
            count++;                                        // 计数 +1
            notEmpty.signal();                              // 精准唤醒一个在 notEmpty 上等待的消费者
                                                            // 不会影响在 notFull 上等待的其他生产者！
        } finally {
            lock.unlock();                                  // 释放锁
        }
    }
 
    @SuppressWarnings("unchecked")
    public E take() throws InterruptedException {
        lock.lock();                                        // 显式加锁
        try {
            while (count == 0) {                            // 队列空了
                notEmpty.await();                           // 消费者在 notEmpty 条件上等待
            }
            E item = (E) items[head];                       // 取出元素
            items[head] = null;                             // 帮助 GC
            head = (head + 1) % items.length;               // 环形指针前移
            count--;                                        // 计数 -1
            notFull.signal();                               // 精准唤醒一个在 notFull 上等待的生产者
            return item;
        } finally {
            lock.unlock();                                  // 释放锁
        }
    }
}

/**
 * 错误示范 vs 正确示范：ReentrantLock 的释放
 */
public class ManualReleaseDemo {
 
    private final ReentrantLock lock = new ReentrantLock();
 
    // ==================== 错误写法 1：忘记 unlock ====================
    void wrong1() {
        lock.lock();                         // 获取锁
        doSomething();                       // 如果这里抛出异常...
        lock.unlock();                       // 这行永远不会执行！锁泄露！
    }
 
    // ==================== 错误写法 2：lock 在 try 内部 ====================
    void wrong2() {
        try {
            lock.lock();                     // 如果 lock() 本身就失败了（理论上极罕见）
            doSomething();
        } finally {
            lock.unlock();                   // 可能 unlock 一个没有成功 lock 的锁
                                             // 抛出 IllegalMonitorStateException
        }
    }
 
    // ==================== 正确写法：lock 在 try 外部 ====================
    void correct() {
        lock.lock();                         // 在 try 块之外获取锁
        try {                                // 紧跟 try
            doSomething();                   // 业务逻辑
        } finally {
            lock.unlock();                   // finally 中释放，百分百执行
        }
    }
 
    // ==================== 正确写法：tryLock 版本 ====================
    void correctTryLock() {
        if (lock.tryLock()) {                // 尝试获取锁
            try {                            // 获取成功才进入 try
                doSomething();
            } finally {
                lock.unlock();               // 获取成功了才需要释放
            }
        } else {
            handleFallback();                // 获取失败走降级逻辑
        }
    }
 
    private void doSomething() { /* ... */ }
    private void handleFallback() { /* ... */ }
}

// 传入 true 表示创建公平锁
ReentrantLock fairLock = new ReentrantLock(true);

// --- FairSync 的 tryAcquire 方法（简化版）---
protected final boolean tryAcquire(int acquires) {
    // 获取当前线程引用
    final Thread current = Thread.currentThread();
    // 读取锁的状态：0 表示无人持有，>0 表示已被持有（值为重入次数）
    int c = getState();
 
    if (c == 0) {
        // ★ 公平锁的关键：先检查队列中是否有等待更久的线程
        // hasQueuedPredecessors() 返回 true 表示"有前驱节点在排队"
        if (!hasQueuedPredecessors() &&
            // 只有队列中没有前驱时，才尝试 CAS 抢锁
            compareAndSetState(0, acquires)) {
            // CAS 成功，将当前线程设为锁的独占持有者
            setExclusiveOwnerThread(current);
            return true; // 获取成功
        }
    }
    // 如果锁已被持有，检查是不是当前线程自己持有的（处理重入）
    else if (current == getExclusiveOwnerThread()) {
        // 重入：状态值累加
        int nextc = c + acquires;
        if (nextc < 0) // int 溢出检查
            throw new Error("Maximum lock count exceeded");
        // 因为是当前线程持有锁，不存在竞争，直接 set 即可，无需 CAS
        setState(nextc);
        return true; // 重入成功
    }
    // 既不是无锁状态可抢，也不是重入，返回 false → 线程将被加入等待队列
    return false;
}

// --- AQS 的 hasQueuedPredecessors 方法 ---
public final boolean hasQueuedPredecessors() {
    Node h = head; // 读取队列头节点（哨兵节点）
    Node s;        // 头节点的后继（即"真正排在第一位"的等待线程）
    // 条件1：h != t 说明队列中有等待节点（队列不为空）
    // 条件2：(s = h.next) == null 说明有线程正在入队但尚未完成（中间态）
    //        或者 s.thread != Thread.currentThread() 说明排在最前面的不是自己
    return h != tail &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

// 以下两种写法等价，都创建非公平锁
ReentrantLock unfairLock1 = new ReentrantLock();       // 默认非公平
ReentrantLock unfairLock2 = new ReentrantLock(false);  // 显式非公平

// --- NonfairSync 的 lock 方法（JDK 8 版本，更直观）---
final void lock() {
    // ★ 非公平的第一次插队机会：连队列都不看，直接 CAS 抢锁
    if (compareAndSetState(0, 1))
        // 抢到了！直接设为独占持有者
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 没抢到，走标准 AQS acquire 流程
        acquire(1);
}
 
// --- NonfairSync 的 tryAcquire 方法 ---
protected final boolean tryAcquire(int acquires) {
    // 调用 Sync 父类中的 nonfairTryAcquire
    return nonfairTryAcquire(acquires);
}
 
// --- Sync（父类）的 nonfairTryAcquire 方法 ---
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // ★ 非公平的第二次插队机会：不调用 hasQueuedPredecessors()
        // 直接 CAS，不管队列里有没有人等着
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true; // 插队成功！
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        // 重入逻辑，与公平锁完全一致
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

┌──────────────────────────────────────────────────────────────────┐
│              公平锁 vs 非公平锁：代码级差异                        │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  公平锁 FairSync.tryAcquire:                                     │
│     if (c == 0) {                                                │
│         if (!hasQueuedPredecessors()    ← ★ 先检查队列            │
│             && compareAndSetState(...)) { ... }                  │
│     }                                                            │
│                                                                  │
│  非公平锁 nonfairTryAcquire:                                     │
│     if (c == 0) {                                                │
│         if (compareAndSetState(...))   ← ★ 直接 CAS，不查队列     │
│             { ... }                                              │
│     }                                                            │
│                                                                  │
│  差异仅仅在于：有没有调用 hasQueuedPredecessors()                  │
└──────────────────────────────────────────────────────────────────┘

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.CountDownLatch;
 
public class FairVsUnfairBenchmark {
 
    // 共享计数器
    private static int counter = 0;
    // 分别创建公平锁和非公平锁
    private static final ReentrantLock fairLock = new ReentrantLock(true);   // 公平
    private static final ReentrantLock unfairLock = new ReentrantLock(false); // 非公平
 
    // 线程数量
    private static final int THREAD_COUNT = 20;
    // 每个线程对 counter 累加的次数
    private static final int INCREMENT_PER_THREAD = 100_000;
 
    public static void main(String[] args) throws InterruptedException {
        // 分别测试公平锁和非公平锁的耗时
        long fairTime = runBenchmark(fairLock, "公平锁");
        long unfairTime = runBenchmark(unfairLock, "非公平锁");
 
        // 输出性能对比结果
        System.out.println("===== 性能对比 =====");
        System.out.printf("公平锁耗时:   %d ms%n", fairTime);
        System.out.printf("非公平锁耗时: %d ms%n", unfairTime);
        System.out.printf("非公平锁快了: %.2f 倍%n", (double) fairTime / unfairTime);
    }
 
    /**
     * 执行基准测试：多线程竞争同一把锁进行累加
     * @param lock 待测试的锁实例
     * @param label 锁的描述标签
     * @return 测试耗时（毫秒）
     */
    private static long runBenchmark(ReentrantLock lock, String label)
            throws InterruptedException {
 
        // 重置计数器
        counter = 0;
        // 使用 CountDownLatch 等待所有线程完成
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
 
        // 记录开始时间
        long start = System.currentTimeMillis();
 
        // 创建并启动所有工作线程
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                // 每个线程执行 INCREMENT_PER_THREAD 次加锁-累加-解锁
                for (int j = 0; j < INCREMENT_PER_THREAD; j++) {
                    lock.lock();        // 获取锁
                    try {
                        counter++;      // 临界区操作：简单累加
                    } finally {
                        lock.unlock();  // 释放锁（必须在 finally 中）
                    }
                }
                latch.countDown();      // 当前线程完成，计数减一
            }).start();
        }
 
        // 主线程等待所有工作线程完成
        latch.await();
        // 记录结束时间
        long elapsed = System.currentTimeMillis() - start;
 
        // 输出结果验证正确性
        System.out.printf("[%s] counter=%d, 耗时=%dms%n", label, counter, elapsed);
        return elapsed;
    }
}

[公平锁] counter=2000000, 耗时=3854ms
[非公平锁] counter=2000000, 耗时=387ms
===== 性能对比 =====
公平锁耗时:   3854 ms
非公平锁耗时: 387 ms
非公平锁快了: 9.96 倍

public class StarvationDemo {
 
    // 使用非公平锁
    private static final ReentrantLock lock = new ReentrantLock(false);
 
    public static void main(String[] args) throws InterruptedException {
 
        // 启动一个"可怜的"长期等待线程
        Thread starvedThread = new Thread(() -> {
            System.out.println("[Starved] 尝试获取锁...");
            lock.lock();    // 这个线程可能很久才能拿到锁
            try {
                System.out.println("[Starved] 终于获得了锁！");
            } finally {
                lock.unlock();
            }
        }, "Starved-Thread");
 
        // 先让主线程持有锁
        lock.lock();
        // 启动"可怜线程"，它会进入等待队列
        starvedThread.start();
        // 给点时间让 starvedThread 确实进入队列
        Thread.sleep(100);
        // 主线程释放锁
        lock.unlock();
 
        // 紧接着不断启动"插队线程"，模拟持续的高竞争
        for (int i = 0; i < 1000; i++) {
            final int id = i;
            new Thread(() -> {
                lock.lock();    // 非公平模式下，这些线程可能每次都比 starvedThread 先抢到
                try {
                    // 模拟极短的临界区操作
                    // 在 starvedThread 被唤醒并完成上下文切换之前，
                    // 这些新线程可能已经完成了 lock-unlock 循环
                } finally {
                    lock.unlock();
                }
            }, "Intruder-" + id).start();
        }
 
        // 等待 starvedThread 结束
        starvedThread.join(5000);  // 最多等 5 秒
        if (starvedThread.isAlive()) {
            System.out.println("[WARNING] Starved-Thread 疑似饥饿，5秒内未获得锁！");
        }
    }
}

// 最佳实践：将锁的公平性做成可配置项
public class OrderService {
 
    private final ReentrantLock lock;
 
    /**
     * 通过配置决定锁的公平性策略
     * @param fair 是否使用公平锁
     */
    public OrderService(boolean fair) {
        // 生产环境可通过配置文件或启动参数控制
        this.lock = new ReentrantLock(fair);
    }
 
    public void processOrder(Order order) {
        lock.lock(); // 根据初始化时的配置，自动使用公平/非公平策略
        try {
            // 处理订单的临界区逻辑
            // ...
        } finally {
            lock.unlock();
        }
    }
}

ReentrantLock lock = new ReentrantLock(); // 默认非公平

// ReentrantLock 的标准使用范式（必须严格遵守）
ReentrantLock lock = new ReentrantLock();  // 创建锁实例
lock.lock();                                // 在 try 块外获取锁
try {
    // 临界区代码：访问共享资源
} finally {
    lock.unlock();                          // 在 finally 中无条件释放
}

// ========== 1. 基础互斥 ==========
ReentrantLock lock = new ReentrantLock();          // 默认非公平锁
lock.lock();                                        // 阻塞获取
try {
    // 临界区
} finally {
    lock.unlock();                                  // 必须释放
}
 
// ========== 2. 非阻塞尝试 ==========
if (lock.tryLock()) {                               // 立即返回, 不阻塞
    try {
        // 获取成功, 执行逻辑
    } finally {
        lock.unlock();                              // 成功获取后才释放
    }
} else {
    // 获取失败, 执行降级逻辑
}
 
// ========== 3. 超时等待 ==========
if (lock.tryLock(3, TimeUnit.SECONDS)) {            // 最多等 3 秒
    try {
        // 在超时前获取成功
    } finally {
        lock.unlock();
    }
} else {
    // 超时未获取到, 执行兜底逻辑
}
 
// ========== 4. 可中断获取 ==========
try {
    lock.lockInterruptibly();                       // 等待中可被中断
    try {
        // 获取成功
    } finally {
        lock.unlock();
    }
} catch (InterruptedException e) {
    // 等待过程中被中断, 进行清理
    Thread.currentThread().interrupt();             // 恢复中断标志
}
 
// ========== 5. 条件变量协作 ==========
Condition notEmpty = lock.newCondition();            // 创建条件: 非空
Condition notFull  = lock.newCondition();            // 创建条件: 非满
lock.lock();
try {
    while (queue.isEmpty()) {
        notEmpty.await();                           // 队列空时等待 "非空" 条件
    }
    Object item = queue.poll();                     // 取出元素
    notFull.signal();                               // 通知 "非满" 条件的等待者
} finally {
    lock.unlock();
}
 
// ========== 6. 公平锁 ==========
ReentrantLock fairLock = new ReentrantLock(true);   // 传入 true 启用公平模式