Java ArrayBlockingQueue 进阶指南：有界阻塞队列与线程安全操作

Java ArrayBlockingQueue

探索 Java ArrayBlockingQueue — 学习如何创建、操作并线程安全地使用此固定大小的阻塞队列，附清晰示例。

ArrayBlockingQueue 类在 Java 集合框架中提供有界、线程安全的队列，底层由数组支撑。它实现 BlockingQueue 接口，允许生产者和消费者通过阻塞操作协调。

创建 ArrayBlockingQueue

导入 java.util.concurrent.ArrayBlockingQueue 并指定固定容量实例化：

ArrayBlockingQueue<Type> queue = new ArrayBlockingQueue<>(capacity);

Type 为元素类型，capacity 为最大容量。

• 示例 — 容量 5 的 String 队列：

  ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

• 示例 — 容量 5 的 Integer 队列：

  ArrayBlockingQueue<Integer> ages = new ArrayBlockingQueue<>(5);

注意： 容量为必填，决定队列的有界大小。

ArrayBlockingQueue 的核心方法

该类实现 BlockingQueue 的所有插入、访问、移除方法。以下为最常用操作。

插入元素

• add(E e) — 添加元素；满时抛 IllegalStateException。
• offer(E e) — 添加元素；满时返回 false。

ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
animals.add("Dog");
animals.offer("Cat");
animals.offer("Horse");
System.out.println("ArrayBlockingQueue: " + animals);

输出： ArrayBlockingQueue: [Dog, Cat, Horse]

访问元素

• peek() — 获取队头不移除；空时返回 null。
• iterator() — 提供队列的快速失败迭代器。

String head = animals.peek();
System.out.println("队头元素: " + head);
Iterator<String> it = animals.iterator();
while (it.hasNext()) {
    System.out.print(it.next() + ", ");
}

输出： 队头元素: Dog 后跟元素列表。

移除元素

• remove() — 移除并返回队头；空时抛 NoSuchElementException。
• poll() — 移除并返回队头；空时返回 null。
• clear() — 清空队列。

String removed1 = animals.remove();
String removed2 = animals.poll();
animals.clear();
System.out.println("更新后的队列: " + animals);

输出： 更新后的队列: []

阻塞操作：put() 与 take()

这两个方法是生产者-消费者模式的关键。它们阻塞直到操作可执行，确保线程协调。

put()

插入元素，队列满时等待。可能抛 InterruptedException。

try {
    animals.put("Dog");
    animals.put("Cat");
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

take()

移除并返回队头，队列空时等待。可能抛 InterruptedException。

try {
    String element = animals.take();
    System.out.println("移除: " + element);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

其他便捷方法

为何选择 ArrayBlockingQueue？

因其提供：

• 线程安全： 内置同步支持并发访问。
• 固定大小：防止内存无序增长。
• 阻塞语义：简化生产者-消费者协调。

当生产者速度慢于消费者时，消费者自动阻塞，避免忙等待，保证 CPU 高效利用。