跳到主要内容
约 11 分钟3 张卡

BlockingQueue

BlockingQueue 是 java.util.concurrent 里支持等待的队列接口:队列满了,往里放的线程可以等到有空位;队列空了,往外取的线程可以等到有元素。线程之间交接任务时,等待和唤醒就由队列负责,不用自己写 wait、notify。

线程池的任务队列、生产者消费者模型都建立在它上面。用好它要想清楚几件事:队满队空时该等还是该失败,队列容量设多大才能挡住积压,消费者怎样停下来,以及内存队列在进程崩溃时会丢什么。实现细节以 OpenJDK 21 为准。

1. 面试核心​

先记住这几条,再读正文
  • put 在队满时等待,take 在队空时等待;限时的 offer、poll 等到超时就返回失败结果。卡 · 入队与出队方法
  • ArrayBlockingQueue 容量固定,LinkedBlockingQueue 不指定容量时上限是 Integer.MAX_VALUE,几乎等于无界。卡 · 有界队列
  • SynchronousQueue 容量为 0,插入和取出必须一一配对、直接交接。卡 · 有界队列
  • 生产者入队之前的写入 happens-before 消费者取出该元素之后的操作,所以消费者能看到入队前写好的字段。卡 · 任务发布与后续修改
  • 有界队列满了就让生产者等待或拒绝入队,把消费跟不上的压力传回生产者,这就是背压。

2. 入队与出队方法​

队满时插入、队空时取出,操作没法马上完成,调用方要决定是等还是立即返回。BlockingQueue 为每种操作都提供了四种处理方式:

操作抛异常返回特殊值一直等待限时等待
插入addofferputoffer(e, timeout, unit)
取出removepolltakepoll(timeout, unit)
查看队首elementpeek不适用不适用
BlockingQueue<Job> queue = new ArrayBlockingQueue<>(1_000);

queue.put(job); // 满时等待,可被中断
Job next = queue.take(); // 空时等待,可被中断

「返回特殊值」那一列:不带超时参数的 offer 入队失败时返回 false,poll 没有元素可取时返回 null,peek 队列为空时返回 null。正因为 null 被用来表示「没有元素」,BlockingQueue 不允许放入 null。上面的例子用的是 put 和 take,调用线程会一直等到有空位或有任务;等待期间线程被中断,方法会抛出 InterruptedException 退出等待。

选哪个方法,取决于你允许调用线程等多久。不能无限等就用限时版本,但超时之后任务怎么办,重试、拒绝还是转存到别处,仍要由调用方决定。

3. 有界队列​

生产速度长期高于消费速度时,没处理的任务会越积越多,无界队列最终会把内存耗尽。有界队列用容量给积压设了上限:队满以后,生产者要么等待,要么入队失败、自己处理。这种把下游处理不过来的压力传回上游的机制叫背压。下面的生产者最多等 100 毫秒,超时就拒绝或转存任务:

boolean accepted = queue.offer(job, 100, TimeUnit.MILLISECONDS);
if (!accepted) {
rejectOrPersist(job);
}

队列满了以后,业务可以选择这些处理方式:

  • 阻塞生产者,让上游自然降速。
  • 等待有限时间后失败。
  • 拒绝低优先级任务。
  • 持久化到可靠队列。
  • 由调用线程自己处理,生产者忙于处理任务,自然就提交得慢了。

队列容量的作用是吸收短时间的流量高峰,让消费者之后慢慢处理积压。如果是持续过载,加大队列只是推迟填满的时间,要解决问题,还得降低生产速度、拒绝部分任务或增加消费能力。

4. 生产者消费者模型​

生产者消费者模型把「产生任务」和「处理任务」交给不同的线程:生产者往队列里提交任务,消费者从队列里领取并处理,两边只通过队列交接,互相不需要知道对方。下面是一个消费者,它循环领取任务,收到中断后退出:

final class Worker implements Runnable {
private final BlockingQueue<Job> queue;

Worker(BlockingQueue<Job> queue) {
this.queue = queue;
}

@Override
public void run() {
try {
while (!Thread.currentThread().isInterrupted()) {
Job job = queue.take();
process(job);
}
} catch (InterruptedException exception) {
Thread.currentThread().interrupt();
}
}
}

队列空时 take 让消费者等待,生产者放入任务后,队列会唤醒等待的消费者。队列还保证了对象的安全发布:消费者能看到生产者在入队之前写好的任务字段(第 8 节会具体说明)。等待、唤醒和可见性都由队列处理,业务代码只需要关心怎样处理任务。

take 等待时被中断会抛出 InterruptedException,抛出时线程的中断标记已被清除。示例在 catch 里调用 interrupt() 把标记设回去,然后结束 run,这样外层代码仍能知道线程是被中断的。正常交接之外,业务还要事先定好失败和停机时的规则:

  • process 失败是否重试。
  • 重试是否保持顺序。
  • 任务是否可以重复执行。
  • 进程崩溃时内存任务是否允许丢失。
  • 停机时等待、排空还是转存。

5. 常见实现​

选实现时先回答两个问题:需不需要缓冲、缓冲多大,以及任务按什么顺序取出。下面几种实现在容量和取出规则上各不相同。

5.1 ArrayBlockingQueue​

ArrayBlockingQueue 的容量在构造时确定,之后不能改,适合需要明确积压上限的场景。OpenJDK 21 用循环数组实现:入队和出队的位置走到数组末尾后绕回开头,槽位反复使用,入队时也不用创建节点对象。

生产和消费共用一把锁,生产者在「队列不满」这个条件上等待,消费者在「队列不空」这个条件上等待。构造时可以选择公平模式,让等待的线程按先来后到的顺序获得访问机会。

5.2 LinkedBlockingQueue​

LinkedBlockingQueue 用链表节点保存任务,构造时可以指定容量。不指定时上限是 Integer.MAX_VALUE,约 21 亿,实际上内存会先耗尽,等于没有背压。

OpenJDK 21 用两把锁分别管入队(put 锁)和出队(take 锁),生产者和消费者可以同时操作队列的两端。代价是每次入队都要分配一个节点对象。两把锁带来的并行收益和节点分配开销哪个更重要,要结合实际负载衡量。

5.3 SynchronousQueue​

SynchronousQueue 容量为 0,根本不存元素,只做直接交接:生产者的元素要交出去,必须有一个消费者同时来取。put、take 会等待另一方到来;不带超时参数的 offer、poll 如果没法立即配对,就直接返回失败结果。它适合把任务直接交给空闲的消费者,因为它不缓冲,积压只能由队列之外的机制处理,比如创建新线程或拒绝任务。

5.4 PriorityBlockingQueue​

PriorityBlockingQueue 按优先级取出任务,逻辑上是无界的。没有任务时它会让消费者等待,但不会因为满了让生产者等待,所以它本身不提供背压。优先级相同的元素按什么顺序取出没有规定,不保证先进先出(FIFO)。比较器要基于入队后不会改变的字段,如果元素入队后修改了用于比较的字段,队列内部的顺序就会被破坏。

5.5 DelayQueue​

DelayQueue 用于在同一个进程内延迟执行任务。元素要实现 Delayed 接口,用 getDelay 返回还剩多久到期,并定义元素之间的比较顺序。消费者只能取到已经到期的元素,没有到期的元素时 take 会等待。

计算延迟时用 System.nanoTime(),它只用于测量时间间隔,不受系统时钟调整的影响;用 System.currentTimeMillis() 的话,有人改了系统时间,等待时长就变了。如果大量任务会被取消,要及时把它们从队列里移除,否则这些无用的对象会一直占着内存。进程重启后队列里的任务就没了,需要恢复的话要另外持久化。

6. 中断、关闭与 poison pill​

消费者阻塞在 take 上等任务时,需要一个明确的信号才能停下来。BlockingQueue 没有 close 方法,常用的结束方式有这几种:

  • 中断消费者线程,take 会抛出 InterruptedException。
  • 往队列里放一个特殊的结束元素,也就是 poison pill。
  • 设置一个外部的关闭标志,消费者用限时 poll 定期醒来检查它。
  • 消费者线程由 ExecutorService 管理时,交给线程池的关闭流程。

poison pill 是一个约定好的特殊元素,消费者取到它就退出。用它时要保证结束信号确实能送到每个消费者:

  • 结束值不会与普通业务任务混淆。
  • 多个消费者收到足够数量的结束信号。
  • 队列已满时仍能完成停机。
  • 不会越过仍需处理的任务。

比如有 3 个消费者,就要放入 3 个结束元素,每个消费者取到一个后退出;只放 1 个,另外 2 个会永远等下去。队列已满时,放入结束元素的 put 本身也会等待。

线程池里的任务要通过 ExecutorService 的 shutdown、shutdownNow 来停止,直接操作线程池的内部队列会绕过它的生命周期管理。自己写的消费者则要自己定义结束协议,包括什么时候停止生产、剩下的任务怎么处理。

7. 内存队列与消息队列​

BlockingQueue 只负责同一个 JVM 里线程之间的交接,任务存在进程内存中,进程一崩溃就全丢了。业务需要下面这些可靠传递的能力时,应该用持久化的消息系统(如 Kafka、RabbitMQ):

  • 崩溃后恢复尚未完成的任务。
  • 跨进程或跨服务传递任务。
  • 确认消费结果,将持续失败的消息放入死信队列,并按需重放。
  • 按分区扩展处理能力,并通过副本容忍节点故障。

如果只需要持久保存任务、再由工作线程领取,用数据库任务表也可以。内存队列仍然可以作为消息消费者内部的有界缓冲,但向消息系统确认消费的时机要和业务实际完成的时机一致。如果消息刚放进内存队列就确认了,随后进程崩溃,消息系统认为它已经处理过,这条任务就丢了。

8. 任务发布与后续修改​

一个线程写入的字段,另一个线程不一定能马上看到。Java 内存模型用 happens-before 描述这种可见性:如果操作 A happens-before 操作 B,A 的写入对 B 可见。BlockingQueue 保证,一个线程把元素放入队列之前的操作,happens-before 另一个线程从队列取出这个元素之后的操作。

比如生产者先设置 job.payload,再执行 queue.put(job),消费者 take 到这个 job 后,一定能读到写好的 payload。

这个保证只覆盖入队之前的写入。队列传递的是对象引用,生产者和消费者拿到的是同一个 Job 对象;生产者入队后如果继续修改它,就和消费者的读取形成了数据竞争,消费者可能看到旧值,也可能看到改了一半的状态。解决办法是让任务不可变,或者约定入队后转移所有权:生产者不再访问这个对象,只由消费者使用。

9. 常见问题​

9.1 LinkedBlockingQueue 不指定容量有什么风险?​

默认上限是 Integer.MAX_VALUE,队列实际上永远不会满,生产者收不到任何队满信号。消费者一旦变慢,节点就持续积压,堆占用和垃圾回收(GC)压力越来越大,严重时出现长时间 GC,甚至内存溢出(OOM)。服务端的线程池和任务管道应该按能承受的积压量显式设置容量。

9.2 先用 remainingCapacity() 检查再 put,为什么还会等待?​

9.3 任务失败重试,怎样避免重复处理?​

9.4 ArrayBlockingQueue 要不要开公平模式?​

10. 面试题卡片​

11. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明