文章目录
在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），让它们歇会儿呗！”
扫一扫
630
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
