BlockingQueue
BlockingQueue 是Java并发包（java.util.concurrent）中提供的一个阻塞队列接口，它继承自 Queue 接口。
BlockingQueue 中的元素采用 FIFO 的原则，支持多线程环境并发访问，提供了阻塞读取和写入的操作，当前线程在队列满或空的情况下会被阻塞，直到被唤醒或超时。
常用的实现类有：
ArrayBlockingQueue：并发容器 ArrayBlockingQueue 详解LinkedBlockingQueuePriorityBlockingQueue：并发容器 PriorityBlockingQueue 详解SynchronousQueue：并发容器 SynchronousQueue 详解LinkedBlockingDeque：LinkedBlockingDeque 详解
等类，它们的实现方式各有不同。
适用场景
BlockingQueue 通常用于一个线程生产对象，而另外一个线程消费这些对象的场景。
![![[BlockingQueue Model.png]]](https://i-blog.csdnimg.cn/direct/0c191a20f0924184968e97717f76af8b.png)
一个线程将会持续生产新对象并将其插入到队列之中，直到队列达到它所能容纳的临界点。
如果该阻塞队列到达了其临界点，生产者线程将会在往里边插入新对象时发生阻塞。它会一直处于阻塞之中，直到消费者线程从队列中拿走一个对象。
消费者线程将会一直从该阻塞队列中拿出对象。如果消费线程尝试去从一个空的队列中提取对象的话，这个消费线程将会处于阻塞之中，直到一个生产线程把一个对象丢进队列。
常用方法
-
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 方法会让消费者线程等待，直到有数据可用。这种机制保证了生产者和消费者之间的同步。
