Java 集合系列之四：Queue基本操做

时间 2019-12-05

标签 java 集合系列之四 queue 基本栏目 Java 繁體版

原文原文链接

1. Java Queue

1. Java Queue 重要观点

Java Queue接口是Java Collections Framework的成员。
Queue 实现一般不容许插入 null 元素
队列一般（但并不是必定）以 FIFO（先进先出）的方式排序各个元素。不过优先级队列和 LIFO 队列（或堆栈）例外，前者根据提供的比较器或元素的天然顺序对元素进行排序，后者按 LIFO（后进先出）的方式对元素进行排序。不管使用哪一种排序方式，队列的头都是调用 remove() 或 poll() 所移除的元素。在 FIFO 队列中，全部的新元素都插入队列的末尾。其余种类的队列可能使用不一样的元素放置规则。每一个 Queue 实现必须指定其顺序属性。
在处理元素前用于保存元素的 collection。除了基本的 Collection 操做外，队列还提供其余的插入、提取和检查操做。每一个方法都存在两种形式：一种抛出异常（操做失败时），另外一种返回一个特殊值（null 或 false，具体取决于操做）。
Queue 接口并未定义阻塞队列的方法，而这在并发编程中是很常见的。BlockingQueue 接口定义了那些等待元素出现或等待队列中有可用空间的方法，这些方法扩展了此接口。
　　抛出异常　　返回特殊值
插入：add(e) 　　 offer(e)  插入一个元素
移除：remove() poll()   移除和返回队列的头
检查：element() peek()   返回但不移除队列的头。html
JDK中并发队列提供了两种实现，一种是高性能队列ConcurrentLinkedQueue，一种是阻塞队列BlockingQueue（7种阻塞队列），两种都继承自Queue。
JDK中队列有两大类，一类是双端队列，一类是单端队列。

2. Java Queue类图

此接口是 Java Collections Framework 的成员。java

Java Queue接口扩展了Collection接口。Collection接口 externs Iterable接口。算法

子接口：BlockingQueue, Deque, BlobkingDequeue编程

一些最经常使用的Queue实现类是LinkedList，ArrayBlickingQueue, LinkedBlockingQueue，PriorityQueue, PriorityBlockingQueue。api

3. Java Queue 方法

boolean  add(E e) //将指定的元素插入此队列（若是当即可行且不会违反容量限制），在成功时返回 true，若是当前没有可用的空间，则抛出 IllegalStateException。
E        element() //获取，可是不移除此队列的头。
boolean  offer(E e) //将指定的元素插入此队列（若是当即可行且不会违反容量限制），当使用有容量限制的队列时，此方法一般要优于 add(E)，后者可能没法插入元素，而只是抛出一个异常。
E        peek() //获取但不移除此队列的头；若是此队列为空，则返回 null。
E        poll() //获取并移除此队列的头，若是此队列为空，则返回 null。
E        remove() //获取并移除此队列的头。

2. ConcurrentLinkedQueue接口（JUC）

1. ConcurrentLinkedQueue 结构图

一个基于连接节点的无界线程安全队列。数组

2. ConcurrentLinkedQueue重要特色

一个基于连接节点的无界线程安全队列。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部是队列中时间最长的元素。队列的尾部是队列中时间最短的元素。新的元素插入到队列的尾部，队列获取操做从队列头部得到元素。当多个线程共享访问一个公共 collection 时，ConcurrentLinkedQueue 是一个恰当的选择。缓存
此队列不容许使用 null 元素。安全
此实现采用了有效的“无等待 (wait-free)”算法，该算法基于 Maged M. Michael 和 Michael L. Scott 合著的 Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms 中描述的算法。数据结构
须要当心的是，与大多数 collection 不一样，size 方法不是一个固定时间操做。因为这些队列的异步特性，肯定当前元素的数量须要遍历这些元素。多线程
内存一致性效果：当存在其余并发 collection 时，将对象放入 ConcurrentLinkedQueue 以前的线程中的操做 happen-before 随后经过另外一线程从 ConcurrentLinkedQueue 访问或移除该元素的操做。
ConcurrentLinkedQueue中有两个volatile类型的Node节点分别用来存在列表的首尾节点，其中head节点存放链表第一个item为null的节点，tail则并非总指向最后一个节点。Node节点内部则维护一个变量item用来存放节点的值，next用来存放下一个节点，从而连接为一个单向无界列表。
开源框架中使用：Tomcat中NioEndPoint中的每一个poller里面就维护一个ConcurrentLinkedQueue<Runnable>用来做为缓冲存听任务。
ConcurrentLinkedQueue使用CAS非阻塞算法实现使用CAS解决了当前节点与next节点之间的安全连接和对当前节点值的赋值。【CAS的基本思想是认为当前环境中的并发并无那么高，比较乐观的看待整个并发，只须要在更新某个值时先检查下该值有没有发生变化，若是没有发生变化则更新，不然放弃更新。CAS的操做其底层是经过调用sun.misc.Unsafe类中的CompareAndSwap的方法保证线程安全的。】因为使用CAS没有使用锁，因此获取size的时候有可能进行offer，poll或者remove操做，致使获取的元素个数不精确，因此在并发状况下size函数不是颇有用。另外第一次peek或者first时候会把head指向第一个真正的队列元素。
线程安全的，volatile + CAS 可知入队出队函数都是操做volatile变量：head，tail。因此要保证队列线程安全只须要保证对这两个Node操做的可见性和原子性，因为volatile自己保证可见性，因此只须要看下多线程下若是保证对着两个变量操做的原子性。对于offer操做是在tail后面添加元素，也就是调用tail.casNext方法，而这个方法是使用的CAS操做，只有一个线程会成功，而后失败的线程会循环一下，从新获取tail，而后执行casNext方法。对于poll也是这样的。

3. Deque接口

1. Deque结构图

　　一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，一般读为“deck”。大多数 Deque 实现对于它们可以包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

　　队列：此接口扩展了 Queue 接口。在将双端队列用做队列时，将获得 FIFO（先进先出）行为。将元素添加到双端队列的末尾，从双端队列的开头移除元素。

　　堆栈：双端队列也可用做 LIFO（后进先出）堆栈。应优先使用此接口而不是遗留 Stack 类。在将双端队列用做堆栈时，元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法彻底等效于 Deque 方法，

4. LinkedList

1. LinkedList 结构图

LinkedList是基于链表实现的，从源码能够看出是一个双向链表。除了当作链表使用外，它也能够被看成堆栈、队列或双端队列进行操做。

LinkedList不是线程安全的，继承AbstractSequentialList实现List、Deque、Cloneable、Serializable。

LinkedList继承AbstractSequentialList，AbstractSequentialList 实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些函数。这些接口都是随机访问List的。
LinkedList 实现 List 接口，能对它进行队列操做。
LinkedList 实现 Deque 接口，即能将LinkedList看成双端队列使用。
LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能经过序列化去传输。

2. LinkedList 重要特色

本质实现：底层使用一个Node数据结构，有先后两个指针，双向链表实现。
线程安全：非同步的。
列表长度：LinkedList中元素个数用size记录。
列表容量：LinkedList是基于链表实现的，所以不存在容量不足的问题，因此这里没有扩容的方法。
内存：须要更多的内存，LinkedList 每一个节点中须要多存储先后节点的信息，占用空间更多些（previous element next）。
元素容许为null。
Fail-Fast机制:同ArrayList相同。
遍历方法：全部指定位置的操做都是从头开始遍历进行的。LinkedList是基于链表实现的，所以插入删除效率高，查找效率低（虽然有一个加速动做）。源码中先将index与长度size的一半比较，若是index<size/2，就只从位置0日后遍历到位置index处，而若是index>size/2，就只从位置size往前遍历到位置index处。这样能够减小一部分没必要要的遍历，从而提升必定的效率（实际上效率仍是很低）。Arrays.copyOf() 方法：
它适合删除，插入较多的场景。

5. ConcurrentLinkedDeque接口（JUC）

1. ConcurrentLinkedDeque 结构图

并发队列ConcurrentLinkedDeque，这是一个非阻塞，无锁，无界，线程安全双端操做的队列。简单说就是ConcurrentLinkedQueue的升级版，在JDK7以后才提供。该队列也不容许空元素，并且size方法并非常量时间，其须要遍历链表，此时并发修改链表会形成统计size不正确。一样，bulk操做和equal以及toArray方法不保证原子性。

2. ConcurrentLinkedDeque重要特色

ConcurrentLinkedDeque 是 双向链表结构的无界并发队列。从JDK 7开始加入到J.U.C的行列中。
使用 CAS实现并发安全，与 ConcurrentLinkedQueue 的区别是该阻塞队列同时支持FIFO和FILO两种操做方式，便可以从队列的头和尾同时操做(插入/删除)。
适合“多生产，多消费”的场景。
内存一致性遵循对 ConcurrentLinkedDeque 的插入操做先行发生于(happen-before)访问或移除操做。

6. BlockingQueue接口（JUC）

1. BlockingQueue 结构图

JDK7提供了7个阻塞队列。分别是

ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue ：一个由链表结构组成的可选有界阻塞队列。若是未指定容量，那么容量将等于 Integer.MAX_VALUE。 2 ³¹－1
PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
DelayQueue：一个使用优先级队列实现的无界阻塞队列,，只有在延迟期满时才能从中提取元素。
SynchronousQueue：一个不存储元素、没有内部容量的阻塞队列。
LinkedTransferQueue：一个由链表结构组成的无界阻塞TransferQueue队列。
LinkedBlockingDeque：一个由链表结构组成的可选范围双向阻塞队列。若是未指定容量，那么容量将等于 Integer.MAX_VALUE。 2 ³¹－1

2. BlockingQueue重要特色

支持两个附加操做的 Queue，这两个操做是：获取元素时等待队列变为非空，以及存储元素时等待空间变得可用(阻塞)。
BlockingQueue 方法以四种形式出现，对于不能当即知足但可能在未来某一时刻能够知足的操做，这四种形式的处理方式不一样：第一种是抛出一个异常，第二种是返回一个特殊值（null 或 false，具体取决于操做），第三种是在操做能够成功前，无限期地阻塞当前线程，第四种是在放弃前只在给定的最大时间限制内阻塞。下表中总结了这些方法：
BlockingQueue 不接受 null 元素。试图 add、put 或 offer 一个 null 元素时，某些实现会抛出 NullPointerException。null 被用做指示 poll 操做失败的警惕值。
BlockingQueue 能够是限定容量的。它在任意给定时间均可以有一个 remainingCapacity，超出此容量，便没法无阻塞地 put 附加元素。没有任何内部容量约束的 BlockingQueue 老是报告 Integer.MAX_VALUE 的剩余容量。
BlockingQueue 实现主要用于生产者-使用者队列，BlockingQueue 能够安全地与多个生产者和多个使用者一块儿使用。但它另外还支持 Collection 接口。所以，举例来讲，使用 remove(x) 从队列中移除任意一个元素是有可能的。然而，这种操做一般不会有效执行，只能有计划地偶尔使用，好比在取消排队信息时。
BlockingQueue 实现是线程安全的。全部排队方法均可以使用内部锁或其余形式的并发控制来自动达到它们的目的。然而，大量的 Collection 操做（addAll、containsAll、retainAll 和 removeAll）没有必要自动执行，除非在实现中特别说明。所以，举例来讲，在只添加了 c 中的一些元素后，addAll(c) 有可能失败（抛出一个异常）。
BlockingQueue 实质上不支持使用任何一种“close”或“shutdown”操做来指示再也不添加任何项。这种功能的需求和使用有依赖于实现的倾向。例如，一种经常使用的策略是：对于生产者，插入特殊的 end-of-stream 或 poison 对象，并根据使用者获取这些对象的时间来对它们进行解释。
内存一致性效果：当存在其余并发 collection 时，将对象放入 BlockingQueue 以前的线程中的操做 happen-before 随后经过另外一线程从 BlockingQueue中访问或移除该元素的操做。

7. ArrayBlockingQueue（JUC）

1. ArrayBlockingQueue 结构图

2. ArrayBlockingQueue 重要特色

一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部是在队列中存在时间最长的元素。队列的尾部是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列获取操做则是从队列头部开始得到元素。
这是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦建立了这样的缓存区，就不能再增长其容量。试图向已满队列中放入元素会致使操做受阻塞；试图从空队列中提取元素将致使相似阻塞。
此类支持对等待的生产者线程和使用者线程进行排序的可选公平策略。默认状况下，不保证是这种排序。然而，经过将公平性 (fairness) 设置为 true 而构造的队列容许按照 FIFO 顺序访问线程。公平性一般会下降吞吐量，但也减小了可变性和避免了“不平衡性”。
ArrayBlockingQueue内部有个循环数组items用来存放队列元素，putIndex下标标示入队元素下标，takeIndex是出队下标，count统计队列元素个数，从定义可知道并无使用volatile修饰，这是由于访问这些变量使用都是在锁块内，并不存在可见性问题。
有个独占锁lock用来对出入队操做加锁，这致使同时只有一个线程能够访问入队出队，
notEmpty，notFull条件变量用来进行出入队的同步。另外构造函数必须传入队列大小参数，因此为有界队列，默认是Lock为非公平锁。
offer操做：在队尾插入元素，若是队列满则返回false，否者入队返回true。因为在操做共享变量前加了锁【final ReentrantLock lock = this.lock; 获取独占锁 lock.lock();】，因此不存在内存不可见问题，加过锁后获取的共享变量都是从主内存获取的，而不是在CPU缓存或者寄存器里面的值，释放锁后修改的共享变量值会刷新会主内存中。另外这个队列是使用循环数组实现，因此计算下一个元素存放下标时候有些特殊。【i=putIndex; return(++i == items.length) ? 0 : i;】另外insert后调用 notEmpty.signal();是为了激活调用notEmpty.await()阻塞后放入notEmpty条件队列中的线程。
put操做：在队列尾部添加元素，若是队列满则等待队列有空位置插入后返回。【final ReentrantLock lock = this.lock; 获取可被中断锁 lock.lockInterruptibly();】若是队列满了那么当前线程会阻塞，直到出队操做调用了notFull.signal方法激活该线程。
size操做：获取队列元素个数，很是精确，由于计算size时候加了独占锁，其余线程不能入队或者出队或者删除元素
ArrayBlockingQueue经过使用全局独占锁实现同时只能有一个线程进行入队或者出队操做，这个锁的粒度比较大，有点相似在方法上添加synchronized的意味。其中offer,poll操做经过简单的加锁进行入队出队操做，而put,take则使用了条件变量实现若是队列满则等待，若是队列空则等待，而后分别在出队和入队操做中发送信号激活等待线程实现同步。另外相比LinkedBlockingQueue，ArrayBlockingQueue的size操做的结果是精确的，由于计算前加了全局锁。

8. LinkedBlockingQueue（JUC）

1. LinkedBlockingQueue 结构图

一个由连接节点支持的可选有界队列。

2. LinkedBlockingQueue 重要特色

一个基于已连接节点的、范围任意的 blocking queue。此队列按 FIFO（先进先出）排序元素。队列的头部是在队列中时间最长的元素。队列的尾部是在队列中时间最短的元素。新元素插入到队列的尾部，而且队列获取操做会得到位于队列头部的元素。连接队列的吞吐量一般要高于基于数组的队列，可是在大多数并发应用程序中，其可预知的性能要低。
可选的容量范围构造方法参数做为防止队列过分扩展的一种方法。若是未指定容量，则它等于 Integer.MAX_VALUE。除非插入节点会使队列超出容量，不然每次插入后会动态地建立连接节点。
LinkedBlockingQueue中也有两个Node分别用来存放首尾节点，而且里面有个初始值为0的原子变量count用来记录队列元素个数，另外里面有两个ReentrantLock的独占锁，分别用来控制元素入队和出队加锁，其中takeLock用来控制同时只有一个线程能够从队列获取元素，其余线程必须等待，putLock控制同时只能有一个线程能够获取锁去添加元素，其余线程必须等待。另外notEmpty和notFull用来实现入队和出队的同步。另外因为出入队是两个非公平独占锁，因此能够同时又一个线程入队和一个线程出队，其实这个是个生产者-消费者模型。

9. PriorityBlockingQueue（JUC）

1. PriorityBlockingQueue 结构图

一个基于优先级堆的无界优先级阻塞队列。

2. PriorityBlockingQueue 重要特色

一个基于优先级堆的无界阻塞队列。，它使用与类 PriorityQueue 相同的顺序规则，而且提供了阻塞获取操做。虽然此队列逻辑上是无界的，可是资源被耗尽时试图执行 add 操做也将失败（致使 OutOfMemoryError）。
此类不容许使用 null 元素。依赖天然顺序的优先级队列也不容许插入不可比较的对象（这样作会致使抛出 ClassCastException）。
此类及其迭代器能够实现 Collection 和 Iterator 接口的全部可选方法。iterator() 方法中提供的迭代器并不保证以特定的顺序遍历 PriorityBlockingQueue 的元素。若是须要有序地进行遍历，则应考虑使用 Arrays.sort(pq.toArray())。此外，可使用方法 drainTo 按优先级顺序移除所有或部分元素，并将它们放在另外一个 collection 中。
在此类上进行的操做不保证具备同等优先级的元素的顺序。若是须要实施某一排序，那么能够定义自定义类或者比较器，比较器可以使用修改键断开主优先级值之间的联系。例如，如下是应用先进先出 (first-in-first-out) 规则断开可比较元素之间联系的一个类。要使用该类，则须要插入一个新的 FIFOEntry(anEntry) 来替换普通的条目对象。
PriorityBlockingQueue内部有个数组queue用来存放队列元素，size用来存放队列元素个数，allocationSpinLockOffset是用来在扩容队列时候作cas的，目的是保证只有一个线程能够进行扩容。
因为这是一个优先级队列因此有个比较器comparator用来比较元素大小。lock独占锁对象用来控制同时只能有一个线程能够进行入队出队操做。notEmpty条件变量用来实现take方法阻塞模式。这里没有notFull 条件变量是由于这里的put操做是非阻塞的，为啥要设计为非阻塞的是由于这是无界队列。
最后PriorityQueue q用来搞序列化的。以下构造函数，默认队列容量为11，默认比较器为null;

10. DelayQueue（JUC）

1. DelayQueue 结构图

一个使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素。

DelayQueue队列中每一个元素都有个过时时间，而且队列是个优先级队列，当从队列获取元素时候，只有过时元素才会出队列。

2. DelayQueue 重要特色

Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。若是延迟都尚未期满，则队列没有头部，而且 poll 将返回 null。
当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于等于 0 的值时，将发生到期。即便没法使用 take 或 poll 移除未到期的元素，也不会将这些元素做为正常元素对待。例如，size 方法同时返回到期和未到期元素的计数。
此队列不容许使用 null 元素。
DelayQueue中内部使用的是PriorityQueue存放数据，使用ReentrantLock实现线程同步，可知是阻塞队列。另外队列里面的元素要实现Delayed接口，一个是获取当前剩余时间的接口，一个是元素比较的接口，由于这个是有优先级的队列。

11. SychronousQueue（JUC）

1. SychronousQueue 结构图

一个不存储元素、没有内部容量的阻塞同步队列。

SynchronousQueue的吞吐量高于LinkedBlockingQueue 和 ArrayBlockingQueue。

2. SychronousQueue 重要特色

一个不存储元素、没有内部容量的阻塞队列，其中每一个插入操做必须等待另外一个线程的对应移除操做，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。不能在同步队列上进行 peek，由于仅在试图要移除元素时，该元素才存在；除非另外一个线程试图移除某个元素，不然也不能（使用任何方法）插入元素；也不能迭代队列，由于其中没有元素可用于迭代。队列的头是尝试添加到队列中的首个已排队插入线程的元素；若是没有这样的已排队线程，则没有可用于移除的元素而且 poll() 将会返回 null。对于其余 Collection 方法（例如 contains），SynchronousQueue 做为一个空 collection。
此队列不容许 null 元素。
同步队列相似于 CSP 和 Ada 中使用的简单汇集（rendezvous）机制信道。它很是适合于传递性设计，在这种设计中，在一个线程中运行的对象要将某些信息、事件或任务传递给在另外一个线程中运行的对象，它就必须与该对象同步。
对于正在等待的生产者和使用者线程而言，此类支持可选的公平排序策略。默认状况下不保证这种排序。可是，使用公平设置为 true 所构造的队列可保证线程以 FIFO 的顺序进行访问。
SynchronousQueue的吞吐量高于LinkedBlockingQueue 和 ArrayBlockingQueue。

12. LinkedTransferQueue（JUC）

1. LinkedTransferQueue 结构图

LinkedTransferQueue是一个由链表结构组成的无界阻塞TransferQueue队列。

2. LinkedTransferQueue 重要特色

LinkedTransferQueue是一个由链表结构组成的无界阻塞TransferQueue队列。
相对于其余阻塞队列LinkedTransferQueue多了tryTransfer和transfer方法。
transfer方法。若是当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer方法能够把生产者传入的元素马上transfer（传输）给消费者。若是没有消费者在等待接收元素，transfer方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回。
tryTransfer方法。则是用来试探下生产者传入的元素是否能直接传给消费者。若是没有消费者等待接收元素，则返回false。和transfer方法的区别是tryTransfer方法不管消费者是否接收，方法当即返回。而transfer方法是必须等到消费者消费了才返回。
对于带有时间限制的tryTransfer(E e, long timeout, TimeUnit unit)方法，则是试图把生产者传入的元素直接传给消费者，可是若是没有消费者消费该元素则等待指定的时间再返回，若是超时还没消费元素，则返回false，若是在超时时间内消费了元素，则返回true。

13. LinkedBlockingDeque（JUC）

1. LinkedBlockingDeque 结构图

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

2. LinkedBlockingDeque 重要特色

一个基于已连接节点的、任选范围的阻塞双端队列。
可选的容量范围构造方法参数是一种防止过分膨胀的方式。若是未指定容量，那么容量将等于 Integer.MAX_VALUE。只要插入元素不会使双端队列超出容量，每次插入后都将动态地建立连接节点。
大多数操做都以固定时间运行（不计阻塞消耗的时间）。异常包括 remove、removeFirstOccurrence、removeLastOccurrence、contains、iterator.remove() 以及批量操做，它们均以线性时间运行。