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 接口的所有可选 方法。

此类是 Java Collections Framework 的成员。

从以下版本开始：

1.5

另请参见：

序列化表格

构造方法摘要

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

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

方法摘要

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

从类 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 - 如果 c 或 c 中的所有元素为 null

方法详细信息

add

public boolean add(E o)

将指定元素添加到此队列的尾部。

指定者：

接口 Collection<E> 中的 add

覆盖：

类 AbstractQueue<E> 中的 add

参数：

o - 要添加的元素

返回：

true（按照 Collection.add 的常规协定）。

抛出：

NullPointerException - 如果指定元素为 null

offer

public boolean offer(E o)

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

指定者：

接口 Queue<E> 中的 offer

参数：

o - 要添加的元素

返回：

true（按照 Queue.offer 的常规协定）。

抛出：

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()

从类 AbstractCollection 复制的描述

如果此 collection 不包含元素，则返回 true。

此实现返回 size() == 0。

指定者：

接口 Collection<E> 中的 isEmpty

覆盖：

类 AbstractCollection<E> 中的 isEmpty

返回：

如果此 collection 不包含元素，则返回 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)

从类 AbstractCollection 复制的描述

如果此 collection 包含指定的元素，则返回 true。更正式地说，当且仅当此 collection 至少包含一个满足以下条件的元素 e 时才返回 true：(o==null ? e==null : o.equals(e))。

此实现迭代该 collection 中的元素，并依次检查每个元素以确定其是否与指定的元素相等。

指定者：

接口 Collection<E> 中的 contains

覆盖：

类 AbstractCollection<E> 中的 contains

参数：

o - 要检查的对象，以确定其是否包含在此 collection 中。

返回：

如果此 collection 包含指定的元素，则返回 true。

remove

public boolean remove(Object o)

从类 AbstractCollection 复制的描述

从此 collection 中移除指定元素的单个实例（如果存在）（可选操作）。更正式地说，如果该 collection 包含一个或多个满足 (o==null ? e==null : o.equals(e)) 的元素 e，则移除 e。如果该 collection 包含指定的元素（或等价元素，如果该 collection 随调用的结果发生变化），则返回 true。

此实现在该 collection 上进行迭代，查找指定的元素。如果找到该元素，那么它会使用迭代器的 remove 方法从该 collection 中移除该元素。

注意，如果此 collection 的 iterator 方法所返回的迭代器无法实现 remove 方法，并且此 collection 包含指定的对象，那么此实现会抛出 UnsupportedOperationException。

指定者：

接口 Collection<E> 中的 remove

覆盖：

类 AbstractCollection<E> 中的 remove

参数：

o - 要从此 collection 中移除的元素（如果存在）。

返回：

如果该 collection 包含指定的元素,则返回 true。

toArray

public Object[] toArray()

从类 AbstractCollection 复制的描述

返回包含此 collection 中所有元素的数组。如果此 collection 保证其迭代器按顺序返回其元素，那么此方法也必须按相同的顺序返回这些元素。返回的数组将是“安全的”，因为此 collection 并不维护对返回数组的任何引用。（换句话说，即使 collection 受到数组的支持，此方法也必须分配一个新的数组）。因此，调用方可以随意修改返回的数组。

此实现会分配返回的数组，并迭代 collection 中的元素，将每个对象引用存储在数组的下一个连续元素中，并从元素 0 开始。

指定者：

接口 Collection<E> 中的 toArray

覆盖：

类 AbstractCollection<E> 中的 toArray

返回：

包含此 collection 中所有元素的数组。

toArray

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

从类 AbstractCollection 复制的描述

返回包含此 collection 中所有元素的数组；返回数组的运行时类型是指定数组的类型。如果指定的数组能容纳该 collection，则在此数组中返回 collection 的元素。否则，将根据指定数组的运行时类型和此 collection 的大小分配一个新数组。

如果指定的数组能容纳 collection，并且有剩余的空间（即数组的元素比 collection 多），那么会将紧挨着 collection 尾部的元素设置为 null（这对确定 collection 的长度很有用，但只有 在调用方知道 collection 不包含任何 null 元素时才可行）。

如果此 collection 保证其迭代器按顺序返回其元素，那么此方法也必须按相同的顺序返回这些元素。

此实现会检查该数组是否足够大，以包含该 collection 中的元素；如果不能包含，则将分配一个具有适当大小和类型的新数组（使用反射）。然后，在该 collection 上进行迭代，将每个对象引用存储在数组的下一个连续元素中，并从元素 0 开始。如果该数组比该 collection 大，则在该 collection 尾部后面的第一个位置存储 null。

指定者：

接口 Collection<E> 中的 toArray

覆盖：

类 AbstractCollection<E> 中的 toArray

参数：

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

返回：

包含此 collection 的元素的数组。

iterator

public Iterator<E> iterator()

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

指定者：

接口 Iterable<E> 中的 iterator

指定者：

接口 Collection<E> 中的 iterator

指定者：

类 AbstractCollection<E> 中的 iterator

返回：

在队列中的元素上以正确顺序进行迭代的迭代器。