1. 引言：为什么需要 ArrayBlockingQueue？
在Java并发编程中，生产者-消费者模式是一种非常经典的解耦设计。而阻塞队列 正是这一模式的核心组件。ArrayBlockingQueue 作为JUC包中一个重要的有界阻塞队列实现，它通过数组 存储数据，并利用 ReentrantLock 和 Condition 实现了线程安全的阻塞存取操作。
本文将带你从类图、核心属性、构造器，到 put/take 及 offer/poll 的核心源码，逐行分析其背后原理，并解答一个关键问题：为什么使用 while 而不是 if 进行条件判断？
2. 核心结构与类图解析
我们先通过一个简化的类图，一览 ArrayBlockingQueue 的内部骨架：
关键点说明：
-
items、takeIndex、putIndex、count 等变量没有使用 volatile，因为所有读写都在锁保护范围内，锁已经保证了内存可见性。
-
lock 是全局独占锁，同一时刻只允许一个线程执行入队或出队操作（读写互斥）。
-
notEmpty 和 notFull 是两个条件变量，用于线程间的等待与唤醒。
3. 构造器：初始化队列与锁
java
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}-
capacity 必须 > 0，数组大小一旦确定就不能扩容（有界）。
-
fair 参数决定锁是否为公平锁。公平锁能避免线程饥饿，但会降低吞吐量。
4. 入队操作源码分析
4.1 offer(e) ------ 非阻塞入队
java
public boolean offer(E e) {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lock();
try {
if (count == items.length)
return false;
else {
enqueue(e);
return true;
}
} finally {
lock.unlock();
}
}流程解析：
-
加锁：保证线程安全。
-
队列满 ：直接返回
false，不阻塞。 -
队列未满 ：调用
enqueue真正入队。 -
解锁 ：释放锁，修改后的变量（如
count）会立即刷回主内存。
优点：快速失败，适合高并发下不希望等待的场景。
4.2 enqueue ------ 真正的入队逻辑
java
private void enqueue(E x) {
final Object[] items = this.items;
items[putIndex] = x; // 放置元素
if (++putIndex == items.length) // 环形数组
putIndex = 0;
count++; // 元素个数+1
notEmpty.signal(); // 唤醒一个等待取元素的线程
}环形数组：
-
通过
putIndex自增并取模（== length时重置为0），实现数组的循环利用。 -
当
putIndex到达数组末尾时，下次插入会从0开始。
信号唤醒：
- 每次成功入队后，都会调用
notEmpty.signal()，通知可能正在等待"队列非空"的消费者线程。
4.3 put(e) ------ 可阻塞入队
java
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
notFull.await();
enqueue(e);
} finally {
lock.unlock();
}
}为什么用 lockInterruptibly()？
- 允许线程在等待锁的过程中响应中断，抛出
InterruptedException，这是一种优雅的退出机制。
为什么是 while 而不是 if？
- 防止虚假唤醒 。线程可能在未真正被 signal 的情况下醒来（spurious wakeup），用
while重新检查条件，确保队列真的未满才继续执行。
5. 出队操作源码分析
5.1 poll() ------ 非阻塞出队
java
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return (count == 0) ? null : dequeue();
} finally {
lock.unlock();
}
}-
队列为空直接返回
null，不阻塞。 -
否则调用
dequeue取出头元素。
5.2 dequeue ------ 真正的出队逻辑
java
private E dequeue() {
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
items[takeIndex] = null; // 帮助GC
if (++takeIndex == items.length)
takeIndex = 0;
count--;
notFull.signal(); // 唤醒一个等待放入的线程
return x;
}细节分析：
-
取出
takeIndex位置的元素，并置为null，让GC及时回收。 -
更新
takeIndex和count。 -
notFull.signal()：队列空出一个位置，通知可能正在等待"队列未满"的生产者。
5.3 take() ------ 可阻塞出队
java
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}-
while(count == 0)：如果队列为空，当前线程进入notEmpty条件队列等待。 -
与
poll的唯一区别 ：take会在队列空时阻塞，而不是立即返回null。
6. 条件变量与等待通知机制图解
生产者线程 消费者线程
| |
put() 队列满 take() 队列空
| |
notFull.await() notEmpty.await()
| |
等待 等待
| |
dequeue() 出队 enqueue() 入队
| |
notFull.signal() notEmpty.signal()-
notFull：队列满时，生产者等待。
-
notEmpty：队列空时，消费者等待。
-
每次成功的
enqueue会唤醒一个消费者，每次成功的dequeue会唤醒一个生产者。
7. 与 LinkedBlockingQueue 的对比
| 特性 | ArrayBlockingQueue | LinkedBlockingQueue |
|---|---|---|
| 数据结构 | 数组 | 链表 |
| 是否无界 | 有界（必须指定容量） | 可选有界/无界 |
| 锁粒度 | 一个锁（读写互斥） | 两个锁（读写分离） |
| 内存效率 | 更好（连续内存） | 一般 |
| 吞吐量 | 较低（锁竞争大） | 较高 |
| size() 精确度 | 精确（锁内计算） | 精确（但基于原子变量） |
8. 最佳实践与注意事项
-
选择合适的容量 ：
ArrayBlockingQueue是有界的，容量过小会导致频繁阻塞，过大则浪费内存。 -
公平锁 vs 非公平锁：默认非公平锁性能更高，但公平锁可避免线程饥饿。
-
使用
offer或poll代替put/take：在非阻塞或超时场景下，避免线程长时间挂起。 -
正确处理中断 ：使用
lockInterruptibly()并捕获InterruptedException，在取消任务时及时释放资源。
9. 总结
ArrayBlockingQueue 虽然名字简单，但背后蕴含了并发编程中的核心思想：
-
锁 保证原子性与可见性。
-
条件变量 实现高效的等待/通知机制。
-
环形数组 实现内存复用。
-
while 循环 + await 防止虚假唤醒。