wait/notify机制 ⭐⭐

// 以下三个方法定义在 java.lang.Object 中
// 因此任何 Java 对象都可以充当"通信媒介"
 
public class Object {
    // 使当前线程进入 WAITING 状态，直到被 notify/notifyAll 唤醒或被中断
    public final void wait() throws InterruptedException;
 
    // 带超时的等待，超时后自动唤醒，单位毫秒
    public final void wait(long timeoutMillis) throws InterruptedException;
 
    // 更精细的超时控制，追加纳秒精度
    public final void wait(long timeoutMillis, int nanos) throws InterruptedException;
 
    // 随机唤醒一个正在该对象上 wait 的线程
    public final void notify();
 
    // 唤醒所有正在该对象上 wait 的线程
    public final void notifyAll();
}

public class WrongUsageDemo {
    public static void main(String[] args) {
        Object lock = new Object(); // 创建一个普通对象作为锁
 
        try {
            lock.wait(); // ❌ 当前线程没有持有 lock 的监视器锁
        } catch (IllegalMonitorStateException e) {
            // 运行时必定抛出此异常
            System.out.println("异常: " + e.getClass().getSimpleName());
            // 输出: 异常: IllegalMonitorStateException
        } catch (InterruptedException e) {
            // wait 声明了 InterruptedException，必须捕获
            Thread.currentThread().interrupt();
        }
    }
}

public class CorrectUsageDemo {
    // 专门用作锁的对象（推荐使用 private final，防止外部干扰）
    private static final Object lock = new Object();
    // 共享条件标志
    private static boolean dataReady = false;
 
    public static void main(String[] args) {
        // ===== 消费者线程：等待数据就绪 =====
        Thread consumer = new Thread(() -> {
            synchronized (lock) {                    // 第1步：获取 lock 的监视器锁
                while (!dataReady) {                 // 第2步：检查条件（循环检查，后文详解）
                    try {
                        System.out.println("[消费者] 数据未就绪，进入等待...");
                        lock.wait();                 // 第3步：释放锁，进入 Wait Set
                        // 被唤醒后会重新获取锁，然后从这里继续执行
                        System.out.println("[消费者] 被唤醒，重新检查条件...");
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt(); // 恢复中断标志
                        return;                             // 退出线程
                    }
                }
                // 条件满足后执行业务逻辑
                System.out.println("[消费者] 数据已就绪，开始消费！");
            } // 离开 synchronized 块，自动释放锁
        }, "Consumer");
 
        // ===== 生产者线程：准备数据并通知 =====
        Thread producer = new Thread(() -> {
            try {
                Thread.sleep(1000);                  // 模拟数据准备耗时
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
            synchronized (lock) {                    // 第1步：获取 lock 的监视器锁
                dataReady = true;                    // 第2步：修改共享条件
                System.out.println("[生产者] 数据已准备好，发出通知");
                lock.notify();                       // 第3步：唤醒 Wait Set 中的一个线程
                // ⚠️ 注意：notify() 执行后，锁并没有立刻释放！
                System.out.println("[生产者] notify已调用，但仍持有锁");
            } // 第4步：离开 synchronized 块，锁才真正释放
            System.out.println("[生产者] 已退出 synchronized 块");
        }, "Producer");
 
        consumer.start(); // 启动消费者
        producer.start(); // 启动生产者
    }
}

public class WaitReleasesLockDemo {
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
        // ===== 线程 A：先获取锁，然后 wait =====
        Thread threadA = new Thread(() -> {
            synchronized (lock) {                          // A 获取锁
                System.out.println("[A] 持有锁，准备 wait");
                System.out.println("[A] wait 前时间: " + System.currentTimeMillis());
                try {
                    lock.wait();                           // A 释放锁，进入等待
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("[A] 被唤醒，重新持有锁"); // 从 wait 返回意味着重新拿到了锁
            }
        }, "Thread-A");
 
        // ===== 线程 B：尝试获取同一把锁 =====
        Thread threadB = new Thread(() -> {
            try {
                Thread.sleep(200);                         // 确保 A 先运行
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            synchronized (lock) {                          // 如果 A 的 wait 没释放锁，B 会卡在这里
                System.out.println("[B] 成功获取锁！证明 A 的 wait() 释放了锁");
                System.out.println("[B] 准备唤醒 A");
                lock.notify();                             // 唤醒 A
                System.out.println("[B] notify 后仍持有锁，继续执行...");
            } // B 离开 synchronized，释放锁，A 才能从 wait 返回
            System.out.println("[B] 已释放锁");
        }, "Thread-B");
 
        threadA.start();                                   // 启动 A
        threadB.start();                                   // 启动 B
        threadA.join();                                    // 主线程等待 A 结束
        threadB.join();                                    // 主线程等待 B 结束
    }
}

// ⚠️ 危险代码：演示多重锁下 wait 的行为
private static final Object lockA = new Object();
private static final Object lockB = new Object();
 
// 线程 1
synchronized (lockA) {              // 获取 lockA
    synchronized (lockB) {          // 获取 lockB
        lockA.wait();               // 只释放 lockA，lockB 仍被持有！
        // 其他需要 lockB 的线程将被阻塞
    }
}

public class NotifyDoesNotReleaseLock {
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
        // ===== 等待线程 =====
        Thread waiter = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("[waiter] 进入等待: " + System.currentTimeMillis());
                    lock.wait();                           // 释放锁，进入 Wait Set
                    // 从 wait 返回 = 重新获得了锁
                    System.out.println("[waiter] 从 wait 返回: " + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "Waiter");
 
        waiter.start();
        Thread.sleep(200); // 确保 waiter 先进入 wait
 
        // ===== 通知线程 =====
        Thread notifier = new Thread(() -> {
            synchronized (lock) {                          // 获取锁
                System.out.println("[notifier] 获取锁，调用 notify: " + System.currentTimeMillis());
                lock.notify();                             // 唤醒 waiter（但不释放锁！）
 
                // 故意在 notify 之后做耗时操作，证明锁还在自己手里
                System.out.println("[notifier] notify 后开始耗时操作...");
                try {
                    Thread.sleep(2000);                    // 持锁睡眠 2 秒
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("[notifier] 耗时操作完成，即将释放锁: " + System.currentTimeMillis());
            } // 这里才释放锁！waiter 才能从 wait() 返回
        }, "Notifier");
 
        notifier.start();
        waiter.join();
        notifier.join();
    }
}

// ✅ 推荐：notify 放在最后
synchronized (lock) {
    // ... 所有业务逻辑先执行完 ...
    dataReady = true;
    lock.notify(); // 紧接着就退出 synchronized，被唤醒线程能更快拿到锁
}
 
// ⚠️ 不推荐：notify 之后还有大量代码
synchronized (lock) {
    dataReady = true;
    lock.notify();        // 唤醒了对方
    doHeavyComputation(); // 但对方要等这段代码跑完才能拿到锁
    doMoreWork();
}

public class Quiz {
    private static final Object mon = new Object();
    public static void main(String[] args) throws Exception {
        Thread t = new Thread(() -> {
            synchronized (mon) {
                try {
                    mon.wait();
                } catch (InterruptedException e) { }
                System.out.print("A");
            }
            System.out.print("B");
        });
        t.start();
        Thread.sleep(500);
        synchronized (mon) {
            mon.notify();
            System.out.print("C");
        }
        t.join();
        System.out.print("D");
    }
}

public class BrokenBuffer {
    private final Queue<String> queue = new LinkedList<>(); // 共享缓冲区
    private final int capacity = 10;                        // 最大容量
 
    // 消费方法 —— 存在严重Bug
    public synchronized String consume() throws InterruptedException {
        // ❌ 致命错误：使用 if 而非 while
        // 如果发生虚假唤醒，线程会跳过这个 if，
        // 直接执行 queue.poll()，此时队列可能仍为空！
        if (queue.isEmpty()) {
            wait(); // 队列为空，等待生产者通知
        }
        // 虚假唤醒后到达此处，queue 仍然为空
        // poll() 返回 null，后续代码可能抛出 NullPointerException
        return queue.poll();
    }
 
    // 生产方法
    public synchronized void produce(String item) throws InterruptedException {
        if (queue.size() == capacity) {
            wait(); // 队列满，等待消费者通知
        }
        queue.offer(item);       // 放入数据
        notifyAll();             // 通知所有等待的消费者
    }
}

public class CorrectBuffer {
    private final Queue<String> queue = new LinkedList<>(); // 共享缓冲区
    private final int capacity = 10;                        // 最大容量
 
    // 消费方法 —— 安全正确
    public synchronized String consume() throws InterruptedException {
        // ✅ 正确：使用 while 循环持续检查条件
        // 即使发生虚假唤醒，循环会重新检查 queue.isEmpty()
        // 条件不满足就继续 wait()，绝不会"溜过去"
        while (queue.isEmpty()) {
            wait(); // 每次从 wait 返回后，都会重新检查条件
        }
        // 能执行到此处，100% 保证 queue 不为空
        return queue.poll();
    }
 
    // 生产方法 —— 安全正确
    public synchronized void produce(String item) throws InterruptedException {
        // ✅ 同样使用 while 循环
        while (queue.size() == capacity) {
            wait(); // 队列满则持续等待
        }
        queue.offer(item);       // 放入数据
        notifyAll();             // 通知所有等待的消费者
    }
}

public synchronized String consume() throws InterruptedException {
    while (queue.isEmpty()) {   // 第一次检查：true → 进入循环
        wait();                 // 被 notifyAll 唤醒，重新获取锁后返回
                                // 回到 while 条件检查 ← 这是关键！
    }                           // 如果队列仍然为空 → 继续 wait()
                                // 如果队列不为空 → 跳出循环，安全消费
    return queue.poll();
}

C2: while(queue.isEmpty()) → true → wait()
    ... 被唤醒，重新获取锁 ...
C2: while(queue.isEmpty()) → true（数据已被 C1 取走）→ 继续 wait()
    ... 等待下一次生产者投递数据 ...
C2: while(queue.isEmpty()) → false → 跳出循环
C2: queue.poll() → 安全取到数据 ✅

// 场景：线程池任务调度
// 多个工作线程等待任务队列中出现新任务
public class ThreadPool {
    private final List<Runnable> taskQueue = new ArrayList<>(); // 任务队列
    private volatile boolean isShutdown = false;                // 关闭标志
 
    // 工作线程的核心循环
    public void workerLoop() throws InterruptedException {
        while (!isShutdown) {                  // 外层循环：持续工作直到关闭
            Runnable task;
            synchronized (taskQueue) {
                // ✅ 必须用 while：
                // 1. 可能虚假唤醒
                // 2. 可能被 notifyAll 唤醒但任务已被其他工人抢走
                // 3. 可能被 shutdown 的 notifyAll 唤醒（需要重新检查条件）
                while (taskQueue.isEmpty() && !isShutdown) {
                    taskQueue.wait();          // 无任务且未关闭，等待
                }
                if (isShutdown && taskQueue.isEmpty()) {
                    return;                    // 关闭且无剩余任务，退出
                }
                task = taskQueue.remove(0);    // 取出一个任务
            }
            task.run();                        // 在 synchronized 外执行任务
        }
    }
}

// ===== wait() 标准使用范式 (Canonical Form) =====
 
synchronized (lockObject) {           // 第1步：获取对象的监视器锁
    // 第2步：在 while 循环中检查等待条件
    // 绝对不能用 if！
    while (!conditionIsSatisfied()) {  // 条件不满足时循环等待
        lockObject.wait();             // 第3步：原子地释放锁并等待
                                       // 被唤醒后重新获取锁
                                       // 然后回到 while 条件检查
    }
    // 第4步：条件满足，安全地执行业务逻辑
    doSomething();                     // 此时持有锁且条件100%满足
}

┌─────────────────────────────────────────────────────────────────┐
│                   wait() 防御循环模型                             │
│                                                                 │
│   synchronized (lock) {                                         │
│       ┌──────────────────────────────────────┐                  │
│       │  while (!condition) {  ◄── 防护墙     │                  │
│       │      lock.wait();                    │                  │
│       │      // 唤醒后回到 while ──┘          │                  │
│       │  }                                   │                  │
│       └──────────────────────────────────────┘                  │
│       // 此处 condition 一定为 true                               │
│       safeAction();                                             │
│   }                                                             │
│                                                                 │
│   防护对象:                                                      │
│     ✓ 虚假唤醒 (Spurious Wakeup)                                 │
│     ✓ 条件被其他线程改变 (Stolen Condition)                       │
│     ✓ 错误的 notify 来源 (Unrelated Notification)                │
└─────────────────────────────────────────────────────────────────┘

// 使用 ReentrantLock + Condition 的等价写法
private final ReentrantLock lock = new ReentrantLock();          // 显式锁
private final Condition notEmpty = lock.newCondition();          // 条件变量：队列非空
private final Condition notFull = lock.newCondition();           // 条件变量：队列未满
private final Queue<String> queue = new LinkedList<>();          // 共享队列
private final int capacity = 10;                                 // 容量上限
 
public String consume() throws InterruptedException {
    lock.lock();                          // 获取显式锁
    try {
        // ✅ 同样必须使用 while 循环
        // Condition.await() 的 Javadoc 同样警告了虚假唤醒
        while (queue.isEmpty()) {
            notEmpty.await();             // 释放锁并等待 notEmpty 信号
        }
        String item = queue.poll();       // 安全取出数据
        notFull.signal();                 // 通知等待 notFull 的生产者
        return item;
    } finally {
        lock.unlock();                    // 确保释放锁
    }
}
 
public void produce(String item) throws InterruptedException {
    lock.lock();                          // 获取显式锁
    try {
        while (queue.size() == capacity) {
            notFull.await();              // 释放锁并等待 notFull 信号
        }
        queue.offer(item);               // 放入数据
        notEmpty.signal();               // 通知等待 notEmpty 的消费者
    } finally {
        lock.unlock();                    // 确保释放锁
    }
}

public synchronized String consume() throws InterruptedException {
    if (queue.isEmpty()) {
        wait();
    }
    return queue.poll();
}

public class NotifyDemo {
 
    // 共享锁对象
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
 
        // 创建 3 个等待线程，它们都会在 lock 上 wait
        for (int i = 1; i <= 3; i++) {
            final int id = i; // 捕获循环变量
            new Thread(() -> {
                synchronized (lock) { // 必须先获取 lock 的监视器锁
                    try {
                        System.out.println("Thread-" + id + " 进入等待...");
                        lock.wait(); // 释放锁并进入 Wait Set
                        // 被唤醒后，重新获取锁，从此处继续执行
                        System.out.println("Thread-" + id + " 被唤醒！");
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt(); // 恢复中断标志
                    }
                }
            }, "Thread-" + i).start(); // 启动线程
        }
 
        // 主线程稍微等待，确保 3 个线程都已进入 wait
        Thread.sleep(500);
 
        synchronized (lock) { // 主线程获取锁
            System.out.println("主线程调用 notify()...");
            lock.notify(); // 只唤醒 Wait Set 中的 1 个线程
            // 注意：此时锁尚未释放，被唤醒的线程还拿不到锁
        } // 退出 synchronized，释放锁 → 被唤醒的线程开始竞争锁
    }
}

Thread-1 进入等待...
Thread-2 进入等待...
Thread-3 进入等待...
主线程调用 notify()...
Thread-3 被唤醒！

public class NotifyAllDemo {
 
    private static final Object lock = new Object(); // 共享锁对象
    private static boolean ready = false;             // 共享条件变量
 
    public static void main(String[] args) throws InterruptedException {
 
        // 创建 3 个工作线程
        for (int i = 1; i <= 3; i++) {
            final int id = i;
            new Thread(() -> {
                synchronized (lock) {
                    // 标准范式：在 while 循环中等待条件
                    while (!ready) { // 每次被唤醒都重新检查条件
                        try {
                            System.out.println("Worker-" + id + " 等待条件...");
                            lock.wait(); // 释放锁，进入 Wait Set
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            return; // 被中断则退出
                        }
                    }
                    // 条件满足，执行业务逻辑
                    System.out.println("Worker-" + id + " 条件满足，开始工作！");
                }
            }, "Worker-" + i).start();
        }
 
        Thread.sleep(500); // 等待所有线程进入 wait
 
        synchronized (lock) {
            ready = true;        // 改变共享条件
            System.out.println("主线程调用 notifyAll()...");
            lock.notifyAll();    // 唤醒 Wait Set 中的所有线程
        } // 释放锁 → 被唤醒的线程们依次竞争锁
    }
}

Worker-1 等待条件...
Worker-2 等待条件...
Worker-3 等待条件...
主线程调用 notifyAll()...
Worker-3 条件满足，开始工作！
Worker-1 条件满足，开始工作！
Worker-2 条件满足，开始工作！

public class BrokenProducerConsumer {
 
    private static final Object lock = new Object(); // 共享锁
    private static final Queue<String> buffer = new LinkedList<>(); // 共享缓冲区
    private static final int CAPACITY = 5; // 缓冲区容量
 
    // --------- 生产者 ---------
    static class Producer implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                // 缓冲区满时，生产者等待
                while (buffer.size() == CAPACITY) {
                    try {
                        lock.wait(); // 进入 Wait Set（等待"缓冲区不满"）
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
                // 生产一条数据
                buffer.add("item");
                System.out.println(Thread.currentThread().getName()
                        + " 生产, 缓冲区大小=" + buffer.size());
                lock.notify(); // 【危险】只唤醒一个线程
            }
        }
    }
 
    // --------- 消费者 ---------
    static class Consumer implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                // 缓冲区空时，消费者等待
                while (buffer.isEmpty()) {
                    try {
                        lock.wait(); // 进入 Wait Set（等待"缓冲区非空"）
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
                // 消费一条数据
                String item = buffer.poll();
                System.out.println(Thread.currentThread().getName()
                        + " 消费, 缓冲区大小=" + buffer.size());
                lock.notify(); // 【危险】只唤醒一个线程
            }
        }
    }
}

假设 Wait Set = { Consumer-A, Consumer-B, Producer-X }
 
Producer-Y 生产了一个 item，调用 notify()
→ JVM 任意选了 Consumer-B？不一定！
→ 如果选中了 Producer-X（它等待"缓冲区不满"），
   Producer-X 醒来发现缓冲区确实不满，于是继续生产
→ Consumer-A 和 Consumer-B 永远不会被唤醒
→ 如果之后没有新的 notify，系统进入"全员等待"的死锁状态

public class CorrectProducerConsumer {
 
    private final Object lock = new Object();          // 监视器锁
    private final Queue<String> buffer = new LinkedList<>(); // 共享缓冲区
    private final int capacity;                        // 缓冲区容量上限
 
    // 构造器：指定缓冲区容量
    public CorrectProducerConsumer(int capacity) {
        this.capacity = capacity;
    }
 
    // --------- 生产方法 ---------
    public void produce(String item) throws InterruptedException {
        synchronized (lock) {                          // 获取监视器锁
            while (buffer.size() == capacity) {        // 【循环检查】缓冲区是否已满
                lock.wait();                           // 满则释放锁，进入 Wait Set
            }
            buffer.add(item);                          // 向缓冲区添加数据
            System.out.println(Thread.currentThread().getName()
                    + " 生产: " + item
                    + ", 缓冲区=" + buffer.size());
            lock.notifyAll();                          // 【notifyAll】唤醒所有等待线程
        }                                              // 退出 synchronized，释放锁
    }
 
    // --------- 消费方法 ---------
    public String consume() throws InterruptedException {
        synchronized (lock) {                          // 获取监视器锁
            while (buffer.isEmpty()) {                 // 【循环检查】缓冲区是否为空
                lock.wait();                           // 空则释放锁，进入 Wait Set
            }
            String item = buffer.poll();               // 从缓冲区取出数据
            System.out.println(Thread.currentThread().getName()
                    + " 消费: " + item
                    + ", 缓冲区=" + buffer.size());
            lock.notifyAll();                          // 【notifyAll】唤醒所有等待线程
            return item;                               // 返回消费到的数据
        }                                              // 退出 synchronized，释放锁
    }
 
    // --------- 测试入口 ---------
    public static void main(String[] args) {
        CorrectProducerConsumer pc = new CorrectProducerConsumer(3);
 
        // 启动 2 个生产者
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++) {         // 每个生产者生产 5 个
                    try {
                        pc.produce("item-" + j);      // 调用生产方法
                        Thread.sleep(50);              // 模拟生产耗时
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            }, "Producer-" + i).start();
        }
 
        // 启动 3 个消费者
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 3; j++) {         // 每个消费者消费 3 个
                    try {
                        pc.consume();                  // 调用消费方法
                        Thread.sleep(80);              // 模拟消费耗时
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            }, "Consumer-" + i).start();
        }
    }
}

while 循环检查  +  notifyAll  +  synchronized
      ↓                ↓              ↓
  防虚假唤醒     防信号丢失      保证可见性与原子性

public class WaitVsSleepLockDemo {
 
    // 共享锁对象
    private static final Object lock = new Object();
 
    public static void main(String[] args) {
        // ========== 场景一：sleep 不释放锁 ==========
        System.out.println("===== sleep 不释放锁演示 =====");
 
        // 线程 A：获取锁后 sleep 3 秒
        Thread sleepThread = new Thread(() -> {
            synchronized (lock) {                              // 获取 lock 的监视器锁
                System.out.println(Thread.currentThread().getName()
                        + " 获得锁, 开始 sleep...");
                try {
                    Thread.sleep(3000);                        // sleep 3秒，但不释放 lock
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()
                        + " sleep 结束, 释放锁");
            }                                                  // 退出 synchronized 才释放锁
        }, "SleepThread");
 
        // 线程 B：尝试获取同一把锁
        Thread competitorA = new Thread(() -> {
            synchronized (lock) {                              // 会阻塞，直到 SleepThread 退出 synchronized
                System.out.println(Thread.currentThread().getName()
                        + " 终于获得了锁！");
            }
        }, "CompetitorA");
 
        sleepThread.start();                                   // 启动 sleep 线程
        try { Thread.sleep(100); } catch (InterruptedException ignored) {} // 确保 sleepThread 先获取锁
        competitorA.start();                                   // 启动竞争线程
 
        // 等待两个线程都结束
        try {
            sleepThread.join();
            competitorA.join();
        } catch (InterruptedException ignored) {}
 
        // ========== 场景二：wait 释放锁 ==========
        System.out.println("\n===== wait 释放锁演示 =====");
 
        // 线程 C：获取锁后 wait
        Thread waitThread = new Thread(() -> {
            synchronized (lock) {                              // 获取 lock 的监视器锁
                System.out.println(Thread.currentThread().getName()
                        + " 获得锁, 开始 wait...");
                try {
                    lock.wait(3000);                           // wait 3秒，立即释放 lock！
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()
                        + " wait 结束 (重新获得锁后才打印此行)");
            }
        }, "WaitThread");
 
        // 线程 D：尝试获取同一把锁
        Thread competitorB = new Thread(() -> {
            synchronized (lock) {                              // wait 释放了锁，所以这里能很快进入
                System.out.println(Thread.currentThread().getName()
                        + " 终于获得了锁！");
            }
        }, "CompetitorB");
 
        waitThread.start();                                    // 启动 wait 线程
        try { Thread.sleep(100); } catch (InterruptedException ignored) {} // 确保 waitThread 先获取锁
        competitorB.start();                                   // 启动竞争线程
 
        try {
            waitThread.join();
            competitorB.join();
        } catch (InterruptedException ignored) {}
    }
}

===== sleep 不释放锁演示 =====
SleepThread 获得锁, 开始 sleep...
SleepThread sleep 结束, 释放锁          ← CompetitorA 等了 3 秒才能进入
CompetitorA 终于获得了锁！
 
===== wait 释放锁演示 =====
WaitThread 获得锁, 开始 wait...
CompetitorB 终于获得了锁！              ← 几乎立刻就获得了锁！
WaitThread wait 结束 (重新获得锁后才打印此行)

Object lock = new Object();         // 一个普通对象即可作为锁
String strLock = "hello";           // String 也可以
int[] arrLock = new int[0];         // 数组也可以
 
// 上述任意对象都可以调用 wait/notify
synchronized (lock) {
    lock.wait();                    // 合法：Object 上定义了 wait()
}

// sleep 是静态方法，作用于当前线程
Thread.sleep(1000);                 // 当前线程休眠 1 秒
 
// 虽然语法上允许通过实例调用，但这是误导性写法（编译器会警告）
Thread t = new Thread();
t.sleep(1000);                      // 实际上仍然是让 "当前线程" sleep，而非 t！

public class SynchronizedRequirementDemo {
 
    private static final Object lock = new Object();
 
    public static void main(String[] args) {
 
        // ====== wait 必须在 synchronized 中 ======
        try {
            lock.wait();                                       // 编译通过，但运行时抛出异常！
        } catch (IllegalMonitorStateException e) {
            System.out.println("抛出 IllegalMonitorStateException: "
                    + e.getMessage());                         // 当前线程不是 lock 的 Monitor Owner
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // 正确做法：先获取 lock 的监视器锁
        synchronized (lock) {                                  // 进入同步块，成为 lock 的 Monitor Owner
            try {
                lock.wait(100);                                // 现在可以安全地 wait
                System.out.println("wait 正常返回");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
 
        // ====== sleep 随时随地都能调用 ======
        try {
            Thread.sleep(100);                                 // 无需 synchronized，直接调用
            System.out.println("sleep 正常返回");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // 在 synchronized 中 sleep 也可以（但通常不推荐）
        synchronized (lock) {
            try {
                Thread.sleep(100);                             // 合法，但 sleep 期间不会释放 lock
                System.out.println("synchronized 中 sleep 正常返回");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// ⚠️ 假设 wait/notify 不需要 synchronized（伪代码，实际不允许）
// 这段代码存在严重的 race condition
 
// 共享状态
boolean conditionMet = false;
 
// ---------- 消费者线程 ----------
if (!conditionMet) {                  // 第1步：检查条件 → 不满足
    // ★ 此时 CPU 切换到生产者线程！
    lock.wait();                      // 第4步：进入 wait，但 notify 已经错过了！永远阻塞！
}
 
// ---------- 生产者线程 ----------
conditionMet = true;                  // 第2步：修改条件
lock.notify();                        // 第3步：发送 notify，但此时消费者还没 wait！→ 信号丢失！

public class Quiz {
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("T1 acquired lock");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {}
                System.out.println("T1 releasing lock");
            }
        });
 
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("T2 acquired lock");
            }
        });
 
        t1.start();
        Thread.sleep(100); // 确保 t1 先启动
        t2.start();
 
        long start = System.currentTimeMillis();
        t1.join();
        t2.join();
        long elapsed = System.currentTimeMillis() - start;
 
        System.out.println("Total time >= 2 seconds? " + (elapsed >= 2000));
    }
}

// ==================== 等待方（Consumer / Waiter） ====================
synchronized (lock) {                    // 第一步：获取对象监视器锁
    while (!condition) {                 // 第二步：在 while 循环中检查条件（防虚假唤醒 + 防条件被篡改）
        lock.wait();                     // 第三步：条件不满足则释放锁并等待
    }
    // 第四步：条件满足，执行业务逻辑     // 被唤醒且重新获得锁后，从这里继续
    doSomething();
}
 
// ==================== 通知方（Producer / Notifier） ====================
synchronized (lock) {                    // 第一步：获取同一个对象的监视器锁
    changeCondition();                   // 第二步：修改共享状态，使条件变为 true
    lock.notifyAll();                    // 第三步：唤醒所有等待线程（推荐 notifyAll）
}                                        // 第四步：退出 synchronized 块，此刻才真正释放锁

public class WaitNotifyQuiz {
 
    private static final Object lock = new Object();
    private static boolean ready = false;
 
    public static void main(String[] args) throws InterruptedException {
 
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                while (!ready) {           // Line A
                    try {
                        System.out.println("T1: waiting");
                        lock.wait();
                        System.out.println("T1: woke up");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("T1: running");
            }
        });
 
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                ready = true;
                System.out.println("T2: notify");
                lock.notify();
                System.out.println("T2: done");
            }
        });
 
        t1.start();
        Thread.sleep(100);   // 确保 T1 先运行
        t2.start();
    }
}