Java多线程（五）之BlockingQueue深入分析

Posted 2023-05-18

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java多线程（五）之BlockingQueue深入分析相关的知识，希望对你有一定的参考价值。

参考技术A

　　 一概述

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

　　 二 BlockingQueue定义的常用方法

　　 BlockingQueue定义的常用方法如下

　　抛出异常特殊值阻塞超时

　　插入 add（e） offer（e） put（e） offer（e time unit）

　　移除 remove（） poll（） take（） poll（time unit）

　　检查 element（） peek（）不可用不可用

　　）add（anObject）把anObject加到BlockingQueue里即如果BlockingQueue可以容纳则返回true 否则招聘异常

　　）offer（anObject）表示如果可能的话将anObject加到BlockingQueue里即如果BlockingQueue可以容纳则返回true 否则返回false

　　）put（anObject）把anObject加到BlockingQueue里如果BlockQueue没有空间则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续

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

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

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

　　 三 BlockingQueue的几个注意点

　　【】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 对象并根据使用者获取这些对象的时间来对它们进行解释

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

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

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

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

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

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

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

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

　　 ArrayBlockingQueue

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

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

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

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

　　public ReentrantLock（boolean fair）

　　sync = （fair）？ new FairSync（） : new NonfairSync（）

　　FairSync/ NonfairSync是ReentrantLock的内部类

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

　　分三点来讲这个类

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

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

　　 Condition实现

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

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

　　 Java代码

　　[java]

　　lock = new ReentrantLock（fair）

　　notEmpty = lock newCondition（） //Condition Variable

　　notFull = lock newCondition（） //Condition Variable

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

　　Java代码

　　[java]

　　public boolean offer（E e）

　　if （e == null） throw new NullPointerException（）

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

　　lock lock（） //请求锁直到获得锁（不可以被interrupte）

　　try

　　if （count == items length）//如果队列已经满了

　　return false;

　　else

　　insert（e）

　　return true;

　　 finally

　　lock unlock（） //

　　看insert方法

　　private void insert（E x）

　　items[putIndex] = x;

　　//增加全局index的值

　　Inc方法体内部

　　final int inc（int i）

　　return （++i == items length）？ : i;

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

　　putIndex = inc（putIndex）

　　++count;

　　notEmpty signal（） //wake up one waiting thread

　　 Java代码

　　[java]

　　public void put（E e） throws InterruptedException

　　if （e == null） throw new NullPointerException（）

　　final E[] items = ems;

　　final ReentrantLock lock = this lock;

　　lock lockInterruptibly（） //请求锁直到得到锁或者变为interrupted

　　try

　　while （count == items length）//如果满了当前线程进入noFull对应的等waiting状态

　　notFull await（）

　　 catch （InterruptedException ie）

　　notFull signal（） // propagate to non interrupted thread

　　throw ie;

　　insert（e）

　　 finally

　　lock unlock（）

　　 Java代码

　　[java]

　　public boolean offer（E e long timeout TimeUnit unit）

　　throws InterruptedException

　　if （e == null） throw new NullPointerException（）

　　long nanos = unit toNanos（timeout）

　　final ReentrantLock lock = this lock;

　　lock lockInterruptibly（）

　　try

　　for （）

　　if （count != items length）

　　insert（e）

　　return true;

　　if （nanos <= ）

　　return false;

　　try

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

　　nanos = notFull awaitNanos（nanos）

　　 catch （InterruptedException ie）

　　notFull signal（） // propagate to non interrupted thread

　　throw ie;

　　 finally

　　lock unlock（）

　　 Java代码

　　[java]

　　public boolean add（E e）

　　return super add（e）

　　父类

　　public boolean add（E e）

　　if （offer（e））

　　return true;

　　else

　　throw new IllegalStateException（ Queue full ）

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

　　 Java代码

　　[java]

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

　　/** items index for next take poll or remove */

　　private int takeIndex;

　　/** items index for next put offer or add */

　　private int putIndex;

　　/** Number of items in the queue */

　　private int count;

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

　　Java代码

　　[java]

　　private E extract（）

　　final E[] items = ems;

　　E x = items[takeIndex];

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

　　takeIndex = inc（takeIndex） //策略和添加元素时相同

　　 count;

　　notFull signal（） //提醒其他在notFull这个Condition上waiting的线程可以尝试工作了

　　return x;

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

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

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

　　 Condition实现

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

　　 Java代码

　　[java]

　　public final void await（） throws InterruptedException

　　if （Thread interrupted（））

　　throw new InterruptedException（）

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

　　Node node = addConditionWaiter（）

　　//释放自己的锁

　　int savedState = fullyRelease（node）

　　int interruptMode = ;

　　while （！isOnSyncQueue（node））

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

　　LockSupport park（this）

　　if （（interruptMode = checkInterruptWhileWaiting（node）） != ）

　　break;

　　if （acquireQueued（node savedState） && interruptMode != THROW_IE）

　　interruptMode = REINTERRUPT;

　　if （node nextWaiter != null）

　　unlinkCancelledWaiters（）

　　if （interruptMode != ）

　　reportInterruptAfterWait（interruptMode）

　　 SynchronousQueue

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

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

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

　　 LinkedBlockingQueue

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

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

　　 PriorityBlockingQueue

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

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

　　 Java代码

　　[java]

　　private final PriorityQueue q;

　　private final ReentrantLock lock = new ReentrantLock（true）

　　private final Condition notEmpty = lock newCondition（）

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

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

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

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

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

　　 BlockingDque+LinkedBlockingQueue

lishixinzhi/Article/program/Java/gj/201311/27544

Java并发多线程编程——阻塞队列（BlockingQueue）

一、阻塞队列（BlockingQueue）的概述

阻塞队列,顾名思义,首先它是一个队列,而一个阻塞队列在数据结构中所起的作用大致如图所示:
当阻塞队列是空时,从队列中获取元素的操作将会被阻塞。
当阻塞队列是满时,往队列中添加元素的操作将会被阻塞。
同样试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞,直到其他线程从队列中移除一个或者多个元素或者全清空队列后使队列重新变得空闲起来并后续新增。

二、阻塞队列（BlockingQueue）的优点

在多线程领域:所谓阻塞,在某些情况下会挂起线程(即线程阻塞),一旦条件满足,被挂起的线程又会被自动唤醒。
我们不需要关心什么时候需要阻塞线程,什么时候需要唤醒线程,因为BlockingQueue都一手给你包办好了。
在java.util.concurrent包发布以前,在多线程环境下,我们每个程序员都必须自己去控制这些细节,尤其还要兼顾效率和线程安全,而这会给我们的程序带来不小的复杂度.

三、阻塞队列（BlockingQueue）的架构介绍

四、阻塞队列（BlockingQueue）的分类

ArrayBlockingQueue: 由数组结构组成的有界阻塞队列。
LinkedBlockingDeque: 由链表结构组成的有界(但大小默认值Integer>MAX_VALUE)阻塞队列。
PriorityBlockingQueue:支持优先级排序的无界阻塞队列。
DelayQueue: 使用优先级队列实现的延迟无界阻塞队列。
SynchronousQueue:不存储元素的阻塞队列,也即是单个元素的队列。
LinkedTransferQueue:由链表结构组成的无界阻塞队列。
LinkedBlockingDeque:由链表结构组成的双向阻塞队列。

五、阻塞队列（BlockingQueue）的核心方法

5.1、阻塞队列的核心方法图解

5.2、阻塞队列的核心方法（抛出异常示例）


抛出异常	当阻塞队列满时,再往队列里面add插入元素会抛IllegalStateException: Queue full
抛出异常	当阻塞队列空时,再往队列Remove元素时候回抛出NoSuchElementException

5.2.1 、代码示例1

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 = 初始容量3
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

输出结果如下图：

5.2.2 、代码示例2

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

        //往有界阻塞队列中添加的元素数量 > 初始容量3
        System.out.println(blockingQueue.add("d"));

输出结果如下图：

5.2.3 、代码示例3

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 = 初始容量3
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

        //从有界阻塞队列中移除的元素数量 = 初始容量3
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());

输出结果如下图：

5.2.4 、代码示例4

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 = 初始容量3
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

        //从有界阻塞队列中移除的元素数量 > 初始容量3
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());

        System.out.println(blockingQueue.remove());

输出结果如下图：

5.2.5 、代码示例5

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 = 初始容量3
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

        //检查队列是否为空 或者队列中队首的元素时哪个
        System.out.println("检查队列是否为空 或者队列中队首的元素时哪个===="+blockingQueue.element());

输出结果如下图：

5.3、阻塞队列的核心方法（特殊值示例）


特殊值	插入方法,成功返回true 失败返回false
特殊值	插入方法,成功返回true 失败返回false

5.3.1 、代码示例1

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 > 初始容量3
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("d"));

输出结果如下图：

5.3.2 、代码示例2

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 = 初始容量3
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));

        //从有界阻塞队列中移除的元素数量 > 初始容量3
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());

输出结果如下图：

5.3.3 、代码示例3

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 = 初始容量3
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));

        //检查队列是否为空 或者队列中队首的元素时哪个
        System.out.println(blockingQueue.peek());

输出结果如下图：

5.4、阻塞队列的核心方法（一直阻塞示例）


一直阻塞	当阻塞队列满时,生产者继续往队列里面put元素,队列会一直阻塞直到put数据or响应中断退出
一直阻塞	当阻塞队列空时,消费者试图从队列take元素,队列会一直阻塞消费者线程直到队列可用.

5.4.1 、代码示例1

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) throws InterruptedException 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 = 初始容量3
        //因为无返回值，所有没有打印输出
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");

        System.out.println("================");
        //往有界阻塞队列中添加的元素数量 > 初始容量3 ,没有报错，一直阻塞
        blockingQueue.put("d");

输出结果如下图：

5.4.2 、代码示例2

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueDemo1 
    public static void main(String[] args) throws InterruptedException 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 = 初始容量3
        //因为无返回值，所有没有打印输出
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");

        System.out.println("================");
        //从有界阻塞队列中移除的元素数量 > 初始容量3 ,没有报错，一直阻塞
        blockingQueue.take();
        blockingQueue.take();
        blockingQueue.take();
        blockingQueue.take();

输出结果如下图：

5.5、阻塞队列的核心方法（超时退出示例）


超时退出	当阻塞队列满时,队列会阻塞生产者线程一定时间,超过后限时后生产者线程就会退出

5.5.1 、代码示例1

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class BlockingQueueDemo1 
    public static void main(String[] args) throws InterruptedException 
        //创建一个由数组结构组成的有界阻塞队列，初始容量为3
        BlockingQueue<String> blockingQueue =new ArrayBlockingQueue<>(3);
        //往有界阻塞队列中添加的元素数量 = 初始容量3,直接添加成功
        System.out.println(blockingQueue.offer("a", 2L, TimeUnit.SECONDS));
        System.out.println(blockingQueue.offer("b", 2L, TimeUnit.SECONDS));
        System.out.println(blockingQueue.offer("c", 2L, TimeUnit.SECONDS));
        //往有界阻塞队列中添加的元素数量 > 初始容量3,等待2秒钟后，添加成功
        System.out.println(blockingQueue.offer("d", 2L, TimeUnit.SECONDS));

输出结果如下图：

5.5.2 、代码示例2

代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import javaJAVA多线程之间共享数据BlockingQueue介绍
 多线程之阻塞队列BlockingQueue详解
 java多线程-BlockingQueue
 Java多线程-BlockingQueue
 Java多线程-工具篇-BlockingQueue
 Java多线程-工具篇-BlockingQueue

Java多线程（五）之BlockingQueue深入分析

Java并发多线程编程——阻塞队列（BlockingQueue）

目录

一、阻塞队列（BlockingQueue）的概述

二、阻塞队列（BlockingQueue）的优点

三、阻塞队列（BlockingQueue）的架构介绍

四、阻塞队列（BlockingQueue）的分类

五、阻塞队列（BlockingQueue）的核心方法

5.1、阻塞队列的核心方法图解

5.2、阻塞队列的核心方法（抛出异常示例）

5.2.1 、代码示例1

5.2.2 、代码示例2

5.2.3 、代码示例3

5.2.4 、代码示例4

5.2.5 、代码示例5

5.3、阻塞队列的核心方法（特殊值示例）

5.3.1 、代码示例1

5.3.2 、代码示例2

5.3.3 、代码示例3

5.4、阻塞队列的核心方法（一直阻塞示例）

5.4.1 、代码示例1

5.4.2 、代码示例2

5.5、阻塞队列的核心方法（超时退出示例）

5.5.1 、代码示例1

5.5.2 、代码示例2