Java 并发编程中,java.util.concurrent
(简称 JUC)包提供了多种阻塞队列 (BlockingQueue
) 实现,包括 ArrayBlockingQueue
, PriorityBlockingQueue
, 和 DelayQueue
。这些队列特别设计用于多线程环境,可以提高并发程序的性能和安全性。下面将详细介绍这些阻塞队列的特点及其使用方式。
阻塞队列接口(BlockingQueue)
BlockingQueue
是一个接口,它扩展了 Queue
接口,并且增加了额外的方法来支持阻塞操作。主要的阻塞方法有:
void put(E e)
:插入一个元素到队列尾部,如果队列已满,则会阻塞,直到队列不再满。E take()
:移除队列头部的元素,并返回这个元素,如果队列为空,则会阻塞,直到队列不为空。
此外,还有一些非阻塞的方法,如 offer
和 poll
,它们在无法立即执行操作时返回 false
或 null
而不是阻塞。
ArrayBlockingQueue
ArrayBlockingQueue
是一个由数组支持的有界阻塞队列。此队列按 FIFO(先进先出)原则对元素进行排序。
特点:
- 固定大小,创建时需要指定队列的容量。
- 可选地支持公平性策略(即 FIFO 策略),默认是非公平的。
- 适用于需要固定容量的场景。
示例代码:
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ArrayBlockingQueueExample {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
// 生产者线程
Thread producer = new Thread(() -> {
try {
for (int i = 0; i < 5; i++) {
queue.put("item-" + i);
System.out.println("Produced: item-" + i);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
// 消费者线程
Thread consumer = new Thread(() -> {
try {
for (int i = 0; i < 5; i++) {
String item = queue.take();
System.out.println("Consumed: " + item);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
producer.start();
consumer.start();
producer.join();
consumer.join();
}
}
PriorityBlockingQueue
PriorityBlockingQueue
是一个无界的优先级阻塞队列。元素会按照自然顺序或者通过比较器进行排序。
特点:
- 元素按照优先级排序,优先级高的元素会被优先取出。
- 无界队列,但是可以使用构造函数设置最大容量。
- 如果没有设置最大容量,队列的大小只受限于系统内存。
示例代码:
import java.util.concurrent.PriorityBlockingQueue;
public class PriorityBlockingQueueExample {
public static void main(String[] args) {
PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();
// 生产者线程
Thread producer = new Thread(() -> {
for (int i = 0; i < 10; i++) {
queue.offer(i);
System.out.println("Produced: " + i);
}
});
// 消费者线程
Thread consumer = new Thread(() -> {
while (true) {
Integer item = queue.poll();
if (item == null) break;
System.out.println("Consumed: " + item);
}
});
producer.start();
consumer.start();
}
}
DelayQueue
DelayQueue
是一个使用 Delayed
类型元素的无界阻塞队列。队列中的元素只有当其延迟过期时才能被消费。
特点:
- 专用于存储实现了
Delayed
接口的对象。 - 队列中的元素只有在其规定的延迟时间到达之后才可被消费。
- 通常用于实现定时任务等场景。
示例代码:
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
public class DelayQueueExample {
public static void main(String[] args) {
DelayQueue<DelayedElement> queue = new DelayQueue<>();
// 添加元素
queue.add(new DelayedElement(5, TimeUnit.SECONDS));
queue.add(new DelayedElement(2, TimeUnit.SECONDS));
// 消费者线程
Thread consumer = new Thread(() -> {
while (true) {
DelayedElement element = queue.poll();
if (element == null) break;
System.out.println("Consumed after " + element.getDelay(TimeUnit.SECONDS) + " seconds");
}
});
consumer.start();
}
static class DelayedElement implements Delayed {
private final long triggerTime;
private final long delayTime;
public DelayedElement(long delay, TimeUnit unit) {
this.delayTime = unit.toMillis(delay);
this.triggerTime = System.currentTimeMillis() + delayTime;
}
@Override
public long getDelay(TimeUnit unit) {
return unit.convert(triggerTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
}
@Override
public int compareTo(Delayed o) {
return Long.compare(this.triggerTime, ((DelayedElement) o).triggerTime);
}
}
}
总结
这些阻塞队列各有特点,可以根据实际需求选择合适的队列类型。例如,如果你需要一个基于优先级的队列,可以选择 PriorityBlockingQueue
;如果你需要一个基于延迟的队列,可以选择 DelayQueue
;如果你需要一个有界队列,可以选择 ArrayBlockingQueue
。
在使用这些队列时,通常会结合生产者-消费者模型来实现线程间的同步和通信。这些队列可以有效地帮助管理线程间的同步问题,提高并发性能。