BlockingQueue
BlockingQueue
是Java并发包(java.util.concurrent)中提供的一个阻塞队列接口,它继承自 Queue
接口。
BlockingQueue
中的元素采用 FIFO 的原则,支持多线程环境并发访问,提供了阻塞读取和写入的操作,当前线程在队列满或空的情况下会被阻塞,直到被唤醒或超时。
常用的实现类有:
ArrayBlockingQueue
LinkedBlockingQueue
PriorityBlockingQueue
SynchronousQueue
LinkedBlockingDeque
:LinkedBlockingDeque 详解
等类,它们的实现方式各有不同。
适用场景
BlockingQueue 通常用于一个线程生产对象,而另外一个线程消费这些对象的场景。
一个线程将会持续生产新对象并将其插入到队列之中,直到队列达到它所能容纳的临界点。
如果该阻塞队列到达了其临界点,生产者线程将会在往里边插入新对象时发生阻塞。它会一直处于阻塞之中,直到消费者线程从队列中拿走一个对象。
消费者线程将会一直从该阻塞队列中拿出对象。如果消费线程尝试去从一个空的队列中提取对象的话,这个消费线程将会处于阻塞之中,直到一个生产线程把一个对象丢进队列。
常用方法
-
put(E e)
:将元素 e 插入到队列中,如果队列已满,则会阻塞当前线程,直到队列有空闲空间 -
offer(E e)
:将元素 e 插入到队列中,如果队列已满,则返回 false。 -
offer(E element, long timeout, TimeUnit unit)
方法是BlockingQueue
:在指定的时间内将元素添加到队列中。-
timeout
:超时时间,表示在指定的时间内等待队列空间可用。如果超过指定的时间仍然无法将元素添加到队列中,将返回 false。 -
unit
:超时时间的单位。
-
-
take()
:移除并返回队列头部的元素,如果队列为空,则会阻塞当前线程,直到队列有元素 -
poll()
:移除并返回队列头部的元素,如果队列为空,则返回null
-
poll(long timeout, TimeUnit unit)
:在指定的时间内从队列中检索并移除元素。返回移除的元素。如果超过指定的时间仍然没有可用的元素,将返回 null。 -
peek()
:返回队列头部的元素,但不会移除。如果队列为空,则返回null
-
size()
:返回队列中元素的数量 -
isEmpty()
:判断队列是否为空,为空返回 true,否则返回 false -
isFull()
:判断队列是否已满,已满返回 true,否则返回 false -
clear()
:清空队列中的所有元素
行为 | 抛异常 | 返回特定值 | 阻塞 | 超时 | |
---|---|---|---|---|---|
插入 | add(o) | offer(o) | put(o) | offer(o, timeout, timeunit) | |
移除 | remove() | poll() | take() | poll(timeout, timeunit) | |
检查 | element() | peek() |
-
抛异常: 如果试图的操作无法立即执行,抛一个异常。
-
特定值: 如果试图的操作无法立即执行,返回 true / false / null)。
-
阻塞: 如果试图的操作无法立即执行,该方法调用将会发生阻塞,直到能够执行。
-
超时: 如果试图的操作无法立即执行,该方法调用将会发生阻塞,直到能够执行,但等待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是 true / false)。
若向 BlockingQueue 中插入 null,将会抛出 NullPointerException
死锁问题
需要注意的是,在使用 BlockingQueue
时要注意防止死锁的问题:
-
在队列满之后调用
offer()
方法插入元素会返回false
,此时不能直接调用put()
方法,因为在插入之前还需要获取其它资源,如果在获取资源时一直阻塞在这里,就会发生死锁。 -
为了防止死锁的问题,建议使用
offer(E e, long timeout, TimeUnit unit)
和poll(long timeout, TimeUnit unit)
带有超时时间的方法。
LinkedBlockingQueue
LinkedBlockingQueue
是 Java 中的一个线程安全的阻塞队列实现。实现了 BlockingQueue 接口,并使用链表作为底层数据结构,可以用于在生产者和消费者之间进行线程安全的数据传输。
特点
-
队列容量:LinkedBlockingQueue 可以选择指定容量,也可以不指定容量(默认为 Integer.MAX_VALUE),即可以是有界队列或无界队列。
-
先进先出(FIFO):队列遵循先进先出的原则,即先入队的元素会先出队。
-
阻塞操作:当队列为空时,消费者线程调用
take()
方法将被阻塞,直到有元素可用;当队列满时,生产者线程调用put()
方法将被阻塞,直到队列有空间。 -
链表实现:LinkedBlockingQueue 使用链表作为内部实现,这个链表由一系列的节点组成,每个节点都包含了一个元素以及指向下一个节点的引用。队列的头部和尾部都维护了对这些节点的引用,以便进行高效的入队和出队操作。
-
线程安全:
LinkedBlockingQueue
内部通过锁机制确保了线程安全,所有公共方法都是原子的。
使用场景
-
生产者-消费者模式:
LinkedBlockingQueue
可以作为生产者和消费者之间的缓冲区,生产者将产品放入队列,消费者从队列中获取产品进行处理。 -
线程池:线程池中的任务队列一般使用
LinkedBlockingQueue
实现,线程池根据需要动态地创建和销毁线程,将任务放入队列中,让线程从队列中获取任务进行处理。 -
任务调度:
LinkedBlockingQueue
可以作为任务调度的工具,将需要执行的任务放入队列中,再由任务调度器从队列中获取任务并执行。
构造方法
- 创建初始容量为
Integer.MAX_VALUE
的无界队列。
LinkedBlockingQueue()
- 创建指定容量的有界队列。如果队列已满,入队操作将会阻塞,直到队列中有空间。
LinkedBlockingQueue(int capacity)
LinkedBlockingQueue(Collection<? extends E> c)
: 创建队列,并将集合中元素按照顺序加入队列中,将队列大小初始化为元素的个数。
LinkedBlockingQueue(Collection<? extends E> collection)
LinkedBlockingQueue 使用示例
LinkedBlockingQueue
是 Java 并发包 java.util.concurrent
中的一个线程安全的阻塞队列实现,它基于链表结构存储数据,并且提供了阻塞操作,非常适合用于多线程环境下的数据交换和同步控制。
下面是一个使用 LinkedBlockingQueue
的简单示例,展示如何实现一个基本的生产者-消费者模型:
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
public class LinkedBlockingQueueExample {
public static void main(String[] args) {
// 创建一个最大容量为 10 的 LinkedBlockingQueue
LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>(10);
// 创建生产者线程
Thread producerThread = new Thread(() -> {
try {
for (int i = 0; i < 20; i++) {
String item = "Item " + i;
System.out.println("Producing: " + item);
// put 方法会在队列满的时候阻塞当前线程,直到有空间可用
queue.put(item);
TimeUnit.MILLISECONDS.sleep(200); // 模拟生产数据的时间间隔
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.out.println("Producer was interrupted");
}
});
// 创建消费者线程
Thread consumerThread = new Thread(() -> {
try {
for (int i = 0; i < 20; i++) {
String item = queue.take(); // take 方法会在队列空的时候阻塞当前线程,直到有数据可用
System.out.println("Consuming: " + item);
TimeUnit.MILLISECONDS.sleep(500); // 模拟消费数据的时间间隔
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.out.println("Consumer was interrupted");
}
});
// 启动线程
producerThread.start();
consumerThread.start();
// 等待线程结束
try {
producerThread.join();
consumerThread.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
在这个例子中,我们创建了一个最大容量为 10 的 LinkedBlockingQueue
。生产者线程会不断地尝试向队列中放入数据,而消费者线程则不断地尝试从中取出数据。当队列已满时,put
方法会让生产者线程等待,直到有空间可用;当队列为空时,take
方法会让消费者线程等待,直到有数据可用。这种机制保证了生产者和消费者之间的同步。