一、ArrayBlockingQueue简介
ArrayBlockingQueue是在JDK1.5时，随着J.U.C包引入的一种阻塞队列，它实现了 BlockingQueue 接口，底层基于 数组 实现：
ArrayBlockingQueue是一种 有界阻塞队列 ，在初始构造的时候需要指定队列的容量。具有如下特点：
- 队列的容量一旦在构造时指定，后续不能改变；
- 插入元素时，在队尾进行；删除元素时，在队首进行；
- 队列满时，调用特定方法插入元素会阻塞线程；队列空时，删除元素也会阻塞线程；
- 支持公平/非公平策略，默认为非公平策略。
这里的公平策略，是指当线程从阻塞到唤醒后，以最初请求的顺序（FIFO）来添加或删除元素；非公平策略指线程被唤醒后，谁先抢占到锁，谁就能往队列中添加/删除顺序，是随机的。
二、ArrayBlockingQueue原理
2.1 构造
ArrayBlockingQueue 提供了三种构造器：
/**
* 指定队列初始容量的构造器.
*/
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();
}
/**
* 根据已有集合构造队列
*/
public ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c) {
this(capacity, fair);
final ReentrantLock lock = this.lock;
lock.lock(); // 这里加锁是用于保证items数组的可见性
try {
int i = 0;
try {
for (E e : c) {
checkNotNull(e); // 不能有null元素
items[i++] = e;
}
} catch (ArrayIndexOutOfBoundsException ex) {
throw new IllegalArgumentException();
}
count = i;
putIndex = (i == capacity) ? 0 : i; // 如果队列已满，则重置puIndex索引为0
} finally {
lock.unlock();
}
}
核心就是第二种构造器，从构造器也可以看出，ArrayBlockingQueue在构造时就指定了内部数组的大小，并通过ReentrantLock来保证并发环境下的线程安全。
ArrayBlockingQueue的公平/非公平策略其实就是内部ReentrantLock对象的策略，此外构造时还创建了两个Condition对象。在队列满时，插入线程需要在notFull上等待；当队列空时，删除线程会在notEmpty上等待：
public class ArrayBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
/**
* 内部数组
*/
final Object[] items;
/**
* 下一个待删除位置的索引: take, poll, peek, remove方法使用
*/
int takeIndex;
/**
* 下一个待插入位置的索引: put, offer, add方法使用
*/
int putIndex;
/**
* 队列中的元素个数
*/
int count;
/**
* 全局锁
*/
final ReentrantLock lock;
/**
* 非空条件队列：当队列空时，线程在该队列等待获取
*/
private final Condition notEmpty;
/**
* 非满条件队列：当队列满时，线程在该队列等待插入
*/
private final Condition notFull;
//...
}
2.2 核心方法
ArrayBlockingQueue会阻塞线程的方法一共4个：put(E e)、offer(e, time, unit)和take()、poll(time, unit)，我们先来看插入元素的方法。
插入元素——put(E e)
插入元素的逻辑很简单，用ReentrantLock来保证线程安全，当队列满时，则调用线程会在 notFull 条件队列上等待，否则就调用 enqueue 方法入队。
/**
* 在队尾插入指定元素，如果队列已满，则阻塞线程.
*/
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly(); // 加锁
try {
while (count == items.length) // 队列已满。这里必须用while，防止虚假唤醒
notFull.await(); // 在notFull队列上等待
enqueue(e); // 队列未满, 直接入队
} finally {
lock.unlock();
}
}
这里需要注意一点，队列已满的时候，是通过while循环判断的,这其实是多线程设计模式中的Guarded Suspension模式：
while (count == items.length) // 队列已满。这里必须用while，防止虚假唤醒
notFull.await(); // 在notFull队列上等待
之所以这样做，是防止线程被意外唤醒，不经再次判断就直接调用 enqueue 方法。
enqueue 方法：
private void enqueue(E x) {
final Object[] items = this.items;
items[putIndex] = x;
if (++putIndex == items.length) // 队列已满,则重置索引为0
putIndex = 0;
count++; // 元素个数+1
notEmpty.signal(); // 唤醒一个notEmpty上的等待线程(可以来队列取元素了)
}
删除元素——take()
删除元素的逻辑和插入元素类似，区别就是：删除元素时，如果队列空了，则线程需要在notEmpty条件队列上等待。
/**
* 从队首删除一个元素, 如果队列为空, 则阻塞线程
*/
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0) // 队列为空, 则线程在notEmpty条件队列等待
notEmpty.await();
return dequeue(); // 队列非空，则出队一个元素
} finally {
lock.unlock();
}
}
队列非空时，调用dequeue方法出队一个元素：
private E dequeue() {
final Object[] items = this.items;
E x = (E) items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length) // 如果队列已空
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
notFull.signal(); // 唤醒一个notFull上的等待线程(可以插入元素到队列了)
return x;
}
2.3 环形队列
从上面的入队/出队操作，可以看出，ArrayBlockingQueue的内部数组其实是一种环形结构。
假设ArrayBlockingQueue的容量大小为6，我们来看下整个入队过程：
①初始时
②插入元素“9”
③插入元素“2”、“10”、“25”、“93”
④插入元素“90”
注意，此时再插入一个元素“90”，则putIndex变成6，等于队列容量6，由于是循环队列，所以会将tableIndex重置为0：
这是队列已经满了（count==6），如果再有线程尝试插入元素，并不会覆盖原有值，而是被阻塞。
我们再来看下出队过程：
①出队元素“9”
②出队元素“2”、“10”、“25”、“93”
③出队元素“90”
注意，此时再出队一个元素“90”，则tabeIndex变成6，等于队列容量6，由于是循环队列，所以会将tableIndex重置为0：
这是队列已经空了（count==0），如果再有线程尝试出队元素，则会被阻塞。
三、总结
ArrayBlockingQueue利用了ReentrantLock来保证线程的安全性，针对队列的修改都需要加全局锁。在一般的应用场景下已经足够。对于超高并发的环境，由于生产者-消息者共用一把锁，可能出现性能瓶颈。
另外，由于ArrayBlockingQueue是有界的，且在初始时指定队列大小，所以如果初始时需要限定消息队列的大小，则ArrayBlockingQueue 比较合适。
后续，我们会介绍另一种基于单链表实现的阻塞队列—— LinkedBlockingQueue ，该队列的最大特点是使用了“两把锁”，以提升吞吐量。
Java 面试宝典是大明哥全力打造的 Java 精品面试题，它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题，而是一套完整的 Java 知识体系，一套你 Java 知识点的扫盲贴。
它的内容包括：
- 大厂真题：Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
- 原创内容：Java 面试宝典内容全部都是大明哥原创，内容全面且通俗易懂，回答部分可以直接作为面试回答内容。
- 持续更新：一次购买，永久有效。大明哥会持续更新 3+ 年，累计更新 1000+，宝典会不断迭代更新，保证最新、最全面。
- 覆盖全面：本宝典累计更新 1000+，从 Java 入门到 Java 架构的高频面试题，实现 360° 全覆盖。
- 不止面试：内容包含面试题解析、内容详解、知识扩展，它不仅仅只是一份面试题，更是一套完整的 Java 知识体系。
- 宝典详情：https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
- 宝典总览：https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
- 宝典进展：https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw
目前 Java 面试宝典累计更新 400+ 道，总字数 42w+。大明哥还在持续更新中，下图是大明哥在 2024-12 月份的更新情况：
想了解详情的小伙伴，扫描下面二维码加大明哥微信【daming091】咨询
同时，大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ，回复【面试题】 即可免费领取。
