知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 阻塞队列与生产者-消费者 > 导读:本文不重复讲"怎么用 wait/notify 实现生产者消费者",而是把阻塞队列(BlockingQueue)当成一个独立的并发组件来拆解:它的四组 API 与阻塞语义、底层双 Condition 协作、有界无界的取舍,以及六种常见实现该怎么选型。适合想搞清楚"线程池、定时任务、消息中间件底层都用了哪种队列"的后端开发者。 ## 一、先建立全局认知 ### Q:阻塞队列到底是什么?它和普通队列的本质区别在哪? A:结论先行——区别只在"队列满/空时的行为"。普通队列(如 `LinkedList`)遇到满或空,要么抛异常、要么返回失败、要么由调用方自己写自旋重试;而阻塞队列(BlockingQueue,一种在入队/出队条件不满足时会让线程挂起等待的线程安全队列)把"等"这件事内建进了 API:入队时队列满就阻塞,出队时队列空就阻塞,条件满足后自动唤醒。它是线程安全的,调用方不需要额外加锁。 把三种处理方式放一起看更清楚:入队失败时,抛异常是"立即失败",返回 `false` 是"由我决定怎么办",而 `put()` 是"我在这儿等着"——正是这第三种语义,让阻塞队列天然成为并发协作的组件。 ### Q:它到底替生产者消费者解决了哪三件事? A:三件事:**解耦、削峰、控制内存占用**。 1. **解耦**:生产者和消费者只依赖队列这个中间层,双方不直接调用、不感知对方的数量与速度。生产者改成"放进队列",消费者改成"从队列取",两端可以独立部署、独立扩容。 2. **削峰**:生产快、消费慢时,超出消费能力的数据先在队列里排队,避免请求直接打垮下游。 3. **控制内存占用**:这一条最容易被忽略——**只有有界队列才能真正削峰**。队列容量就是缓冲区上限,它给上游施加了反压(Back Pressure,条件不满足时让上游阻塞或失败,而不是无限接收)。无界队列的"削峰"只是把问题推迟成 OOM。 ## 二、理解核心机制 ### Q:BlockingQueue 的四组 API 该怎么区分? A:同一个操作按失败策略不同提供了四组方法,记住这句口诀——**抛异常、给返回值、阻塞、超时**: | 操作 | 抛异常 | 返回特殊值 | 阻塞 | 超时 | |------|--------|-----------|------|------| | 入队 | `add(e)` | `offer(e)` | `put(e)` | `offer(e, t, unit)` | | 出队 | `remove()` | `poll()` | `take()` | `poll(t, unit)` | | 检查队头 | `element()` | `peek()` | — | — | 各自适合的场景: - **抛异常**:确定操作一定成功、失败即程序 bug(如入队前已知容量充足),用 `add`/`remove` 让问题尽早暴露。 - **返回特殊值**:不想阻塞、也不希望抛异常,用 `offer` 判断失败 / `poll` 返回 `null` 自行处理,适合"尽力而为"的场景。 - **阻塞**:就是要等到能操作为止,这是生产者消费者核心场景,用 `put`/`take`。 - **超时**:既不想无限等、又愿意给机会,用 `offer`/`poll` 的重载版本,超时返回 `false`/`null`,是防止线程永久挂起的常用手段。 注意 `peek`/`element` 都只"看"不出队,区别仅在队空时的行为(返回 `null` vs 抛异常)。  *图:阻塞队列的双条件协作模型——生产者与消费者共用一个锁、分别等待 notFull 与 notEmpty,入队/出队后互相唤醒,以及有界容量如何形成天然的反压。* ### Q:底层的阻塞与唤醒是怎么实现的? A:结论:**一把 `ReentrantLock` + 两个 `Condition`**。以 `ArrayBlockingQueue` 为例,它内部持有 `notFull` 和 `notEmpty` 两个条件队列,`put`/`take` 的流程是: - `put(e)`:先 `lock`,再用 `while (count == items.length) notFull.await()` 判断——满了就在"不满"条件上等待;成功入队后执行 `notEmpty.signal()`,告诉等在"不空"上的消费者"有数据了",最后 `unlock`。 - `take()`:先 `lock`,用 `while (count == 0) notEmpty.await()` 判断——空了就在"不空"条件上等待;成功出队后执行 `notFull.signal()`,唤醒生产者"有空位了",最后 `unlock`。 一句话记忆:**入队后 signal notEmpty,出队后 signal notFull**,方向永远是"通知对面"。这里的 `await` 同样必须放在 `while` 里,原因和 `wait` 一致(虚假唤醒 + 抢锁后条件可能再次不成立)。这正是《生产者消费者模型》里方案三的底层原型,区别在于本篇关心的是 JDK 已经把它封装成了可直接复用的组件。 ### Q:有界和无界的区别是什么?为什么无界队列在真实系统里很危险? A:有界队列容量固定,满了就让生产者阻塞/失败,形成反压;无界队列不设上限,生产者理论上永远不会被阻塞。危险恰恰在这里: 1. **内存被堆积的任务撑爆**:上游快、下游慢时任务只进不出,容量接近 `Integer.MAX_VALUE` 的队列会在内存耗尽前先让 GC 频繁告警,最终 OOM——这不是"削峰",是把突发流量攒成一次更大的故障。 2. **让线程池的 max 参数形同虚设**:`ThreadPoolExecutor` 只有"核心线程满 + 队列满"才会扩容到 `max`。如果配了无界队列(如 `LinkedBlockingQueue` 默认构造),队列永远不会满,线程数就永远停在 core,`maximumPoolSize` 根本用不上,任务全积压在队列里排队。 所以生产环境的铁律是:**显式指定容量**,写 `new LinkedBlockingQueue<>(capacity)` 而不是 `new LinkedBlockingQueue<>()`,再配合第三章的拒绝/降级策略兜底(这也与《线程池拒绝策略》一篇呼应)。 ### Q:为什么 put/take 会抛 InterruptedException?为什么不能吞掉? A:因为阻塞的本质是"线程停在某处等条件",而取消一个任务时我们要能把它从等待中叫醒——中断就是这个"叫醒"机制。`put`/`take` 声明抛 `InterruptedException`(一种表示线程在阻塞过程中被中断的受检异常),语义是"我等待时被中断了,操作没完成"。 必须处理而不是吞掉,有两层原因: - **正确性**:捕获后如果什么都不做,中断标记会被清除(抛出时 JVM 会清掉中断状态),上层就永远不知道有人要求停止,优雅停机、超时取消都会失效。 - **协作性**:正确做法是恢复中断标记 `Thread.currentThread().interrupt()`,把信号继续往上传,由调用方决定是退出还是降级。 ### Q:常见实现这么多,到底该怎么选型? A:先看一张对比表,再逐个说适合与不适合: | 实现 | 结构 | 容量 | 锁 | 特点 | |------|------|------|----|------| | `ArrayBlockingQueue` | 数组 | 有界(必填) | 一把锁,可选公平 | 内存紧凑,可指定公平性 | | `LinkedBlockingQueue` | 链表 | 默认 `Integer.MAX_VALUE` | 两把锁(put/take 分离) | 吞吐高,读写并行 | | `SynchronousQueue` | 不存储元素 | 0 | 直接移交 | 生产者必须等到消费者 | | `PriorityBlockingQueue` | 堆 | 无界 | 一把锁 | 按优先级出队 | | `DelayQueue` | 优先队列 | 无界 | 一把锁 | 到期才能取出 | | `LinkedTransferQueue` | 链表 | 无界 | — | 支持 transfer 移交语义 | - **`ArrayBlockingQueue`**:适合容量可控、需要公平性的场景(顺序敏感);不适合追求极致吞吐的高并发生产消费(一把锁让 put/take 互斥)。 - **`LinkedBlockingQueue`**:适合吞吐优先、单条任务处理较重的场景(双锁分离);不适合作为线程池队列时"忘记指定容量",那等于埋了一颗 OOM 的雷。 - **`SynchronousQueue`**:适合任务必须被立即处理、不允许排队(如 `Executors.newCachedThreadPool()` 用的就是它);不适合上游突发流量大(没有缓冲,来不及时直接拒绝或新建线程)。 - **`PriorityBlockingQueue`**:适合按优先级调度任务(高优先跑);不适合要求同优先级严格 FIFO 的场景(它**不保证同优先级元素的顺序**)。 - **`DelayQueue`**:适合定时任务、缓存过期、订单超时关闭;不适合把无上限的任务往里塞(无界,同样会 OOM)。 - **`LinkedTransferQueue`**:适合需要"生产者确认消费者已接手"的场景(`transfer` 会阻塞到被消费或超时);一般业务用不到,了解语义即可。 ## 三、放进真实场景 ### Q:用阻塞队列改写生产者消费者,正确姿势是什么? A:和基础版(手写 `wait`/`notify`)相比,这里的重点不再是自己管锁和唤醒,而是关注**容量、停止、异常**: ```java import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicBoolean; public class BlockingQueueDemo { private static final BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(100); private static final AtomicBoolean running = new AtomicBoolean(true); public static void main(String[] args) throws InterruptedException { Thread producer = new Thread(() -> { int i = 0; try { while (running.get()) { queue.put(i++); // 满则阻塞,天然反压 } } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复中断标记,允许优雅退出 } }, "producer"); Thread consumer = new Thread(() -> { try { while (running.get() || !queue.isEmpty()) { Integer item = queue.poll(200, TimeUnit.MILLISECONDS); // 超时轮询,兼顾退出 if (item != null) { handle(item); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "consumer"); producer.start(); consumer.start(); Thread.sleep(2000); running.set(false); // 通知停止 producer.interrupt(); // 打断可能阻塞中的 put producer.join(); consumer.join(); } private static void handle(Integer item) { /* 业务处理 */ } } ``` 关键点:为什么它比 `wait`/`notify` 版本好?因为阻塞队列已经封装了"检查—等待—唤醒"的完整循环,不会写错 `while` 条件,也不会出现 `notify` 叫错人。而消费者侧用 `poll(timeout)` 而不是 `take()`,是为了在停止时能周期性检查 `running`,否则它会一直阻塞在 `take()` 上导致线程无法退出。这就是"优雅停止"要单独处理的原因——**阻塞中的线程必须有人把它叫醒**。 ### Q:手写一个简易有界阻塞队列,核心逻辑是什么? A:理解了双 Condition,40 行就能写出来,重点看两个 `while` 和两次 `signal`: ```java public class SimpleBlockingQueue<T> { private final Object[] items; private int count, putIndex, takeIndex; private final ReentrantLock lock = new ReentrantLock(); private final Condition notFull = lock.newCondition(); private final Condition notEmpty = lock.newCondition(); public SimpleBlockingQueue(int capacity) { this.items = new Object[capacity]; } public void put(T e) throws InterruptedException { lock.lock(); try { while (count == items.length) { notFull.await(); // 满:生产者等待 } items[putIndex] = e; if (++putIndex == items.length) putIndex = 0; // 环形复用 count++; notEmpty.signal(); // 通知消费者 } finally { lock.unlock(); } } @SuppressWarnings("unchecked") public T take() throws InterruptedException { lock.lock(); try { while (count == 0) { notEmpty.await(); // 空:消费者等待 } T e = (T) items[takeIndex]; items[takeIndex] = null; if (++takeIndex == items.length) takeIndex = 0; count--; notFull.signal(); // 通知生产者 return e; } finally { lock.unlock(); } } } ``` 要点:`while` 不能用 `if`(要防虚假唤醒);`signal` 必须在改变 `count` 之后调用;`unlock` 必须在 `finally`。 ### Q:队列容量怎么定?满了怎么办? A:容量不是拍脑袋定的,两个步骤: 1. **估算缓冲能力**:容量 ≈ 峰值生产速率 × 允许的积压时长。比如峰值 2000 QPS、能容忍下游积压 5 秒,容量大约 1 万。 2. **定义溢出策略**:有界就一定会有满的时候,必须为"满"定义行为,而不是让它无限阻塞(生产者被永久挂起同样是故障): - 用 `offer(timeout)` 替代 `put`,超时后走**降级**(返回兜底数据、把任务落库落盘重试); - 若是线程池,就交给**拒绝策略**(`AbortPolicy` 快速失败、`CallerRunsPolicy` 让提交线程自己执行,形成反压)。 ### Q:用 DelayQueue 做延迟任务有哪些坑? A:`DelayQueue` 的元素必须实现 `Delayed` 接口,`getDelay` 返回"还有多久到期",到期前 `take` 会一直阻塞: ```java class DelayTask implements Delayed { private final long expireAt; // 绝对到期时间(毫秒) private final String name; DelayTask(String name, long delayMs) { this.name = name; this.expireAt = System.currentTimeMillis() + delayMs; // 构造时算好绝对时间 } @Override public long getDelay(TimeUnit unit) { return unit.convert(expireAt - System.currentTimeMillis(), TimeUnit.MILLISECONDS); } @Override public int compareTo(Delayed o) { return Long.compare(this.expireAt, ((DelayTask) o).expireAt); } } // 使用:queue.put(new DelayTask("order-1", 5000)); 到期后 take 才会返回 ``` 三个坑: 1. **超时时间要用"绝对时间"**:`getDelay` 每次被调用都要重新计算剩余时间,如果用相对量会导致永远取不出来。上面在构造时就固定 `expireAt` 正是为此。 2. **元素一旦入队不要修改**:`DelayQueue` 底层是优先队列(堆),比较依据变了会破坏堆序,导致取出顺序和延迟都不对。 3. **它是无界的**:一直往里加而没人取,同样会内存增长到 OOM,要有数量上限或消费兜底。 ### Q:消费端抛异常,任务会丢吗?队列会不会卡住不前进? A:这是最隐蔽的一类线上问题,分几种情况: - **取出来之后、处理之前抛异常**:任务已经从队列移除,如果异常向外抛出导致消费者线程退出,这个任务就**永久丢失**,且后续没人再消费。正确做法是在消费者的循环里用 `try/catch` 包住单次处理,失败的任务记日志并有条件地重新 `put` 回队列(重试要有次数上限或延迟,否则会变成死循环),**循环本身不能因为单条任务失败而中断**。 - **处理阻塞或死循环**:消费者卡住不动,队列只进不出,最终堆积。对策是给处理逻辑加超时,或用独立线程池隔离不同类型的任务。 - **兜底**:消费端要有"线程挂了能被发现"的机制——`ThreadPoolExecutor` 里可以重写 `afterExecute` 或给任务包一层 catch 来感知;生产环境更常见的做法是依赖消息中间件的 ack/重投,但那已经超出本地队列的范畴。 ## 四、总结与自测 ### Q:面试里怎么答"阻塞队列"这道题? A:按"语义 → 原理 → 选型"三段: 1. **语义**:阻塞队列在入队满、出队空时让线程阻塞等待,而不是抛异常或忙等;它解决解耦、削峰、控制内存占用三件事,其中"控制内存"必须靠有界队列。 2. **原理**:四组 API(抛异常/特殊值/阻塞/超时);底层是一把 `ReentrantLock` + `notFull`/`notEmpty` 两个 `Condition`,入队后 signal notEmpty、出队后 signal notFull;`put`/`take` 响应中断,不能吞掉中断标记。 3. **选型**:数组用 `ArrayBlockingQueue`(可公平)、链表双锁用 `LinkedBlockingQueue`(记得给容量)、零容量直接移交用 `SynchronousQueue`、优先级用 `PriorityBlockingQueue`、延迟用 `DelayQueue`、移交确认用 `LinkedTransferQueue`;无界队列会让线程池 `max` 失效并有 OOM 风险。 ### Q:如果面试官追问"生产环境你怎么用"? A:一句话:**有界队列 + 明确的溢出策略 + 能被中断的退出**。容量按峰值速率和容忍积压时长估算,满了走 `offer(timeout)` 降级或线程池拒绝策略;消费者用带超时的 `poll`,保证停机时能退出;单条任务异常只影响它自己,循环不能挂。 --- ## 自测 1. 阻塞队列的 `add`/`offer`/`put` 三者在入队失败时的行为分别是什么?各自适合什么场景? 2. 为什么 `LinkedBlockingQueue` 默认构造在真实系统里很危险?它如何让线程池的 `maximumPoolSize` 失效? 3. `put`/`take` 抛出 `InterruptedException` 后,为什么不能直接吞掉?正确的处理方式是什么? 4. 用 `DelayQueue` 做延迟任务时,为什么元素的超时时间要用绝对时间?元素入队后为什么不能修改?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入