阻塞队列三大实现源码解析，线程池选型避坑指南

时间：2026-06-28 12:42

BlockingQueue是线程池核心阻塞队列。ArrayBlockingQueue有界数组，容量固定，无OOM风险；LinkedBlockingQueue链表结构，读写锁分离，但默认无界，可能耗尽内存；SynchronousQueue不存储元素，直接交付，吞吐量高。线程池选型推荐采用有界队列如ArrayBlockingQueue，并配置合理拒绝策略。

BlockingQueue，这个在Java并发面试中频繁被考察的核心组件，究竟该如何深入理解？今天，我们将通过一套组合拳——通俗类比、源码剖析、实战选型，彻底掌握它。

先从最基础的场景说起。线程池之所以能高效运行，BlockingQueue功不可没。你可以把它想象成一个“任务缓冲站”，专门解决生产者和消费者之间速度不匹配的问题。本质上，这是JUC并发包中一个非常经典的设计。

话不多说，直接上干货。

一、先搞懂：BlockingQueue到底是个啥？（大白话版）

用生活场景做个类比：

生产者 = 餐厅后厨做菜的厨师
消费者 = 前台取餐的服务员
BlockingQueue = 出餐口的餐架

核心逻辑如下：

餐架摆满了（队列满），厨师只能等着，直到有服务员取走菜品——这叫阻塞生产者。
餐架空了（队列空），服务员只能等着，直到厨师做好菜品——这叫阻塞消费者。

底层原理其实很简单：基于AQS的Condition条件队列实现等待与唤醒。你完全不需要手动处理线程同步，JUC已经帮我们封装好了。

面试时，这些核心方法必须能默写出来：

面试考点：put()/take()是阻塞方法，offer()/poll()是非阻塞方法。实际开发中，优先使用阻塞方法——可以避免空轮询带来的性能浪费。

二、三大核心实现：源码拆解+核心特性（面试重点）

1. ArrayBlockingQueue：有界数组队列（稳定安全首选）

底层结构：基于固定容量的数组实现，创建时必须指定容量，比如new ArrayBlockingQueue(9)。

public class ArrayBlockingQueue {
    final Object[] items; // 存放元素的固定数组
    final ReentrantLock lock; // 独占锁：入队出队共用同一把锁
    private final Condition notEmpty; // 队列非空条件（唤醒消费者）
    private final Condition notFull; // 队列非满条件（唤醒生产者）
}

✅ 核心优点：

有界队列，不会无限扩容，没有OOM风险——生产环境首选。
结构简单，性能稳定，适合生产消费速度均衡的场景。

❌ 注意点：

读写共用一把锁，高并发下吞吐量一般。
支持公平/非公平锁，默认是非公平锁，公平锁性能更低。

2. LinkedBlockingQueue：链表队列（高吞吐但需谨慎）

底层结构：基于单向链表实现，可以指定容量（有界），也可以不指定（无界，默认Integer.MAX_VALUE）。

public class LinkedBlockingQueue {
    private final int capacity; // 容量（不指定则为无界）
    private final AtomicInteger count; // 元素计数（原子类保证线程安全）
    private final ReentrantLock takeLock; // 出队锁（独立）
    private final ReentrantLock putLock; // 入队锁（独立）
}

✅ 核心优点：

读写锁分离，生产者和消费者不互斥，并发吞吐量远超ArrayBlockingQueue。
链表结构，插入和删除效率高。

❌ 致命坑点（面试必问）：

不指定容量时是无界队列，一旦生产速度远超消费速度，队列会无限膨胀，最终导致OOM。
Executors.newFixedThreadPool()默认使用无界LinkedBlockingQueue——生产环境严禁直接使用！

3. SynchronousQueue：同步队列（无存储高吞吐）

底层结构：内部不存储任何元素，相当于“直接手递手”传递任务。

public class SynchronousQueue {
    abstract static class Transferer {
        abstract E transfer(E e, boolean timed, long nanos);
    }
}

✅ 核心优点：

容量为0，无存储开销，吞吐量极高。
每一个put()操作必须等待take()操作，适合任务处理速度极快的场景。

❌ 注意点：

无缓冲，如果没有消费者，生产者会一直阻塞。
Executors.newCachedThreadPool()默认使用SynchronousQueue，高并发下容易创建过多线程。

三、源码核心逻辑：以put/take方法为例（面试拆解）

以ArrayBlockingQueue为例，看懂这两个方法，就掌握了所有阻塞队列的核心逻辑。

1. put方法（阻塞入队）

public void put(E e) throws InterruptedException {
    lock.lockInterruptibly(); // 加锁（支持中断）
    try {
        // 队列满了，在notFull条件队列等待
        while (count == items.length) 
            notFull.await(); 
        enqueue(e); // 入队
    } finally {
        lock.unlock(); // 解锁
    }
}

private void enqueue(E x) {
    items[putIndex] = x;
    putIndex = (putIndex + 1) % items.length; // 循环数组
    count++;
    notEmpty.signal(); // 唤醒等待的消费者
}

2. take方法（阻塞出队）

public E take() throws InterruptedException {
    lock.lockInterruptibly(); // 加锁
    try {
        // 队列空了，在notEmpty条件队列等待
        while (count == 0) 
            notEmpty.await(); 
        return dequeue(); // 出队
    } finally {
        lock.unlock(); // 解锁
    }
}

private E dequeue() {
    E x = (E) items[takeIndex];
    items[takeIndex] = null; // 清空元素
    takeIndex = (takeIndex + 1) % items.length;
    count--;
    notFull.signal(); // 唤醒等待的生产者
    return x;
}

核心逻辑闭环（面试必说）：