BlockingQueue队列大讲解

亦凉 2022-01-11 05:07 121阅读 0赞

# **更多多线程知识访问 [www.itkc8.com][]** #

[https://blog.csdn.net/qq\_42135428/article/details/80285737][https_blog.csdn.net_qq_42135428_article_details_80285737]

# 1：BlockingQueue继承关系 #

java.util.concurrent 包里的 BlockingQueue是一个接口， 继承Queue接口，Queue接口继承 Collection

** ** BlockingQueue----->Queue-->Collection

图：

![20.jpg][]

队列的特点是：先进先出（FIFO）

# 2：BlockingQueue的方法 #

BlockingQueue 具有 4 组不同的方法用于插入、移除以及对队列中的元素进行检查。如果请求的操作不能得到立即执行的话，每个方法的表现也不同。这些方法如下：

<table> 
 <tbody> 
  <tr> 
   <td>&nbsp;</td> 
   <td><em>抛出异常</em></td> 
   <td><em>特殊值</em></td> 
   <td><em>阻塞</em></td> 
   <td><em>超时</em></td> 
  </tr> 
  <tr> 
   <td><strong>插入</strong></td> 
   <td><code>add(e)</code></td> 
   <td><code>offer(e)</code></td> 
   <td><code>put(e)</code></td> 
   <td><code>offer(e, time, unit)</code></td> 
  </tr> 
  <tr> 
   <td><strong>移除</strong></td> 
   <td><code>remove()</code></td> 
   <td><code>poll()</code></td> 
   <td><code>take()</code></td> 
   <td><code>poll(time, unit)</code></td> 
  </tr> 
  <tr> 
   <td><strong>检查</strong></td> 
   <td><code>element()</code></td> 
   <td><code>peek()</code></td> 
   <td><em>不可用</em></td> 
   <td><em>不可用</em><br> &nbsp;</td> 
  </tr> 
 </tbody> 
</table>

四组不同的行为方式解释:

1（异常）

如果试图的操作无法立即执行，抛一个异常。

2（特定值）

如果试图的操作无法立即执行，返回一个特定的值(常常是 true / false)。

3(阻塞)

如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行。

4（超时）

如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行，但等待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是 true / false)。

不能向BlockingQueue插入一个空对象，否则会抛出NullPointerException，相应的实现类校验代码

1.  `private static void checkNotNull(Object v) {`
2.  `        if (v == null)`
3.  `            throw new NullPointerException();`
4.  `    }`

**BlockingQueue ：不接受 null 元素。试图 add、put 或 offer 一个 null 元素时，某些实现会抛出 NullPointerException。null 被用作指示 poll 操作失败的警戒值。**

**BlockingQueue： 可以是限定容量的。它在任意给定时间都可以有一个 remainingCapacity，超出此容量，便无法无阻塞地 put 附加元素。没有任何内部容量约束的 BlockingQueue 总是报告Integer.MAX\_VALUE 的剩余容量。**

**BlockingQueue ：****实现主要用于生产者-使用者队列，但它另外还支持 `Collection` 接口****。因此，举例来说，使用 remove(x) 从队列中移除任意一个元素是有可能的。然而，这种操作通常*不* 会有效执行，只能有计划地偶尔使用，比如在取消排队信息时。**

**BlockingQueue ：实现是线程安全的。所有排队方法都可以使用内部锁或其他形式的并发控制来自动达到它们的目的。然而，*大量的* Collection 操作（addAll、containsAll、retainAll 和removeAll）*没有* 必要自动执行，除非在实现中特别说明。因此，举例来说，在只添加了 c 中的一些元素后，addAll(c) 有可能失败（抛出一个异常）。**

BlockingQueue 实质上*不* 支持使用任何一种“close”或“shutdown”操作来指示不再添加任何项。这种功能的需求和使用有依赖于实现的倾向。例如，一种常用的策略是：对于生产者，插入特殊的 *end-of-stream* 或 *poison* 对象，并根据使用者获取这些对象的时间来对它们进行解释。

![11.jpg][]

# 3:BlockingQueue实现类和继承接口 #

**   ArrayBlockingQueue**

**    DelayQueue**

**    LinkedBlockingQueue**

**    PriorityBlockingQueue**

**    SynchronousQueue**

继承他的接口：

**   ****public interface** BlockingDeque **extends** BlockingQueue, Deque 1.6新增

**   public** **interface** TransferQueue **extends** BlockingQueue           1.7新增

# 4：BlockingQueue用法 #

BlockingQueue 通常用于一个线程生产对象，而另外一个线程消费这些对象的场景。下图是对这个原理的阐述：

![b.png][]

一个线程往里边放，另外一个线程从里边取的一个 BlockingQueue。

一个线程将会持续生产新对象并将其插入到队列之中，直到队列达到它所能容纳的临界点。也就是说，它是有限的。如果该阻塞队列到达了其临界点，负责生产的线程将会在往里边插入新对象时发生阻塞。它会一直处于阻塞之中，直到负责消费的线程从队列中拿走一个对象。

负责消费的线程将会一直从该阻塞队列中拿出对象。如果消费线程尝试去从一个空的队列中提取对象的话，这个消费线程将会处于阻塞之中，直到一个生产线程把一个对象丢进队列。

# 5:BlockingQueue Example #

public class BlockingQueueExample {
    
        public static void main(String[] args) throws Exception {
    
            BlockingQueue queue = new ArrayBlockingQueue(1024);
    
            Producer producer = new Producer(queue);
            Consumer consumer = new Consumer(queue);
    
            new Thread(producer).start();
            new Thread(consumer).start();
    
            Thread.sleep(4000);
        }
    }

public class Producer implements Runnable{
    
        protected BlockingQueue queue = null;
    
        public Producer(BlockingQueue queue) {
            this.queue = queue;
        }
    
        public void run() {
            try {
                queue.put("1");
                Thread.sleep(1000);
                queue.put("2");
                Thread.sleep(1000);
                queue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

public class Consumer implements Runnable{
    
        protected BlockingQueue queue = null;
    
        public Consumer(BlockingQueue queue) {
            this.queue = queue;
        }
    
        public void run() {
            try {
                System.out.println(queue.take());
                System.out.println(queue.take());
                System.out.println(queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

# 6:BlockingQueue实现类详解 #

## 1  数组阻塞队列 ArrayBlockingQueue ##

## 一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部 是在队列中存在时间最长的元素。队列的尾部 是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列获取操作则是从队列头部开始获得元素。 ##

这是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区，就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞；试图从空队列中提取元素将导致类似阻塞。

此类支持对等待的生产者线程和使用者线程进行排序的可选公平策略。默认情况下，不保证是这种排序。然而，通过将公平性 (fairness) 设置为 true 而构造的队列允许按照 FIFO 顺序访问线程。公平性通常会降低吞吐量，但也减少了可变性和避免了“不平衡性”

1.  `BlockingQueue queue = new ArrayBlockingQueue(1024);`
2.  `queue.put("1");String string = queue.take();`

## 2：延迟队列DelayQueue ##

Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部 是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且 poll 将返回 null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于等于 0 的值时，将发生到期。即使无法使用 take 或 poll 移除未到期的元素，也不会将这些元素作为正常元素对待。例如，size 方法同时返回到期和未到期元素的计数。此队列不允许使用 null 元素

**3. 链阻塞队列 LinkedBlockingQueue**

LinkedBlockingQueue 类实现了 BlockingQueue 接口。

LinkedBlockingQueue 内部以一个链式结构(链接节点)对其元素进行存储。如果需要的话，这一链式结构可以选择一个上限。如果没有定义上限，将使用 Integer.MAX\_VALUE 作为上限。

LinkedBlockingQueue 内部以 FIFO(先进先出)的顺序对元素进行存储。队列中的头元素在所有元素之中是放入时间最久的那个，而尾元素则是最短的那个。

1.  `BlockingQueue unbounded = new LinkedBlockingQueue();`
2.  `BlockingQueue bounded   = new LinkedBlockingQueue(1024);bounded.put("Value");`
3.  `String value = bounded.take();`
4.  `System.out.println(value);`
5.  `System.out.println(unbounded.remainingCapacity()==Integer.MAX_VALUE);//true`

# 4. 具有优先级的阻塞队列 PriorityBlockingQueue #

PriorityBlockingQueue 类实现了 BlockingQueue 接口。

一个无界阻塞队列，它使用与类 PriorityQueue 相同的顺序规则，并且提供了阻塞获取操作。虽然此队列逻辑上是无界的，但是资源被耗尽时试图执行 add 操作也将失败（导致OutOfMemoryError）。此类不允许使用 null 元素。依赖自然顺序的优先级队列也不允许插入不可比较的对象（这样做会导致抛出 ClassCastException）。

此类及其迭代器可以实现 Collection 和 Iterator 接口的所有可选 方法。iterator() 方法中提供的迭代器并不 保证以特定的顺序遍历 PriorityBlockingQueue 的元素。如果需要有序地进行遍历，则应考虑使用 Arrays.sort(pq.toArray())。此外，可以使用方法 drainTo 按优先级顺序移除 全部或部分元素，并将它们放在另一个 collection 中。

在此类上进行的操作不保证具有同等优先级的元素的顺序。如果需要实施某一排序，那么可以定义自定义类或者比较器，比较器可使用修改键断开主优先级值之间的联系。例如，以下是应用先进先出 (first-in-first-out) 规则断开可比较元素之间联系的一个类。要使用该类，则需要插入一个新的 FIFOEntry(anEntry) 来替换普通的条目对象。

#    5. 同步队列 SynchronousQueue #

SynchronousQueue 类实现了 BlockingQueue 接口。

SynchronousQueue 是一个特殊的队列，它的内部同时只能够容纳单个元素。如果该队列已有一元素的话，试图向队列中插入一个新元素的线程将会阻塞，直到另一个线程将该元素从队列中抽走。同样，如果该队列为空，试图向队列中抽取一个元素的线程将会阻塞，直到另一个线程向队列中插入了一条新的元素。

据此，把这个类称作一个队列显然是夸大其词了。它更多像是一个汇合点。

#    6. 阻塞双端队列 BlockingDeque #

java.util.concurrent 包里的 BlockingDeque 接口表示一个线程安放入和提取实例的双端队列。本小节我将给你演示如何使用 BlockingDeque。

BlockingDeque 类是一个双端队列，在不能够插入元素时，它将阻塞住试图插入元素的线程；在不能够抽取元素时，它将阻塞住试图抽取的线程。

deque(双端队列) 是 "Double Ended Queue" 的缩写。因此，双端队列是一个你可以从任意一端插入或者抽取元素的队列。

## 7. 链阻塞双端队列 LinkedBlockingDeque ##

一个基于已链接节点的、任选范围的阻塞双端队列。

可选的容量范围构造方法参数是一种防止过度膨胀的方式。如果未指定容量，那么容量将等于 Integer.MAX\_VALUE。只要插入元素不会使双端队列超出容量，每次插入后都将动态地创建链接节点。

大多数操作都以固定时间运行（不计阻塞消耗的时间）。异常包括 remove、removeFirstOccurrence、removeLastOccurrence、contains、iterator.remove() 以及批量操作，它们均以线性时间运行。

[www.itkc8.com]: http://www.itkc8.com
[https_blog.csdn.net_qq_42135428_article_details_80285737]: https://blog.csdn.net/qq_42135428/article/details/80285737
[20.jpg]: /images/20220111/5a746fd5d95f4715b1cf14c99e68d273.png
[11.jpg]: /images/20220111/97342464b73f46e4b2b6346f3d71ac0b.png
[b.png]: /images/20220111/5b94178e29214c139b5cdb1eb92ee81f.png