wait 与 notify 详解

import java.util.LinkedList;
import java.util.Queue;

/**
 * 飞翔科技 - 消息队列生产者消费者 wait/notify 实现
 * 
 * 场景：大翔(10001) 生产消息，白歌(10002) 消费消息
 *       队列容量 5，使用 wait/notifyAll 实现线程通信
 */
public class MessageQueueDemo {

    static class MessageQueue {
        private final Queue<String> queue = new LinkedList<>();
        private final int capacity;

        public MessageQueue(int capacity) {
            this.capacity = capacity;
        }

        /**
         * 生产者：大翔发布消息
         * @param message 消息内容
         * @param employeeId 员工工号
         */
        public synchronized void produce(String message, int employeeId) 
                throws InterruptedException {
            // ★ while 循环防止虚假唤醒 — 不能用 if！
            while (queue.size() == capacity) {
                System.out.printf("[生产者-工号%d] 队列已满(%d/%d)，等待消费...\n",
                        employeeId, queue.size(), capacity);
                wait();  // 释放锁，等待消费者唤醒
            }

            queue.offer(message);
            System.out.printf("[生产者-工号%d] 发布: \"%s\" | 队列: %d/%d\n",
                    employeeId, message, queue.size(), capacity);

            // ★ 唤醒所有等待线程 — 包括消费者和可能等待的其他生产者
            notifyAll();
        }

        /**
         * 消费者：白歌消费消息
         * @param employeeId 员工工号
         * @return 消费的消息
         */
        public synchronized String consume(int employeeId) 
                throws InterruptedException {
            // ★ while 循环防止虚假唤醒
            while (queue.isEmpty()) {
                System.out.printf("[消费者-工号%d] 队列为空，等待生产...\n", employeeId);
                wait();  // 释放锁，等待生产者唤醒
            }

            String message = queue.poll();
            System.out.printf("[消费者-工号%d] 消费: \"%s\" | 队列: %d/%d\n",
                    employeeId, message, queue.size(), capacity);

            // ★ 唤醒所有等待线程 — 包括生产者和可能等待的其他消费者
            notifyAll();

            return message;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MessageQueue mq = new MessageQueue(5);
        System.out.println("========== 飞翔科技内部消息系统 ==========\n");

        // 生产者：大翔(10001)
        Thread producer = new Thread(() -> {
            try {
                String[] messages = {
                    "系统维护通知：今晚 22:00 停机",
                    "薪资调整：本月起基本工资 8888.88 元",
                    "团建通知：周末南山烧烤",
                    "安全提醒：请更新登录密码",
                    "新项目立项：智能监控平台 v2.0",
                    "报销通知：本月报销截止 25 日",
                    "培训通知：周五 Java 并发编程培训",
                    "福利通知：下午茶已到茶水间",
                    "会议通知：周一 9:00 全体会议",
                    "年终奖通知：本月发放年终奖"
                };
                for (int i = 0; i < messages.length; i++) {
                    mq.produce(messages[i], 10001);
                    Thread.sleep(200); // 模拟生产间隔
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Producer-大翔");

        // 消费者：白歌(10002)
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    String msg = mq.consume(10002);
                    Thread.sleep(400); // 模拟消费处理耗时
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Consumer-白歌");

        producer.start();
        consumer.start();

        producer.join();
        consumer.join();

        System.out.println("\n========== 所有消息处理完毕 ==========");
    }
}

/**
 * 飞翔科技 - 奇偶数交替打印 wait/notify 实现
 * 
 * 场景：大翔(10001) 打印奇数，白歌(10002) 打印偶数
 *       使用 wait/notify 实现交替输出 1-20
 */
public class OddEvenPrinterDemo {

    // 共享计数器
    private int number = 1;
    private final int max;
    private final Object lock = new Object();

    public OddEvenPrinterDemo(int max) {
        this.max = max;
    }

    /**
     * 大翔打印奇数
     */
    public void printOdd(int employeeId) {
        synchronized (lock) {
            while (number <= max) {
                // ★ while 循环检查条件
                while (number % 2 == 0) {  // 当前是偶数，等待
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }

                if (number > max) break;

                System.out.printf("[工号%d-大翔] 奇数: %d\n", employeeId, number);
                number++;
                lock.notifyAll();  // ★ 唤醒偶数线程
            }
        }
    }

    /**
     * 白歌打印偶数
     */
    public void printEven(int employeeId) {
        synchronized (lock) {
            while (number <= max) {
                // ★ while 循环检查条件
                while (number % 2 == 1) {  // 当前是奇数，等待
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }

                if (number > max) break;

                System.out.printf("[工号%d-白歌] 偶数: %d\n", employeeId, number);
                number++;
                lock.notifyAll();  // ★ 唤醒奇数线程
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        OddEvenPrinterDemo printer = new OddEvenPrinterDemo(20);
        System.out.println("========== 飞翔科技奇偶数交替打印 (1-20) ==========\n");

        // 大翔(10001) — 打印奇数
        Thread oddThread = new Thread(
                () -> printer.printOdd(10001), "Odd-大翔");

        // 白歌(10002) — 打印偶数
        Thread evenThread = new Thread(
                () -> printer.printEven(10002), "Even-白歌");

        oddThread.start();
        evenThread.start();

        oddThread.join();
        evenThread.join();

        System.out.println("\n========== 打印完成，工号10001月薪: 8888.88 ==========");
    }
}

/**
 * 飞翔科技 - wait vs sleep 锁释放行为对比
 */
public class WaitVsSleepDemo {

    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        System.out.println("========== wait vs sleep 锁行为对比 ==========\n");

        // === 测试1：sleep 不释放锁 ===
        System.out.println("--- 测试1: sleep 不释放锁 ---");
        Thread sleepThread = new Thread(() -> {
            synchronized (lock) {
                System.out.println("[sleep线程] 获取锁，开始 sleep 2 秒...");
                try {
                    Thread.sleep(2000); // sleep 不释放锁！
                } catch (InterruptedException e) { }
                System.out.println("[sleep线程] sleep 结束，释放锁");
            }
        }, "SleepThread");

        Thread tryLockThread = new Thread(() -> {
            try { Thread.sleep(200); } catch (InterruptedException e) { }
            System.out.println("[尝试线程] 尝试获取锁...");
            long start = System.currentTimeMillis();
            synchronized (lock) {
                long waited = System.currentTimeMillis() - start;
                System.out.printf("[尝试线程] 获取锁成功！等待了 %d ms\n", waited);
            }
        }, "TryLockThread");

        sleepThread.start();
        tryLockThread.start();
        sleepThread.join();
        tryLockThread.join();

        // === 测试2：wait 释放锁 ===
        System.out.println("\n--- 测试2: wait 释放锁 ---");
        Thread waitThread = new Thread(() -> {
            synchronized (lock) {
                System.out.println("[wait线程] 获取锁，调用 wait()...");
                try {
                    lock.wait(2000); // wait 释放锁！其他线程可以获取
                } catch (InterruptedException e) { }
                System.out.println("[wait线程] wait 返回，释放锁");
            }
        }, "WaitThread");

        Thread tryLockThread2 = new Thread(() -> {
            try { Thread.sleep(200); } catch (InterruptedException e) { }
            System.out.println("[尝试线程2] 尝试获取锁...");
            long start = System.currentTimeMillis();
            synchronized (lock) {
                long waited = System.currentTimeMillis() - start;
                System.out.printf("[尝试线程2] 获取锁成功！等待了 %d ms\n", waited);
            }
        }, "TryLockThread2");

        waitThread.start();
        tryLockThread2.start();
        waitThread.join();
        tryLockThread2.join();

        System.out.println("\n========== 结论 ==========");
        System.out.println("sleep 不释放锁 → 其他线程被阻塞 2 秒");
        System.out.println("wait 释放锁 → 其他线程可以立即获取");
    }
}

// ✗ 错误：不在 synchronized 中调用 wait() → IllegalMonitorStateException
Object lock = new Object();
lock.wait();  // 运行时异常！没有持有锁

// ✓ 正确：必须在 synchronized 块中
synchronized (lock) {
    lock.wait();  // 合法
}

// ✗ 错误：if 只检查一次，虚假唤醒后不重新检查
synchronized (lock) {
    if (queue.isEmpty()) {          // ★ 用 if！
        lock.wait();                 // 虚假唤醒后直接往下执行
    }
    queue.poll();                    // 可能队列仍为空！
}

// ✓ 正确：用 while 循环，每次醒来都重新检查
synchronized (lock) {
    while (queue.isEmpty()) {       // ★ 用 while！
        lock.wait();
    }
    queue.poll();
}

// ✗ 错误：notify 后还持有锁，被唤醒线程无法立即执行
synchronized (lock) {
    queue.offer(data);
    lock.notify();
    // 还在做一些耗时操作...被唤醒的线程必须等待！
    Thread.sleep(5000);  // 糟糕！
}

// ✓ 正确：notify 后尽快释放锁（最小化临界区）
synchronized (lock) {
    queue.offer(data);
    lock.notify();
}  // 立即释放锁

// ✗ 错误：多生产者-多消费者用 notify() 可能唤醒同类型线程
// 场景：2 个生产者都在等"队列未满"，2 个消费者都在等"队列非空"
// notify() 可能唤醒另一个生产者 → 检查队列仍满 → 继续 wait → 信号丢失！

// ✓ 正确：不确定时使用 notifyAll()
synchronized (lock) {
    queue.offer(data);
    lock.notifyAll();  // 唤醒所有等待线程，避免信号丢失
}

// ✓ 标准 wait/notify 模板
synchronized (lock) {
    // 1. while 循环检查条件（防止虚假唤醒）
    while (条件不满足) {
        lock.wait();  // 2. 释放锁，进入等待
    }
    // 3. 条件满足，执行操作
    doSomething();
    // 4. 唤醒其他线程
    lock.notifyAll();  // 5. 优先使用 notifyAll
}

synchronized (lock) {
    while (条件不满足) {  // ★ 每次醒来都重新检查
        lock.wait();
    }
    // 此时条件一定满足
}