BlockingQueue队列
BlockingQueue，是java.util.concurrent 包提供的用于解决并发生产者 - 消费者问题的最有用的类，它的特性是在任意时刻只有一个线程可以进行take或者put操作，并且BlockingQueue提供了超时return
null的机制，在许多生产场景里都可以看到这个工具的身影
应用场景
BlockingQueue 是线程安全的，我们在很多场景下都可以利用线程安全的队列来优雅地解决我们业务自身的线程安全问题。比如说，使用生产者/消费者模式的时候，我们生产者只需要往队列里添加元素，而消费者只需
要从队列里取出它们就可以了，如图所示：
因为阻塞队列是线程安全的，所以生产者和消费者都可以是多线程的，不会发生线程安全问题。生产者/消费者直接使用线程安全的队列就可以，而不需要自己去考虑更多的线程安全问题。这也就意味着，考虑锁等线程安全
问题的重任从“你”转移到了“队列”上，降低了我们开发的难度和工作量。
同时，队列它还能起到一个隔离的作用。比如说我们开发一个银行转账的程序，那么生产者线程不需要关心具体的转账逻辑，只需要把转账任务，如账户和金额等信息放到队列中就可以，而不需要去关心银行这个类如何实
现具体的转账业务。而作为银行这个类来讲，它会去从队列里取出来将要执行的具体的任务，再去通过自己的各种方法来完成本次转账。这样就实现了具体任务与执行任务类之间的解耦，任务被放在了阻塞队列中，而负责
放任务的线程是无法直接访问到我们银行具体实现转账操作的对象的，实现了隔离，提高了安全性。
常用堵塞队列
队列类型
无限队列 （unbounded queue ） - 几乎可以无限增长
有限队列 （ bounded queue ） - 定义了最大容量
队列数据结构
队列实质就是一种存储数据的结构
通常用链表或者数组实现
一般而言队列具备FIFO先进先出的特性，当然也有双端队列（Deque）优先级队列
主要操作：入队（EnQueue）与出队（Dequeue）
常见的4种阻塞队列
ArrayBlockingQueue 由数组支持的有界队列
LinkedBlockingQueue 由链接节点支持的可选有界队列
PriorityBlockingQueue 由优先级堆支持的无界优先级队列
DelayQueue 由优先级堆支持的、基于时间的调度队列
ArrayBlockingQueue
队列基于数组实现,容量大小在创建ArrayBlockingQueue对象时已定义好
数据结构如下图：
ArrayBlockingQueue是最典型的有界阻塞队列，其内部是用数组存储元素的，初始化时需要指定容量大小，利用 ReentrantLock 实现线程安全。
在生产者-消费者模型中使用时，如果生产速度和消费速度基本匹配的情况下，使用ArrayBlockingQueue是个不错选择；当如果生产速度远远大于消费速度，则会导致队列填满，大量生产线程被阻塞。 使用独占锁ReentrantLock实现线程安全，入队和出队操作使用同一个锁对象，也就是只能有一个线程可以进行入队或者出队操作；这也就意味着生产者和消费者无法并行操作，在高并发场景下会成为性能瓶颈
队列创建： BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(); 应用场景 在线程池中有比较多的应用，生产者消费者场景 工作原理 基于ReentrantLock保证线程安全，根据Condition实现队列满时的阻塞
LinkedBlockingQueue
inkedBlockingQueue是一个基于链表实现的阻塞队列，默认情况下，该阻塞队列的大小为Integer.MAX_VALUE，由于这个数值特别大，所以 LinkedBlockingQueue 也被称作无界队列，代表它几乎没有界限，队列
可以随着元素的添加而动态增长，但是如果没有剩余内存，则队列将抛出OOM错误。所以为了避免队列过大造成机器负载或者内存爆满的情况出现，我们在使用的时候建议手动传一个队列的大小。
LinkedBlockingQueue内部由单链表实现，只能从head取元素，从tail添加元素。LinkedBlockingQueue采用两把锁的锁分离技术实现入队出队互不阻塞，添加元素和获取元素都有独立的锁，也就是说
LinkedBlockingQueue是读写分离的，读写操作可以并行执行
是一个基于链表的无界队列(理论上有界) BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(); 上面这段代码中，blockingQueue 的容量将设置为 Integer.MAX_VALUE 。
向无限队列添加元素的所有操作都将永远不会阻塞，[注意这里不是说不会加锁保证线程安全]，因此它可以增长到非常大的容量。
使用无限 BlockingQueue 设计生产者 - 消费者模型时最重要的是 消费者应该能够像生产者向队列添加消息一样快地消费消息 。否则，内存可能会填满，然后就会得到一个 OutOfMemory 异常
LinkedBlockingQueue与ArrayBlockingQueue对比
LinkedBlockingQueue是一个阻塞队列，内部由两个ReentrantLock来实现出入队列的线程安全，由各自的Condition对象的await和signal来实现等待和唤醒功能。它和ArrayBlockingQueue的不同点在于：
队列大小有所不同，ArrayBlockingQueue是有界的初始化必须指定大小，而LinkedBlockingQueue可以是有界的也可以是无界的(Integer.MAX_VALUE)，对于后者而言，当添加速度大于移除速度时，在无界的情况
下，可能会造成内存溢出等问题。
数据存储容器不同，ArrayBlockingQueue采用的是数组作为数据存储容器，而LinkedBlockingQueue采用的则是以Node节点作为连接对象的链表。
由于ArrayBlockingQueue采用的是数组的存储容器，因此在插入或删除元素时不会产生或销毁任何额外的对象实例，而LinkedBlockingQueue则会生成一个额外的Node对象。这可能在长时间内需要高效并发地处理大
批量数据的时，对于GC可能存在较大影响。
两者的实现队列添加或移除的锁不一样，ArrayBlockingQueue实现的队列中的锁是没有分离的，即添加操作和移除操作采用的同一个ReenterLock锁，而LinkedBlockingQueue实现的队列中的锁是分离的，其添加
采用的是putLock，移除采用的则是takeLock，这样能大大提高队列的吞吐量，也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。
SynchronousQueue
SynchronousQueue是一个没有数据缓冲的BlockingQueue，生产者线程对其的插入操作put必须等待消费者的移除操作take。
如图所示，SynchronousQueue 最大的不同之处在于，它的容量为 0，所以没有一个地方来暂存元素，导致每次取数据都要先阻塞，直到有数据被放入；同理，每次放数据的时候也会阻塞，直到有消费者来取。
需要注意的是，SynchronousQueue 的容量不是 1 而是 0，因为 SynchronousQueue 不需要去持有元素，它所做的就是直接传递（direct handoff）。由于每当需要传递的时候，SynchronousQueue 会把元素
直接从生产者传给消费者，在此期间并不需要做存储，所以如果运用得当，它的效率是很高的
应用场景
SynchronousQueue非常适合传递性场景做交换工作，生产者的线程和消费者的线程同步传递某些信息、事件或者任务。
SynchronousQueue的一个使用场景是在线程池里。如果我们不确定来自生产者请求数量，但是这些请求需要很快的处理掉，那么配合SynchronousQueue为每个生产者请求分配一个消费线程是处理效率最高的办法。
Executors.newCachedThreadPool()就使用了SynchronousQueue，这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。
SynchronousQueue使用 BlockingQueue<Integer> synchronousQueue = new SynchronousQueue<>();
PriorityBlockingQueue
PriorityBlockingQueue是一个无界的基于数组的优先级阻塞队列，数组的默认长度是11，虽然指定了数组的长度，但是可以无限的扩充，直到资源消耗尽为止，每次出队都返回优先级别最高的或者最低的元素。默认
情况下元素采用自然顺序升序排序，当然我们也可以通过构造函数来指定Comparator来对元素进行排序。需要注意的是PriorityBlockingQueue不能保证同优先级元素的顺序。
优先级队列PriorityQueue： 队列中每个元素都有一个优先级，出队的时候，优先级最高的先出
应用场景 电商抢购活动，会员级别高的用户优先抢购到商品 银行办理业务，vip客户插队 PriorityBlockingQueue使用 //创建优先级阻塞队列 Comparator为null,自然排序 PriorityBlockingQueue<Integer> queue=new PriorityBlockingQueue<Integer>(5); //自定义Comparator PriorityBlockingQueue queue=new PriorityBlockingQueue<Integer>( 5, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o2-o1; }
DelayQueue
DelayQueue 是一个支持延时获取元素的阻塞队列， 内部采用优先队列 PriorityQueue 存储元素，同时元素必须实现 Delayed 接口；在创建元素时可以指定多久才可以从队列中获取当前元素，只有在延迟期满时才
能从队列中提取元素。延迟队列的特点是：不是先进先出，而是会按照延迟时间的长短来排序，下一个即将执行的任务会排到队列的最前面。
由优先级堆支持的、基于时间的调度队列，内部基于无界队列PriorityQueue实现，而无界队列基于数组的扩容实现。 队列创建：
BlockingQueue<String> blockingQueue = new DelayQueue(); 要求 入队的对象必须要实现Delayed接口,而Delayed集成自Comparable接口
应用场景
电影票
工作原理：
队列内部会根据时间优先级进行排序。延迟类线程池周期执行
BlockingQueue API
BlockingQueue 接口的所有方法可以分为两大类：负责向队列添加元素的方法和检索这些元素的方法。在队列满/空的情况下，来自这两个组的每个方法的行为都不同
添加元素
|
方法
|
说明
|
|
add()
|
如果插入成功则返回 true，否则抛出 IllegalStateException 异常
|
|
put()
|
将指定的元素插入队列，如果队列满了，那么会阻塞直到有空间插入
|
|
offer()
|
如果插入成功则返回 true，否则返回 false
|
|
offer(E e, long timeout, TimeUnit unit)
|
尝试将元素插入队列，如果队列已满，那么会阻塞直到有空间插入
|
检索元素
|
方法
|
说明
|
|
take()
|
获取队列的头部元素并将其删除，如果队列为空，则阻塞并等待元素变为可用
|
|
poll(long timeout, TimeUnit unit)
|
检索并删除队列的头部，如有必要，等待指定的等待时间以使元素可用，如果超时，则返回 null
|
入队： （1）offer(E e)：如果队列没满，返回true，如果队列已满，返回false（不阻塞） （2）offer(E e, long timeout, TimeUnit unit)：可以设置阻塞时间，如果队列已满，则进行阻 塞。超过阻塞时间，则返回false （3）put(E e)：队列没满的时候是正常的插入，如果队列已满，则阻塞，直至队列空出位置 出队： （1）poll()：如果有数据，出队，如果没有数据，返回null （不阻塞） （2）poll(long timeout, TimeUnit unit)：可以设置阻塞时间，如果没有数据，则阻塞，超过 阻塞时间，则返回null （3）take()：队列里有数据会正常取出数据并删除；但是如果队列里无数据，则阻塞，直到队 列里有数据 当队列满了无法添加元素，或者是队列空了无法移除元素时： 1. 抛出异常：add、remove、element 2. 返回结果但不抛出异常：offer、poll、peek 3. 阻塞：put、take
BlockingQueue常用方法示例 当队列满了无法添加元素，或者是队列空了无法移除元素时：
1. 抛出异常：add、remove、element
2. 返回结果但不抛出异常：offer、poll、peek
3. 阻塞：put、take
public class BlockingQueueTest { public static void main(String[] args) { addTest(); } /** * add 方法是往队列里添加一个元素，如果队列满了，就会抛出异常来提示队列已满。 */ private static void addTest() { BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2); System.out.println(blockingQueue.add(1)); System.out.println(blockingQueue.add(2)); System.out.println(blockingQueue.add(3)); } /** * remove 方法的作用是删除元素并返回队列的头节点，如果删除的队列是空的， remove 方法就会抛出异常。 */ private static void removeTest() { ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2); blockingQueue.add(1); blockingQueue.add(2); System.out.println(blockingQueue.remove()); System.out.println(blockingQueue.remove()); System.out.println(blockingQueue.remove()); } /** * element 方法是返回队列的头部节点，但是并不删除。如果队列为空，抛出异常 */ private static void elementTest() { ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2); blockingQueue.element(); } /** * offer 方法用来插入一个元素。如果添加成功会返回 true，而如果队列已经满了，返回false */ private static void offerTest(){ ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2); System.out.println(blockingQueue.offer(1)); System.out.println(blockingQueue.offer(2)); System.out.println(blockingQueue.offer(3)); } /** * poll 方法作用也是移除并返回队列的头节点。 如果队列为空，返回null */ private static void pollTest() { ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(3); blockingQueue.offer(1); blockingQueue.offer(2); blockingQueue.offer(3); System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); System.out.println(blockingQueue.poll()); } /** * peek 方法返回队列的头元素但并不删除。 如果队列为空，返回null */ private static void peekTest() { ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2); System.out.println(blockingQueue.peek()); } /** * put 方法的作用是插入元素。如果队列已满就无法继续插入,阻塞插入线程，直至队列空出位置 */ private static void putTest(){ BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2); try { blockingQueue.put(1); blockingQueue.put(2); blockingQueue.put(3); } catch (InterruptedException e) { e.printStackTrace(); } } /** * take 方法的作用是获取并移除队列的头结点。如果执队列里无数据，则阻塞，直到队列里有数据 */ private static void takeTest(){ BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2); try { blockingQueue.take(); } catch (InterruptedException e) { e.printStackTrace(); } }
阻塞队列特性
多线程生产者-消费者示例
接下来我们创建一个由两部分组成的程序 - 生产者 ( Producer ) 和消费者 ( Consumer ) 。 生产者将生成一个 0 到 100 的随机数(十全大补丸的编号)，并将该数字放在 BlockingQueue 中。我们将创建 16 个线程（潘金莲）用于生成随机数并使用 put() 方法阻塞，直到队列中有可用空间。 需要记住的重要一点是，我们需要阻止我们的消费者线程无限期地等待元素出现在队列中。 从生产者(潘金莲)向消费者(武大郎)发出信号的好方法是，不需要处理消息，而是发送称为毒 （ poison ） 丸 （ pill ） 的特殊消息。 我们需要发送尽可能多的毒 （ poison ） 丸 （ pill ） ，因为我们有
消费者(武大郎)。然后当消费者从队列中获取特殊的毒 （ poison ） 丸 （ pill ）消息时，它将优雅地完成执行。
以下生产者的代码： @Slf4j public class NumbersProducer implements Runnable { private BlockingQueue<Integer> numbersQueue; private final int poisonPill; private final int poisonPillPerProducer; public NumbersProducer(BlockingQueue<Integer> numbersQueue, int poisonPill, int poisonPillPerProducer) { this.numbersQueue = numbersQueue; this.poisonPill = poisonPill; this.poisonPillPerProducer = poisonPillPerProducer; } public void run() { try { generateNumbers(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } private void generateNumbers() throws InterruptedException { for (int i = 0; i < 100; i++) { numbersQueue.put(ThreadLocalRandom.current().nextInt(100)); log.info("潘金莲-{}号,给武大郎的泡药！",Thread.currentThread().getId()); } for (int j = 0; j < poisonPillPerProducer; j++) { numbersQueue.put(poisonPill); log.info("潘金莲-{}号,往武大郎的药里放入第{}颗毒丸！",Thread.currentThread().getId(),j+1); } } }
我们的生成器构造函数将 BlockingQueue 作为参数，用于协调生产者和使用者之间的处理。我们看到方法 generateNumbers() 将 100 个元素（生产100副药给武大郎吃）放入队列中。它还需要有毒
（ poison ） 丸 （ pill ） （潘金莲给武大郎下毒）消息，以便知道在执行完成时放入队列的消息类型。该消息需要将 poisonPillPerProducer 次放入队列中。 每个消费者将使用 take() 方法从 BlockingQueue 获取一个元素，因此它将阻塞，直到队列中有一个元素。从队列中取出一个 Integer 后，它会检查该消息是否是毒 （ poison ） 丸 （ pill ）
（武大郎看潘金莲有没有下毒） ，如果是，则完成一个线程的执行。否则，它将在标准输出上打印出结果以及当前线程的名称。
@Slf4j public class NumbersConsumer implements Runnable { private BlockingQueue<Integer> queue; private final int poisonPill; public NumbersConsumer(BlockingQueue<Integer> queue, int poisonPill) { this.queue = queue; this.poisonPill = poisonPill; } public void run() { try { while (true) { Integer number = queue.take(); if (number.equals(poisonPill)) { return; } log.info("武大郎-{}号,喝药-编号:{}",Thread.currentThread().getId(),number); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }
需要注意的重要事项是队列的使用。与生成器构造函数中的相同，队列作为参数传递。我们可以这样做，是因为 BlockingQueue 可以在线程之间共享而无需任何显式同步。 既然我们有生产者和消费者，我们就可以开始我们的计划。我们需要定义队列的容量，并将其设置为 10个元素。 我们创建4 个生产者线程，并且创建等于可用处理器数量的消费者线程：
public class Main { public static void main(String[] args) { int BOUND = 10; int N_PRODUCERS = 16; int N_CONSUMERS = Runtime.getRuntime().availableProcessors(); int poisonPill = Integer.MAX_VALUE; int poisonPillPerProducer = N_CONSUMERS / N_PRODUCERS; int mod = N_CONSUMERS % N_PRODUCERS; BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(BOUND); //潘金莲给武大郎熬药 for (int i = 1; i < N_PRODUCERS; i++) { new Thread(new NumbersProducer(queue, poisonPill, poisonPillPerProducer)).start(); } //武大郎开始喝药 for (int j = 0; j < N_CONSUMERS; j++) { new Thread(new NumbersConsumer(queue, poisonPill)).start(); } //潘金莲开始投毒，武大郎喝完毒药GG new Thread(new NumbersProducer(queue, poisonPill, poisonPillPerProducer + mod)).start(); } }
BlockingQueue 是使用具有容量的构造创建的。我们正在创造 4 个生产者和 N 个消费者（武大郎）。我们将我们的毒 （ poison ） 丸 （ pill ）消息指定为 Integer.MAX_VALUE，因为我们的生产者在正常
工作条件下永远不会发送这样的值。这里要注意的最重要的事情是 BlockingQueue 用于协调它们之间的工作。
浙公网安备 33010602011771号