知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 02 - 生产者消费者模型 > 导读:本文用一问一答的方式拆解"手写生产者消费者模型"这道经典并发题——从 BlockingQueue、wait/notify 到 ReentrantLock + Condition 三种写法,讲清各自的阻塞唤醒原理、常见写错的地方与选型建议。适合准备 Java 并发面试、或想真正搞懂 `wait()`/`notify()` 该配 `while` 还是 `if` 的开发者阅读。 ## 一、先建立全局认知 ### Q:"用 Java 实现一个生产者消费者模型"这道题,考察点是什么? A:结论先行——题目通常会附加几个约束(线程安全、生产者满了阻塞、消费者空了阻塞),考察三件事: 1. **你是否知道有现成的并发工具**:`BlockingQueue`(阻塞队列,提供了"队列满自动阻塞、队列空自动阻塞"语义的线程安全队列)就是为这个场景设计的,能直接用它说明你懂工程实践。 2. **你是否理解底层同步原语**:`synchronized`、`wait()`/`notify()`、`Lock`/`Condition` 是阻塞唤醒的底层机制,`wait()` 为什么必须放在 `while` 里、为什么用 `notifyAll()` 而不是 `notify()`,都是高频追问。 3. **取舍意识**:简单方案和精确唤醒方案各有什么代价、分别适合什么场景。 ### Q:用"生产者消费者模型"要解决什么问题?为什么不能简单地共享一个队列? A:生产者消费者模型(Producer-Consumer Pattern)用一个**缓冲区(队列)**解耦生产与消费两端:生产者只负责往队列放数据,消费者只负责从队列取数据。 它的价值在于:削峰填谷(生产快、消费慢时把数据暂存起来)、解耦(两端不必互相等待)、并行(多个生产者消费者同时工作)。但这些收益都建立在一个前提上——**队列的各种状态转换必须线程安全**: - 队列满时,生产者应阻塞等待,而不是丢数据或空转; - 队列空时,消费者应阻塞等待,而不是取到 null 或抛异常; - 一次"检查状态 + 修改队列 + 唤醒对方"必须整体原子,否则并发下必然出问题。 所以手写这道题的核心,就是把这套"阻塞—唤醒"逻辑写对。 ## 二、理解核心机制 ### Q:方案一:为什么说用 BlockingQueue 是最简洁、生产环境首选的写法? A:因为它把"满则阻塞、空则阻塞"的语义内建到了 API 里,业务代码只需要调用 `put()`/`take()`: ```java import java.util.concurrent.*; public class ProducerConsumer { // 有界阻塞队列,容量为 10 private static final BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10); // 生产者 static class Producer implements Runnable { @Override public void run() { int i = 0; while (true) { try { queue.put(i); // 队列满时自动阻塞 System.out.println("生产: " + i++); Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } } } // 消费者 static class Consumer implements Runnable { @Override public void run() { while (true) { try { int item = queue.take(); // 队列空时自动阻塞 System.out.println("消费: " + item); Thread.sleep(200); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } } } public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(3); executor.submit(new Producer()); executor.submit(new Consumer()); executor.submit(new Consumer()); // 两个消费者 } } ``` **BlockingQueue 的阻塞原理**:底层用 `ReentrantLock` + `Condition` 实现,`put()` 满时调用 `notFull.await()`,`take()` 空时调用 `notEmpty.await()`,有数据/空间时调用 `signal()` 唤醒。 几点值得注意的取舍: - 这里用的是**有界**队列 `ArrayBlockingQueue<>(10)`。生产环境更推荐有界队列,因为无界队列在消费跟不上时会无限堆积、最终 OOM。 - `put()`/`take()` 会抛 `InterruptedException`,代码里捕获后调用了 `Thread.currentThread().interrupt()` 重新置位中断标记,这是中断处理的规范做法——不要吞掉中断状态。 - 代价是这版代码依赖 JDK 提供的类,"手写"成分较少;面试中通常需要你同时答出方案二或方案三,以证明你理解底层原理。 ### Q:方案二:用 wait/notify 手写时,正确的写法长什么样? A:这是考察基础同步原语的一版,核心是"在 `synchronized` 里用 `while` 判断条件、用 `notifyAll()` 唤醒": ```java public class ProducerConsumerWait { private final LinkedList<Integer> buffer = new LinkedList<>(); private final int capacity; public ProducerConsumerWait(int capacity) { this.capacity = capacity; } public synchronized void produce(int item) throws InterruptedException { while (buffer.size() == capacity) { wait(); // 队列满,释放锁并等待 } buffer.add(item); System.out.println("生产: " + item + ",队列大小: " + buffer.size()); notifyAll(); // 唤醒所有等待的线程(包括消费者) } public synchronized int consume() throws InterruptedException { while (buffer.isEmpty()) { wait(); // 队列空,释放锁并等待 } int item = buffer.removeFirst(); System.out.println("消费: " + item + ",队列大小: " + buffer.size()); notifyAll(); // 唤醒所有等待的线程(包括生产者) return item; } } ``` 这里有个必须记住的规则:`wait()`、`notify()`、`notifyAll()` 只能在持有该对象监视器锁的代码里调用(即 `synchronized` 块中),否则会抛 `IllegalMonitorStateException`。`wait()` 被调用时会**释放锁并让出 CPU**,被唤醒后需要重新竞争到锁才能继续执行。 ### Q:为什么条件判断一定要用 while 而不是 if? A:因为被唤醒不等于条件成立。用 `if` 的写法在并发下有正确性缺陷: ```java // 错误写法(if): if (buffer.isEmpty()) { wait(); } // 被唤醒后直接执行,但可能是被其他消费者唤醒的 // 此时 buffer 可能已经被其他消费者消费完了,再次为空 // → 会抛出 NoSuchElementException // 正确写法(while): while (buffer.isEmpty()) { wait(); } // 被唤醒后重新检查条件,如果还是空就继续等待 // 防止"虚假唤醒"(spurious wakeup) ``` 要点有两个: - **防止"虚假唤醒"(spurious wakeup)**:线程可能在没有任何 `notify` 的情况下从 `wait()` 返回,所以必须在醒来后重新检查条件。 - **防止被"同类"唤醒后条件已不成立**:多个消费者同时等待时,一个生产者 `notifyAll` 后,可能某个消费者先抢到锁把数据取走,另一个消费者再醒来时队列又空了。`while` 会让它继续等待,`if` 则会直接往下执行导致出错。 ### Q:为什么用 notifyAll 而不是 notify? A:核心原因是 `notify` 可能唤醒"错的对象",导致所有线程都在等待: ``` notify 只唤醒一个等待线程,可能唤醒的是同类(生产者唤醒生产者) 导致所有线程都在等待,系统死锁 notifyAll 唤醒所有等待线程,让它们重新竞争锁 虽然性能稍差,但更安全 更好的方案:用 ReentrantLock + 两个 Condition(notFull 和 notEmpty) 生产者满时等待 notFull,消费者消费后 signal notFull 消费者空时等待 notEmpty,生产者生产后 signal notEmpty 精确唤醒,避免无效唤醒 ``` 换句话说,`wait/notify` 只有**一个等待队列**,生产者和消费者混在一起,`notify` 无法区分"该叫醒谁"。用 `notifyAll` 是靠"多叫醒几个总没错"来换正确性,代价是无意义的上下文切换和锁竞争。下一节的方案三正是为了消除这个代价。 ### Q:方案三:怎么用 ReentrantLock + Condition 做到"精确唤醒"? A:思路是给"队列不满"和"队列不空"各配一个独立的等待队列,唤醒时只唤醒真正需要的那一类线程: ```java public class ProducerConsumerLock { private final LinkedList<Integer> buffer = new LinkedList<>(); private final int capacity; private final ReentrantLock lock = new ReentrantLock(); private final Condition notFull = lock.newCondition(); // 队列不满 private final Condition notEmpty = lock.newCondition(); // 队列不空 public ProducerConsumerLock(int capacity) { this.capacity = capacity; } public void produce(int item) throws InterruptedException { lock.lock(); try { while (buffer.size() == capacity) { notFull.await(); // 队列满,等待"不满"信号 } buffer.add(item); notEmpty.signal(); // 精确唤醒消费者(不唤醒生产者) } finally { lock.unlock(); } } public int consume() throws InterruptedException { lock.lock(); try { while (buffer.isEmpty()) { notEmpty.await(); // 队列空,等待"不空"信号 } int item = buffer.removeFirst(); notFull.signal(); // 精确唤醒生产者(不唤醒消费者) return item; } finally { lock.unlock(); } } } ``` `Condition`(条件变量)可以理解为"绑在某个 `Lock` 上的等待队列"。这里用两个 `Condition` 把等待线程分成两组:生产者等 `notFull`,消费者等 `notEmpty`。生产者放入数据后 `notEmpty.signal()` 只会唤醒消费者,反之亦然——既避免了无效唤醒,也天然回避了"`notify` 唤醒同类"的风险。注意 `while` 的写法同样不能丢,因为虚假唤醒和抢锁竞争依旧存在。 ---  [编辑 Excalidraw 源图](/images/java-interview-copy/concurrent/02-producer-consumer-producer-consumer-condition-flow-diagram.excalidraw) ## 三、放进真实场景 ### Q:三种方案该怎么选? A:把复杂度、性能和适用场景拉平来看: | 方案 | 代码复杂度 | 性能 | 适用场景 | |------|-----------|------|---------| | BlockingQueue | 最简单 | 好 | 生产环境首选 | | wait/notify | 中等 | 一般(notifyAll 有无效唤醒) | 考察基础 | | ReentrantLock + Condition | 较复杂 | 最好(精确唤醒) | 需要精细控制 | 实践中的选择建议: - **业务代码**:优先用 `BlockingQueue`,把并发难点交给经过充分验证的 JDK 实现,同时别忘了用有界队列防止堆积。 - **面试答题**:先给 `BlockingQueue` 体现工程意识,再补 `wait/notify` 和 `ReentrantLock + Condition` 体现对底层原理的掌握,最后点出 `while` 与 `notifyAll` 的原因。 - **需要精细控制时**(如一个锁上要区分多种等待条件、需要超时等待、需要可中断锁):用 `ReentrantLock + Condition`。 ### Q:BlockingQueue 有哪些实现?区别是什么? A:常用实现与差异如下: - `ArrayBlockingQueue`:有界,数组实现,生产和消费共用一把锁。 - `LinkedBlockingQueue`:可有界可无界,链表实现,生产和消费用两把锁(吞吐量更高)。注意默认构造出来的其实是接近无界的队列,容易堆积,使用时要显式指定容量。 - `PriorityBlockingQueue`:无界,按优先级排序。 - `SynchronousQueue`:容量为 0,每次 put 必须等待 take,适合直接传递任务。 - `DelayQueue`:延迟队列,元素到期才能取出。 其中"共用一把锁"与"用两把锁"的区别,正是"整体串行"与"读写分离"的经典取舍:`ArrayBlockingQueue` 实现简单但生产消费互相阻塞,`LinkedBlockingQueue` 通过双锁 + `AtomicInteger` 计数提高了并发吞吐。 ### Q:为什么手写队列时容易踩坑?生产代码里还要注意什么? A:手写版只解决了"阻塞唤醒",而生产环境还要考虑几件事: - **中断与关闭**:`wait()`/`await()` 会响应中断,需要像方案一那样处理 `InterruptedException`,并在系统关闭时能优雅退出而不是死循环。 - **超时**:`await(timeout, unit)`、`poll(timeout, unit)` 能避免线程永久阻塞,是防止故障扩散的常用手段。 - **异常安全**:方案三用 `try/finally` 保证 `unlock()` 一定执行;方案二依赖 `synchronized` 自动释放锁,这也是它写法更简单的原因。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:建议按"最优方案 → 底层原理 → 细节陷阱"三步作答: 1. **先给最优方案**:业务上直接用有界的 `BlockingQueue`,`put()` 满则阻塞、`take()` 空则阻塞,代码最简单且经过充分验证。 2. **再讲底层原理**:`BlockingQueue` 内部就是 `ReentrantLock` + 两个 `Condition`(`notFull`/`notEmpty`)实现的精确唤醒;如果手写,可以用 `synchronized + wait/notify`,也可以用 `ReentrantLock + Condition`。 3. **点出细节陷阱**:条件判断必须用 `while` 防虚假唤醒,唤醒优先用 `notifyAll`,或干脆用双 `Condition` 精确唤醒;同时处理中断、优先选有界队列。 ### Q:如果面试官追问"BlockingQueue 内部是怎么阻塞的",怎么答? A:一句话概括:它内部持有一把 `ReentrantLock` 和两个 `Condition`。`put()` 时若队列已满就在 `notFull` 上 `await()`,放入后 `signal()` 唤醒等在 `notEmpty` 上的消费者;`take()` 时若队列为空就在 `notEmpty` 上 `await()`,取出后 `signal()` 唤醒等在 `notFull` 上的生产者。判断条件同样用 `while` 循环,逻辑与手写方案三一致。 --- ## 自测 1. 为什么 `wait()` 的条件判断要用 `while` 而不是 `if`?"虚假唤醒"指什么? 2. `notify()` 与 `notifyAll()` 有什么区别?为什么用 `ReentrantLock + Condition` 能避免它们之间的问题? 3. `ArrayBlockingQueue` 和 `LinkedBlockingQueue` 在锁的使用上有什么差异?各自适合什么场景?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入