---

在Java中使用wait()和notify()方法的方式：

1、wait()： 调用wait()使当前线程等待，直到其他线程调用此对象的notify()或notifyAll()方法。

2、notify()： 唤醒在此对象监视器上等待的单个线程。

3、同步块内使用： wait()和notify()必须在同步块或同步方法内部使用。

4、释放锁： 调用wait()会释放锁，而notify()不会释放锁。

---

📢 外卖催单催早了？wait () 和 notify () 教你给线程 “发暗号”

零、引入

“你这催单功能是用脚写的？商家刚接单就弹‘催单成功’，用户骂我们‘骚扰’，商家骂我们‘添乱’！” 测试小姐姐把电脑屏幕怼到你脸上，订单日志里 “催单触发” 比 “商家接单” 早了 3 秒，红得像你马上要被扣的绩效。

你慌得一批 —— 负责的外卖系统催单模块，逻辑是 “商家 10 秒不接单就自动催”，结果现在线程乱成一锅粥：催单线程和接单线程各跑各的，催单线程没等够时间就瞎触发，接单线程接了单也没告诉催单线程 “别催了”。更要命的是，领导半小时后要听汇报，你上周还拍胸脯说 “线程通信稳得很”。

就在你对着代码抓头发时，隔壁工位的王哥叼着煎饼凑过来：“慌啥？线程之间没‘暗号’能不乱吗？用 wait () 和 notify () 给它们搭个话，比你这‘裸奔线程’靠谱 10 倍！”

一、wait () 和 notify ()：线程间的 “后厨喊号系统”

王哥抹了把嘴角的葱花，用你天天吃的外卖举例子：“你把催单线程当成服务员，接单线程当成后厨，订单就是那碗‘番茄炒蛋’。服务员的活儿是‘等 10 分钟，没好就催’，后厨的活儿是‘做好了喊一声’—— 要是服务员不等人就催，后厨做好了不吱声，这不就是你现在的问题？

“wait () 和 notify () 就是它们的‘暗号’：”

• wait() ：服务员拿到订单后，往后厨门口一坐等，手里的订单（锁）先交出去，不占着茅坑不拉屎；
• notify() ：后厨做好番茄炒蛋，喊一声 “好了”，服务员立马站起来拿订单送餐；
• 核心是 “通信”—— 线程不再各玩各的，能互相 “打招呼”。

他说着点开你的代码，一针见血：“你看你这代码，催单线程和接单线程都抢同一个订单对象，但没规定‘谁等谁’，就像俩没暗号的特工，碰头了都得打起来！”

你的错误代码（线程乱套版）:

public class BadTakeoutDemo {
    // 订单状态：false=未接单，true=已接单
    static boolean isAccepted = false;

    public static void main(String[] args) {
        // 催单线程：10秒没接单就催
        new Thread(() -> {
            try {
                Thread.sleep(10000); // 等10秒
                // 这里大概率出问题：可能接单线程刚改了状态，催单线程没读到
                if (!isAccepted) {
                    System.out.println("催单成功：商家快接单！");
                } else {
                    System.out.println("无需催单：商家已接单");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "催单线程").start();

        // 接单线程：模拟3秒后接单
        new Thread(() -> {
            try {
                Thread.sleep(3000); // 商家3秒后接单
                isAccepted = true;
                System.out.println("商家已接单");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "接单线程").start();
    }
}

“你跑 10 次能有 5 次错的，” 王哥笑，“线程之间没同步，催单线程可能‘看不见’接单线程改的状态，这就是‘线程可见性’坑 —— 就像你给同事发了消息，他没刷新，以为你没发。”

二、正确用法：3 个核心规则 + 完整可运行代码

王哥把煎饼放一边，手把手给你改代码，边改边讲 “铁律”—— 这可是 JVM 的规矩，违反了直接给你抛异常，比领导的脾气还暴。

核心铁律（记牢！不然 JVM 怼哭你）

• 必须在同步块里用：wait () 和 notify () 得拿着 “锁” 说话，锁对象就是你要保护的资源（比如订单），没锁就调用？直接报 IllegalMonitorStateException，相当于没带工牌进公司被保安赶出去。
• 锁对象要一致：调用 wait () 和 notify () 的必须是同一个锁对象，就像服务员和后厨得对着同一个订单喊暗号，你对着 A 订单喊，B 订单的服务员肯定听不见。
• wait () 会释放锁：这是和 sleep () 最大的区别！sleep () 睡的时候抱着锁不放，别人抢不到；wait () 一睡就把锁扔出去，让其他线程能用 —— 就像你占着会议室睡觉，sleep () 是锁门睡，wait () 是开门睡，别人能进来用。

修复后的代码（线程听话版）:

public class GoodTakeoutDemo {
    // 订单对象：作为锁对象，必须是同一个！
    static final Object ORDER_LOCK = new Object();
    // 订单状态：false=未接单，true=已接单
    static boolean isAccepted = false;

    public static void main(String[] args) {
        // 1. 催单线程：等10秒，要么被唤醒（商家接单），要么超时催单
        Thread remindThread = new Thread(() -> {
            // 铁律1：必须在同步块里，锁对象是ORDER_LOCK
            synchronized (ORDER_LOCK) {
                try {
                    System.out.println("催单线程待命：等待商家接单，10秒内不接就催");
                    // 铁律2：锁对象一致，这里用ORDER_LOCK调用wait()
                    // wait(10000)：最多等10秒，超时自动醒；没参数就是死等
                    ORDER_LOCK.wait(10000);

                    // 醒了之后判断状态
                    if (!isAccepted) {
                        System.out.println("【催单成功】商家快接单！用户都等急了！");
                    } else {
                        System.out.println("【无需催单】商家已接单，撤掉催单提醒");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "催单线程");

        // 2. 接单线程：接单后通知催单线程“别催了”
        Thread acceptThread = new Thread(() -> {
            synchronized (ORDER_LOCK) {
                try {
                    System.out.println("商家收到订单，正在确认...");
                    Thread.sleep(3000); // 模拟商家3秒后接单
                    isAccepted = true;
                    System.out.println("商家已接单！");

                    // 铁律3：用同一个锁对象调用notify()，唤醒等待的线程
                    ORDER_LOCK.notify(); // 喊一声：“催单的别等了，单接了！”
                    System.out.println("已通知催单线程：无需催单");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "接单线程");

        // 启动线程
        remindThread.start();
        acceptThread.start();
    }
}

“这就对了！” 王哥拍桌，“催单线程先拿着锁等，wait () 的时候把锁放了，接单线程才能拿到锁去改状态，改完用 notify () 喊醒它 —— 这流程比外卖小哥送餐还顺！”

插个冷笑话：“wait () 和 notify () 的关系，就像你和外卖员：你点了餐，发消息说‘我先睡会儿，到了喊我’（wait ()），外卖员到了喊‘你的餐到了’（notify ()），你立马起来取 —— 要是没这暗号，你要么一直盯着手机（死循环轮询，耗 CPU），要么外卖员到了没人接（线程漏通知），俩都难受！”

三、进阶：notify () 和 notifyAll () 的区别，别喊错人

“刚用的 notify () 是喊醒一个线程，要是多个线程等着同一个锁呢？” 王哥又抛个问题，比如外卖系统里，一个订单有 “催单线程”“退款线程” 两个线程在等，商家接单后，俩线程都得知道。

这时候 notify () 就不够用了 —— 它只会随机喊醒一个，另一个还在死等，就像你在群里 @一个人，其他人看不见。这时候得用notifyAll() ，相当于在群里发 “@所有人 单接了”，所有等这个锁的线程都能醒。

多线程等待场景（notifyAll () 版）

public class NotifyAllDemo {
    static final Object ORDER_LOCK = new Object();
    static boolean isAccepted = false;

    public static void main(String[] args) {
        // 1. 催单线程
        Thread remindThread = new Thread(() -> {
            synchronized (ORDER_LOCK) {
                try {
                    System.out.println("催单线程：等商家接单...");
                    ORDER_LOCK.wait();
                    System.out.println("催单线程：收到通知，商家已接单，不催了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "催单线程");

        // 2. 退款线程：商家超久不接单就退款
        Thread refundThread = new Thread(() -> {
            synchronized (ORDER_LOCK) {
                try {
                    System.out.println("退款线程：等商家接单，超时就退款...");
                    ORDER_LOCK.wait();
                    System.out.println("退款线程：收到通知，商家已接单，取消退款");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "退款线程");

        // 3. 接单线程：接单一键通知所有等待线程
        Thread acceptThread = new Thread(() -> {
            synchronized (ORDER_LOCK) {
                try {
                    Thread.sleep(2000);
                    isAccepted = true;
                    System.out.println("商家已接单！准备通知所有等待线程");
                    // 用notifyAll()唤醒所有等ORDER_LOCK的线程
                    ORDER_LOCK.notifyAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "接单线程");

        remindThread.start();
        refundThread.start();
        acceptThread.start();
    }
}

运行结果里，两个等待线程都被唤醒了：

“记住：notify () 是‘精准喊人’，notifyAll () 是‘广播通知’，” 王哥总结，“用错了就麻烦 —— 比如退款线程没被唤醒，用户都接单了还被退款，这锅你背得起吗？”

四、真实使用场景：生产者 - 消费者模式

“除了催单，这俩方法最经典的就是‘生产者 - 消费者’模式，” 王哥说，比如外卖平台的订单队列：

• 生产者：用户下单，往队列里塞订单；
• 消费者：商家抢单，从队列里拿订单；
• 没订单时，消费者 wait () 等着；
• 有新订单时，生产者 notify () 喊消费者来拿。

极简订单队列（生产者 - 消费者）

package cn.tcmeta.threads;

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

// 外卖订单队列
class TakeoutQueue {
    // 订单队列，最多存5个订单（防止撑爆）
    private final Queue<String> queue = new LinkedList<>();
    // 锁对象
    private final Object LOCK = new Object();

    // 生产者：用户下单（往队列加订单）
    public void addOrder(String orderId) {
        synchronized (LOCK) {
            // 队列满了就等（不能再加了）
            int MAX_SIZE = 5;
            while (queue.size() >= MAX_SIZE) {
                try {
                    System.out.println("订单队列满了，用户" + orderId + "请稍等...");
                    LOCK.wait(); // 释放锁，让消费者拿订单
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.add(orderId);
            System.out.println("用户下单：" + orderId + "，当前队列订单数：" + queue.size());
            LOCK.notifyAll(); // 通知消费者来拿订单
        }
    }

    // 消费者：商家抢单（从队列拿订单）
    public void takeOrder(String merchantId) {
        synchronized (LOCK) {
            // 队列空了就等（没单可抢）
            while (queue.isEmpty()) {
                try {
                    System.out.println("商家" + merchantId + "：暂无订单，等待中...");
                    LOCK.wait(); // 释放锁，让生产者加订单
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            String orderId = queue.poll();
            System.out.println("商家" + merchantId + "抢单成功：" + orderId + "，剩余订单数：" + queue.size());
            LOCK.notifyAll(); // 通知生产者可以加订单了
        }
    }
}

// 测试类
public class ProducerConsumerDemo {
    public static void main(String[] args) {
        TakeoutQueue queue = new TakeoutQueue();

        // 3个生产者（用户下单）
        for (int i = 1; i <= 3; i++) {
            int userId = i;
            new Thread(() -> {
                for (int j = 1; j <= 4; j++) {
                    queue.addOrder("U" + userId + "-" + j); // 订单ID：U1-1表示用户1的第1个单
                    try {
                        Thread.sleep(1000); // 模拟用户1秒下一个单
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "用户" + i).start();
        }

        // 2个消费者（商家抢单）
        for (int i = 1; i <= 2; i++) {
            int merchantId = i;
            new Thread(() -> {
                while (true) {
                    queue.takeOrder("M" + merchantId); // 商家ID：M1表示商家1
                    try {
                        Thread.sleep(1500); // 模拟商家1.5秒处理一个单
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "商家" + i).start();
        }
    }
}

五、总结：5 分钟上手的核心要点

王哥把煎饼渣扫干净，给你画了个 “傻瓜式口诀”，记牢就能直接用：

• 锁对象先备好：不管 wait 还是 notify，先搞个共同的锁对象（比如订单、队列）；
• 同步块包起来：把 wait/notify 和共享变量（状态、队列）都放进 synchronized (锁对象) 里；
• wait 前先判断：用 while 循环判断条件（比如队列是否空 / 满），别用 if—— 防止线程 “假醒”（JVM - 可能莫名唤醒 wait 的线程）；
• notify 后要释放：notify () 之后同步块会继续执行完才释放锁，别在 notify () 后面写太多代码；
• 多线程用 notifyAll：多个线程等同一个锁，就用 notifyAll ()，别用 notify () 随机唤醒。

彩蛋：王哥的血泪史

“我刚工作时，把 wait () 写在了同步块外面，” 王哥捂脸，“结果一跑就抛异常，我以为 JVM 坏了，还重启了服务器，被领导骂‘连锁都不会用’，罚我抄了 10 遍 synchronized 用法 —— 现在我写 wait () 前，先摸一下锁对象，比摸手机还熟练。”

六、最后说句实在的

wait () 和 notify () 不是什么高深技术，本质就是给线程 “装个对讲机”，让它们别瞎跑。今天这篇代码你复制过去就能跑，改改锁对象和状态判断，就能用到自己的项目里 —— 比如订单系统、消息通知、任务队列，都能用。

要是你搞懂了，别光顾着自己爽，点赞让更多人避坑，关注我 —— 下次咱们扒一扒 “wait () 和 Condition 的区别”，Condition 比 wait () 更灵活，能给线程 “分组喊号”，再也不用怕 notifyAll () 喊醒一堆无关线程。

对了，把这篇分享给你那用 “死循环轮询” 实现线程等待的同事，下次代码 review 时，你就能笑着说：“兄弟，别让线程当‘卷王’一直问了，给它们发个‘对讲机’（wait/notify），让它们歇会儿呗！”