一、概述：

BlockingQueue作为线程容器，可以为线程同步提供有力的保障。

二、BlockingQueue定义的常用方法

1.BlockingQueue定义的常用方法如下:

  抛出异常 特殊值 阻塞 超时
插入 add(e) offer(e) put(e) offer(e, time, unit)
移除 remove() poll() take() poll(time, unit)
检查 element() peek() 不可用 不可用

1)add(anObject):把anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则招聘异常

2)offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.

3)put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续.

4)poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,取不到时返回null

5)take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止

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

三、BlockingQueue的几个注意点

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

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

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

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

四、简要概述BlockingQueue常用的四个实现类

1)ArrayBlockingQueue:规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的.

2)LinkedBlockingQueue:大小不定的BlockingQueue,若其构造函数带一个规定大小的参数,生成的BlockingQueue有大小限制,若不带大小参数,所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定.其所含的对象是以FIFO(先入先出)顺序排序的

3)PriorityBlockingQueue:类似于LinkedBlockQueue,但其所含对象的排序不是FIFO,而是依据对象的自然排序顺序或者是构造函数的Comparator决定的顺序.

4)SynchronousQueue:特殊的BlockingQueue,对其的操作必须是放和取交替完成的.

其中LinkedBlockingQueue和ArrayBlockingQueue比较起来,它们背后所用的数据结构不一样,导致LinkedBlockingQueue的数据吞吐量要大于ArrayBlockingQueue,但在线程数量很大时其性能的可预见性低于ArrayBlockingQueue.

五、具体BlockingQueue的实现类的内部细节

有耐心的同学请看具体实现类细节：

1、ArrayBlockingQueue

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

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

ArrayBlockingQueue创建的时候需要指定容量capacity(可以存储的最大的元素个数，因为它不会自动扩容)以及是否为公平锁(fair参数)。

在创建ArrayBlockingQueue的时候默认创建的是非公平锁，不过我们可以在它的构造函数里指定。这里调用ReentrantLock的构造函数创建锁的时候，调用了：

public ReentrantLock(boolean fair) {

sync = (fair)? new FairSync() : new NonfairSync();

}

FairSync/ NonfairSync是ReentrantLock的内部类：

线程按顺序请求获得公平锁，而一个非公平锁可以闯入，且当它尚未进入等待队列，就会和等待队列head结点的线程发生竞争，如果锁的状态可用，请求非公平锁的线程可在等待队列中向前跳跃，获得该锁。内部锁synchronized没有提供确定的公平性保证。

分三点来讲这个类：

2.1 添加新元素的方法：add/put/offer

2.2 该类的几个实例变量：takeIndex/putIndex/count/

2.3 Condition实现

1.1 添加新元素的方法：add/put/offer

首先，谈到添加元素的方法，首先得分析以下该类同步机制中用到的锁：

Java代码

  1. lock = new ReentrantLock(fair);

  2. notEmpty = lock.newCondition();//Condition Variable 1

  3. notFull = lock.newCondition();//Condition Variable 2

这三个都是该类的实例变量，只有一个锁lock，然后lock实例化出两个Condition，notEmpty/noFull分别用来协调多线程的读写操作。

Java代码

  1. public boolean offer(E e) {

  2. if (e == null) throw new NullPointerException();

  3. final ReentrantLock lock = this.lock;//每个对象对应一个显示的锁

  4. lock.lock();//请求锁直到获得锁（不可以被interrupte）

  5. try {

  6. if (count == items.length)//如果队列已经满了

  7. return false;

  8. else {

  9. insert(e);

  10. return true;

  11. }

  12. } finally {

  13. lock.unlock();//

  14. }

  15. }

  16. 看insert方法：

  17. private void insert(E x) {

  18. items[putIndex] = x;

  19. //增加全局index的值。

  20. /*

  21. Inc方法体内部：

  22. final int inc(int i) {

  23. return (++i == items.length)? 0 : i;

  24. }

  25. 这里可以看出ArrayBlockingQueue采用从前到后向内部数组插入的方式插入新元素的。如果插完了，putIndex可能重新变为0（在已经执行了移除操作的前提下，否则在之前的判断中队列为满）

  26. */

  27. putIndex = inc(putIndex);

  28. ++count;

  29. notEmpty.signal();//wake up one waiting thread

  30. }

Java代码

  1. public void put(E e) throws InterruptedException {

  2. if (e == null) throw new NullPointerException();

  3. final E[] items = this.items;

  4. final ReentrantLock lock = this.lock;

  5. lock.lockInterruptibly();//请求锁直到得到锁或者变为interrupted

  6. try {

  7. try {

  8. while (count == items.length)//如果满了，当前线程进入noFull对应的等waiting状态

  9. notFull.await();

  10. } catch (InterruptedException ie) {

  11. notFull.signal(); // propagate to non-interrupted thread

  12. throw ie;

  13. }

  14. insert(e);

  15. } finally {

  16. lock.unlock();

  17. }

  18. }

Java代码

  1. public boolean offer(E e, long timeout, TimeUnit unit)

  2. throws InterruptedException {

  3. if (e == null) throw new NullPointerException();

  4. long nanos = unit.toNanos(timeout);

  5. final ReentrantLock lock = this.lock;

  6. lock.lockInterruptibly();

  7. try {

  8. for (;;) {

  9. if (count != items.length) {

  10. insert(e);

  11. return true;

  12. }

  13. if (nanos <= 0)

  14. return false;

  15. try {

  16. //如果没有被 signal/interruptes,需要等待nanos时间才返回

  17. nanos = notFull.awaitNanos(nanos);

  18. } catch (InterruptedException ie) {

  19. notFull.signal(); // propagate to non-interrupted thread

  20. throw ie;

  21. }

  22. }

  23. } finally {

  24. lock.unlock();

  25. }

  26. }

Java代码

  1. public boolean add(E e) {

  2. return super.add(e);

  3. }

  4. 父类：

  5. public boolean add(E e) {

  6. if (offer(e))

  7. return true;

  8. else

  9. throw new IllegalStateException("Queue full");

  10. }

1.2 该类的几个实例变量：takeIndex/putIndex/count

Java代码

  1. 用三个数字来维护这个队列中的数据变更：

  2. /** items index for next take, poll or remove */

  3. private int takeIndex;

  4. /** items index for next put, offer, or add. */

  5. private int putIndex;

  6. /** Number of items in the queue */

  7. private int count;

提取元素的三个方法take/poll/remove内部都调用了这个方法：

Java代码

  1. private E extract() {

  2. final E[] items = this.items;

  3. E x = items[takeIndex];

  4. items[takeIndex] = null;//移除已经被提取出的元素

  5. takeIndex = inc(takeIndex);//策略和添加元素时相同

  6. --count;

  7. notFull.signal();//提醒其他在notFull这个Condition上waiting的线程可以尝试工作了

  8. return x;

  9. }

从这个方法里可见，tabkeIndex维护一个可以提取/移除元素的索引位置，因为takeIndex是从0递增的，所以这个类是FIFO队列。

putIndex维护一个可以插入的元素的位置索引。

count显然是维护队列中已经存在的元素总数。

1.3 Condition实现

Condition现在的实现只有java.util.concurrent.locks.AbstractQueueSynchoronizer内部的ConditionObject，并且通过ReentranLock的newCondition()方法暴露出来，这是因为Condition的await()/sinal()一般在lock.lock()与lock.unlock()之间执行，当执行condition.await()方法时，它会首先释放掉本线程持有的锁，然后自己进入等待队列。直到sinal()，唤醒后又会重新试图去拿到锁，拿到后执行await()下的代码，其中释放当前锁和得到当前锁都需要ReentranLock的tryAcquire(int arg)方法来判定，并且享受ReentranLock的重进入特性。

Java代码

  1. public final void await() throws InterruptedException {

  2. if (Thread.interrupted())

  3. throw new InterruptedException();

  4. //加一个新的condition等待节点

  5. Node node = addConditionWaiter();

  6. //释放自己的锁

  7. int savedState = fullyRelease(node);

  8. int interruptMode = 0;

  9. while (!isOnSyncQueue(node)) {

  10. //如果当前线程 等待状态时CONDITION，park住当前线程，等待condition的signal来解除

  11. LockSupport.park(this);

  12. if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)

  13. break;

  14. }

  15. if (acquireQueued(node, savedState) && interruptMode != THROW_IE)

  16. interruptMode = REINTERRUPT;

  17. if (node.nextWaiter != null)

  18. unlinkCancelledWaiters();

  19. if (interruptMode != 0)

  20. reportInterruptAfterWait(interruptMode);

  21. }

2、SynchronousQueue

一种阻塞队列，其中每个 put 必须等待一个 take，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。不能在同步队列上进行 peek，因为仅在试图要取得元素时，该元素才存在；除非另一个线程试图移除某个元素，否则也不能（使用任何方法）添加元素；也不能迭代队列，因为其中没有元素可用于迭代。队列的头 是尝试添加到队列中的首个已排队线程元素；如果没有已排队线程，则不添加元素并且头为 null。对于其他Collection 方法（例如 contains），SynchronousQueue 作为一个空集合。此队列不允许 null 元素。

同步队列类似于 CSP 和 Ada 中使用的 rendezvous 信道。它非常适合于传递性设计，在这种设计中，在一个线程中运行的对象要将某些信息、事件或任务传递给在另一个线程中运行的对象，它就必须与该对象同步。

对于正在等待的生产者和使用者线程而言，此类支持可选的公平排序策略。默认情况下不保证这种排序。但是，使用公平设置为 true 所构造的队列可保证线程以 FIFO 的顺序进行访问。公平通常会降低吞吐量，但是可以减小可变性并避免得不到服务。

3、LinkedBlockingQueue

一个基于已链接节点的、范围任意的 blocking queue。此队列按 FIFO（先进先出）排序元素。队列的头部 是在队列中时间最长的元素。队列的尾部 是在队列中时间最短的元素。新元素插入到队列的尾部，并且队列检索操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。

单向链表结构的队列。如果不指定容量默认为Integer.MAX_VALUE。通过putLock和takeLock两个锁进行同步，两个锁分别实例化notFull和notEmpty两个Condtion，用来协调多线程的存取动作。其中某些方法(如remove,toArray,toString,clear等)的同步需要同时获得这两个锁，并且总是先putLock.lock紧接着takeLock.lock(在同一方法fullyLock中)，这样的顺序是为了避免可能出现的死锁情况(我也想不明白为什么会是这样?)

4、PriorityBlockingQueue

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

看它的三个属性，就基本能看懂这个类了：

Java代码

  1. private final PriorityQueue q;

  2. private final ReentrantLock lock = new ReentrantLock(true);

  3. private final Condition notEmpty = lock.newCondition();

说明，本类内部数据结构是PriorityQueue，至于PriorityQueue怎么排序看之前一篇文章：http://jiadongkai-sina-com.iteye.com/blog/825683

lock说明本类使用一个lock来同步读写等操作。

notEmpty协调队列是否有新元素提供，而队列满了以后会调用PriorityQueue的grow方法来扩容。

5、DelayQueue

Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部 是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且 poll 将返回 null。当一个元素的getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满。此队列不允许使用 null 元素。

Delayed接口继承自Comparable,我们插入的E元素都要实现这个接口。

DelayQueue的设计目的间API文档：

An unbounded blocking queue of Delayed elements, in which an element can only be taken when its delay has expired. The head of the queue is that Delayed element whose delay expired furthest in the past. If no delay has expired there is no head and poll will returnnull. Expiration occurs when an element's getDelay(TimeUnit.NANOSECONDS) method returns a value less than or equal to zero. Even though unexpired elements cannot be removed using take or poll, they are otherwise treated as normal elements. For example, the size method returns the count of both expired and unexpired elements. This queue does not permit null elements.

因为DelayQueue构造函数了里限定死不允许传入comparator(之前的PriorityBlockingQueue中没有限定死)，即只能在compare方法里定义优先级的比较规则。再看上面这段英文，“The head of the queue is that Delayed element whose delay expired furthest in the past.”说明compare方法实现的时候要保证最先加入的元素最早结束延时。而 “Expiration occurs when an element's getDelay(TimeUnit.NANOSECONDS) method returns a value less than or equal to zero.”说明getDelay方法的实现必须保证延时到了返回的值变为<=0的int。

上面这段英文中，还说明了：在poll/take的时候，队列中元素会判定这个elment有没有达到超时时间，如果没有达到，poll返回null，而take进入等待状态。但是，除了这两个方法，队列中的元素会被当做正常的元素来对待。例如，size方法返回所有元素的数量，而不管它们有没有达到超时时间。而协调的Condition available只对take和poll是有意义的。

另外需要补充的是，在ScheduledThreadPoolExecutor中工作队列类型是它的内部类DelayedWorkQueue，而DelayedWorkQueue的Task容器是DelayQueue类型，而ScheduledFutureTask作为Delay的实现类作为Runnable的封装后的Task类。也就是说ScheduledThreadPoolExecutor是通过DelayQueue优先级判定规则来执行任务的。

6、BlockingDque+LinkedBlockingQueue

BlockingDque为阻塞双端队列接口，实现类有LinkedBlockingDque。双端队列特别之处是它首尾都可以操作。LinkedBlockingDque不同于LinkedBlockingQueue，它只用一个lock来维护读写操作，并由这个lock实例化出两个Condition notEmpty及notFull，而LinkedBlockingQueue读和写分别维护一个lock。

参考：
 Java线程(十三)：BlockingQueue-线程的阻塞队列 
http://blog.csdn.net/zzp_403184692/article/details/8021615
（13）多线程与并发库之java5阻塞队列(BlockingQueue)的应用----子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着再回到主线程循环100次，如此循环50次 
http://blog.csdn.net/itm_hadf/article/details/7538083 
线程----BlockingQueue (转)
http://www.cnblogs.com/likwo/archive/2010/07/01/1769199.html 
并发容器——BlockingQueue相关类
http://developer.51cto.com/art/201104/256805.htm 
 Java Concurrent包学习之BlockingQueue 
http://blog.csdn.net/derekjiang/article/details/5330019

Java多线程（五）之BlockingQueue深入分析相关推荐

  1. Java多线程(五) Lock接口,ReentranctLock,ReentrantReadWriteLock

    在JDK5里面,提供了一个Lock接口.该接口通过底层框架的形式为设计更面向对象.可更加细粒度控制线程代码.更灵活控制线程通信提供了基础.实现Lock接口且使用得比较多的是可重入锁(Reentrant ...

  2. Java多线程(五) —— 线程并发库之锁机制

    参考文献: http://www.blogjava.net/xylz/archive/2010/07/08/325587.html 一.Lock与ReentrantLock 前面的章节主要谈谈原子操作 ...

  3. java blockqueue_[Java基础] Java多线程-工具篇-BlockingQueue

    前言: 在新增的Concurrent包中,BlockingQueue很好的解决了多线程中,如何高效安全"传输"数据的问题.通过这些高效并且线程安全的队列类,为我们快速搭建高质量的多 ...

  4. Java多线程包之BlockingQueue

    2019独角兽企业重金招聘Python工程师标准>>> 在hadoop底层代码中,会看到有BlockingQueue的使用. 作为了解配置调优的作用,我也来了解一下BlockingQ ...

  5. java多线程-阻塞队列BlockingQueue

    大纲 BlockingQueue接口 ArrayBlockingQueue 一.BlockingQueue接口 public interface BlockingQueue<E> exte ...

  6. Java多线程闲聊（五）：AQS

    Java多线程闲聊(五):AQS 前言 今天的第二篇了,我肚子里也没有那么多的墨水,所以这第二篇的前言,就免了吧. 正文 AQS,AbstractQueueSynchronizer,是Java官方所提 ...

  7. JAVA多线程：守护线程 setDaemon全方位剖析| 守护线程是线程吗 |thread.isAlive()反思（五）

    前言 本文目的,通过短小精悍的实例,让你在最短时间,全面揭晓 thread.setDaemon(true)守护线程的使用,及其使用场景.一看就懂,一学就会! 概述 守护线程的作用 用来让其(这里暂称之 ...

  8. Android 价值千万java多线程同步 lt;五CountDownLatch（计数器）和Semaphore（信号量）

    1).Android 价值千万   java线程专题:Wait&notify&join&Yield http://blog.csdn.net/whb20081815/artic ...

  9. Java多线程总结（3）— Timer 和 TimerTask深入分析

    1. 基本概念   java.util.Timer:是一个实用工具类,该类用来调度一个线程(schedule a thread),使它可以在将来某一时刻执行. Java的Timer类可以调度一个任务运 ...

  10. Java多线程系列(五)：线程池的实现原理、优点与风险、以及四种线程池实现

    为什么需要线程池 我们有两种常见的创建线程的方法,一种是继承Thread类,一种是实现Runnable的接口,Thread类其实也是实现了Runnable接口.但是我们创建这两种线程在运行结束后都会被 ...

最新文章

  1. ASP.NET控件Repeater遍历
  2. Cannot convert type ‘ASP.login_aspx’ to ‘System.Web.UI.WebControls.Login’的解决方法
  3. java线程死锁 cpu 100%_一文学会Java死锁和CPU 100% 问题的排查技巧
  4. 单模光纤收发器产品介绍及常见分类方式
  5. 【奇技淫巧】在安卓模拟器中安装busybox
  6. Docker - 容器编排工具 compose 之安装
  7. 调试错误：ValueError: Protocol message Feature has no quot;featurequot; field.
  8. 网站技术架构发展之我见--[引子]
  9. [前端网站毕业设计源码]基于html的大学校园官网(jQuery)(静态网页)
  10. Python连接MySQL数据库
  11. 微信公众平台开发系列之必备知识
  12. 【饭谈】那些看似为公司着想，实际却很自私的故事 （一：造轮子）
  13. 我的创业你也可以复制：财务做账中常见的问题
  14. 基于中国剩余定理的秘密共享方案（miracl库）
  15. 连接超时计算机无法连接失败,爱思助手无法连接或者连接超时解决办法
  16. 为什么要将数据序列化？
  17. Spring的核心是什么？
  18. 【每日新闻】桥水达里奥：人工智能造成贫富差距 | 国产x86处理器开始生产：基于AMD Zen架构...
  19. android输入法切换
  20. ipv6 16进制转成10进制的数

热门文章

  1. 通用无线设备对码软件_电动车上的无线电池管理系统wBMS
  2. 用计算机连接路由器,用路由器怎么连接两台电脑
  3. android 打开免打扰模式_三星S10+免root也能完美使用Xp框架？这款神器你必须要知道...
  4. 计算机有哪两种绘图,能被计算机接受的数字图像有哪两种？它们分别由什么构成？...
  5. pb公共变量怎么找_阿迪达斯的4D怎么就火不起来呢？
  6. linux抓post命令,Linux 使用curl发起post请求的4个常用方式
  7. 微型计算机的三级存储体系是,简述存储系统的三级存储体系及分级的目的。
  8. vs2015 单元测试 linux,VS2015做单元测试
  9. linux7安装pgsql数据库,CentOS7下PostgreSQL安装
  10. 6工程文件夹作用_MCUXpresso IDE下SDK工程导入与workspace管理机制