java.util.concurrent
类 ConcurrentLinkedQueue<E>

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractQueue<E>
          java.util.concurrent.ConcurrentLinkedQueue<E>

类型参数：

E - 在此 collection 中保持的元素类型

所有已实现的接口：

Serializable, Iterable<E>, Collection<E>, Queue<E>

public class ConcurrentLinkedQueue<E>
extends AbstractQueue<E>
implements Queue<E>, Serializable

一个基于链接节点的无界线程安全队列。此队列按照 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 和 Iterator 接口的所有可选 方法。

内存一致性效果：当存在其他并发 collection 时，将对象放入 ConcurrentLinkedQueue 之前的线程中的操作 happen-before 随后通过另一线程从 ConcurrentLinkedQueue 访问或移除该元素的操作。

此类是 Java Collections Framework 的成员。

从以下版本开始：

1.5

另请参见：

序列化表格

构造方法摘要

ConcurrentLinkedQueue()
创建一个最初为空的 ConcurrentLinkedQueue。

ConcurrentLinkedQueue(Collection<? extends E> c)
创建一个最初包含给定 collection 元素的 ConcurrentLinkedQueue，按照此 collection 迭代器的遍历顺序来添加元素。

方法摘要

boolean	add(E e) 将指定元素插入此队列的尾部。
boolean	contains(Object o) 如果此队列包含指定元素，则返回 true。
boolean	isEmpty() 如果此队列不包含任何元素，则返回 true。
Iterator<E>	iterator() 返回在此队列元素上以恰当顺序进行迭代的迭代器。
boolean	offer(E e) 将指定元素插入此队列的尾部。
E	peek() 获取但不移除此队列的头；如果此队列为空，则返回 null。
E	poll() 获取并移除此队列的头，如果此队列为空，则返回 null。
boolean	remove(Object o) 从队列中移除指定元素的单个实例（如果存在）。
int	size() 返回此队列中的元素数量。
Object[]	toArray() 返回以恰当顺序包含此队列所有元素的数组。
<T> T[]	toArray(T[] a) 返回以恰当顺序包含此队列所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

从类 java.util.AbstractQueue 继承的方法

addAll, clear, element, remove

从类 java.util.AbstractCollection 继承的方法

containsAll, removeAll, retainAll, toString

从类 java.lang.Object 继承的方法

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

从接口 java.util.Queue 继承的方法

element, remove

从接口 java.util.Collection 继承的方法

addAll, clear, containsAll, equals, hashCode, removeAll, retainAll

构造方法详细信息

ConcurrentLinkedQueue

public ConcurrentLinkedQueue()

创建一个最初为空的 ConcurrentLinkedQueue。

ConcurrentLinkedQueue

public ConcurrentLinkedQueue(Collection<? extends E> c)

创建一个最初包含给定 collection 元素的 ConcurrentLinkedQueue，按照此 collection 迭代器的遍历顺序来添加元素。

参数：

c - 最初包含的元素 collection

抛出：

NullPointerException - 如果指定 collection 或其任何元素为 null

方法详细信息

add

public boolean add(E e)

将指定元素插入此队列的尾部。

指定者：

接口 Collection<E> 中的 add

指定者：

接口 Queue<E> 中的 add

覆盖：

类 AbstractQueue<E> 中的 add

参数：

o - 要添加的元素

返回：

true（根据 Collection.add(E) 的规定）

抛出：

NullPointerException - 如果指定元素为 null

offer

public boolean offer(E e)

将指定元素插入此队列的尾部。

指定者：

接口 Queue<E> 中的 offer

参数：

e - 要添加的元素

返回：

true（根据 Queue.offer(E) 的规定）

抛出：

NullPointerException - 如果指定元素为 null

poll

public E poll()

从接口 Queue 复制的描述

获取并移除此队列的头，如果此队列为空，则返回 null。

指定者：

接口 Queue<E> 中的 poll

返回：

队列的头，如果此队列为空，则返回 null

peek

public E peek()

从接口 Queue 复制的描述

获取但不移除此队列的头；如果此队列为空，则返回 null。

指定者：

接口 Queue<E> 中的 peek

返回：

此队列的头；如果此队列为空，则返回 null

isEmpty

public boolean isEmpty()

如果此队列不包含任何元素，则返回 true。

指定者：

接口 Collection<E> 中的 isEmpty

覆盖：

类 AbstractCollection<E> 中的 isEmpty

返回：

如果此队列不包含任何元素，则返回 true

size

public int size()

返回此队列中的元素数量。如果此队列包含的元素数大于 Integer.MAX_VALUE，则返回 Integer.MAX_VALUE。

需要小心的是，与大多数 collection 不同，此方法不是 一个固定时间操作。由于这些队列的异步特性，确定当前的元素数需要进行一次花费 O(n) 时间的遍历。

指定者：

接口 Collection<E> 中的 size

指定者：

类 AbstractCollection<E> 中的 size

返回：

此队列中的元素数

contains

public boolean contains(Object o)

如果此队列包含指定元素，则返回 true。更确切地讲，当且仅当此队列至少包含一个满足 o.equals(e) 的元素 e 时，返回 true。

指定者：

接口 Collection<E> 中的 contains

覆盖：

类 AbstractCollection<E> 中的 contains

参数：

o - 要检查是否包含于此队列的对象

返回：

如果此队列包含指定元素，则返回 true

remove

public boolean remove(Object o)

从队列中移除指定元素的单个实例（如果存在）。更确切地讲，如果此队列包含一个或多个满足 o.equals(e) 的元素 e，则移除一个这样的元素。如果此队列包含指定元素（或者此队列由于调用而发生更改），则返回 true。

指定者：

接口 Collection<E> 中的 remove

覆盖：

类 AbstractCollection<E> 中的 remove

参数：

o - 将从此队列中移除的元素（如果存在）

返回：

如果此队列由于调用而发生更改，则返回 true

toArray

public Object[] toArray()

返回以恰当顺序包含此队列所有元素的数组。

由于此队列并不维护对返回数组的任何引用，因而它将是“安全的”。（换句话说，此方法必须分配一个新数组）。因此，调用者可以随意修改返回的数组。

此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。

指定者：

接口 Collection<E> 中的 toArray

覆盖：

类 AbstractCollection<E> 中的 toArray

返回：

包含此队列所有元素的数组

toArray

public <T> T[] toArray(T[] a)

返回以恰当顺序包含此队列所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。如果指定的数组能容纳队列，则将该队列返回此处。否则，将分配一个具有指定数组的运行时类型和此队列大小的新数组。

如果指定的数组能容纳队列，并有剩余的空间（即数组的元素比队列多），那么会将紧接队列尾部的元素设置为 null。

像 toArray() 方法一样，此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。更进一步说，此方法允许对输出数组的运行时类型进行精确控制，在某些情况下，这可以用来节省分配开销。

假定 x 是只包含字符串的一个已知队列。以下代码用来将该队列转储到一个新分配的 String 数组：

     String[] y = x.toArray(new String[0]);

注意，toArray(new Object[0]) 和 toArray() 在功能上是相同的。

指定者：

接口 Collection<E> 中的 toArray

覆盖：

类 AbstractCollection<E> 中的 toArray

参数：

a - 将用来存储队列元素的数组（如果该数组足够大）；否则，将为此分配一个具有相同运行时类型的新数组

返回：

包含此队列所有元素的数组

抛出：

ArrayStoreException - 如果指定数组的运行时类型不是此队列中每个元素的运行时类型的超类型

NullPointerException - 如果指定数组为 null

iterator

public Iterator<E> iterator()

返回在此队列元素上以恰当顺序进行迭代的迭代器。返回的迭代器是一个“弱一致”迭代器，它不会抛出 ConcurrentModificationException，并且可保证遍历迭代器构造时存在的元素，此外还可能（但并不保证）反映构造后的所有修改。

指定者：

接口 Iterable<E> 中的 iterator

指定者：

接口 Collection<E> 中的 iterator

指定者：

类 AbstractCollection<E> 中的 iterator

返回：

在此队列元素上以恰当顺序进行迭代的迭代器