compact1, compact2, compact3

java.util.concurrent

Class ConcurrentLinkedQueue<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractQueue<E>

java.util.concurrent.ConcurrentLinkedQueue<E>

参数类型

E -元素举行此集合中的类型

All Implemented Interfaces:

Serializable， Iterable ， Collection ， Queue

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

一个基于链接节点的无界线程安全的 queue。这个队列的命令元素的FIFO（先进先出）。队列的头是已在队列中的元素，是最长的时间。队列的尾部是已在队列中的元素最短的时间。新的元素插入在队列的尾部，并在队列的头部获取元素的队列检索操作。一个 ConcurrentLinkedQueue是一个合适的选择，当多个线程共享访问公共收藏。像大多数其他并行采集的实现，这类不允许使用 null元素。

该实现使用一个有效的非基于一个由Maged M. Michael和Michael L. Scott所描述的 Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms阻塞算法。

迭代器返回的元素弱一致的，反映国家的队列在一些点或从迭代器的创作。他们不把ConcurrentModificationException，并可同时进行其他操作。队列中包含的元素，因为创建迭代器将被精确地返回一次。

要小心的是，不像大多数集合的方法，size不是常量时间的操作。由于这些队列的异步性质，确定当前元素的数量需要一个元素的遍历，如果这个集合在遍历过程中被修改，那么可能会报告不准确的结果。此外，大容量操作addAll，removeAll，retainAll，containsAll，equals，和toArray不保证是自动执行。例如，一个addAll并发运行的操作一个迭代器可能会认为只有一些加入的元素。

这个类和它的迭代器实现所有的可选方法的Queue和Iterator接口。

内存一致性效果：与其他并发集合，在将对象放入一个ConcurrentLinkedQueue happen-before行动从另一个线程的ConcurrentLinkedQueue元素的访问和去除之前的线程的行为。

这个班的一员 Java Collections Framework。

从以下版本开始：

一点五

另请参见：

Serialized Form

构造方法摘要

构造方法

Constructor and Description
ConcurrentLinkedQueue() 创建一个 ConcurrentLinkedQueue，最初是空的。
ConcurrentLinkedQueue(Collection<? extends E> c) 创建一个 ConcurrentLinkedQueue最初包含元素的集合，加入集合的迭代器遍历顺序。

方法摘要

Modifier and Type	Method and Description
boolean	add(E e) 在这个队列的尾部插入指定的元素。
boolean	addAll(Collection<? extends E> c) 追加指定集合的所有元素到这个队列的末尾，按他们的指定集合的迭代器返回。
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() 返回此队列中的元素的数目。
Spliterator<E>	spliterator() 返回队列中的元素在这一 Spliterator。
Object[]	toArray() 返回一个数组，包含这个队列中的所有元素，在适当的顺序。
<T> T[]	toArray(T[] a) 返回一个包含此队列中所有元素的数组，在适当的顺序；返回的数组的运行时类型是指定的数组的运行时类型。

Methods inherited from class java.util.AbstractQueue

clear, element, remove

Methods inherited from class java.util.AbstractCollection

containsAll, removeAll, retainAll, toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.Queue

element, remove

Methods inherited from interface java.util.Collection

clear, containsAll, equals, hashCode, parallelStream, removeAll, removeIf, retainAll, stream

Methods inherited from interface java.lang.Iterable

forEach

Constructor Detail

ConcurrentLinkedQueue

public ConcurrentLinkedQueue()

创建一个 ConcurrentLinkedQueue，最初是空的。

ConcurrentLinkedQueue

public ConcurrentLinkedQueue(Collection<? extends E> c)

创建一个 ConcurrentLinkedQueue最初包含元素的集合，加入集合的迭代器遍历顺序。

参数

c -最初包含元素的集合

异常

NullPointerException -如果指定集合或其任何元素都是空的

方法详细信息

add

public boolean add(E e)

在这个队列的尾部插入指定的元素。因为队列是无界的，这种方法不会扔 IllegalStateException或返回 false。

Specified by:

add 接口 Collection<E>

Specified by:

add 接口 Queue<E>

重写：

add 方法重写，继承类 AbstractQueue<E>

参数

e -元素添加

结果

true（由 Collection.add(E)指定）

异常

NullPointerException -如果指定元素为null

offer

public boolean offer(E e)

在这个队列的尾部插入指定的元素。因为队列是无界的，这种方法不会返回 false。

Specified by:

offer 接口 Queue<E>

参数

e -元素添加

结果

true（由 Queue.offer(E)指定）

异常

NullPointerException -如果指定元素为null

poll

public E poll()

从接口复制的描述： Queue

检索并移除此队列的头，或返回 null如果队列为空。

Specified by:

poll 接口 Queue<E>

结果

这个队列头，或 null如果队列为空

peek

public E peek()

从接口复制的描述： Queue

检索，但不删除，这个队列头，或返回 null如果队列为空。

Specified by:

peek 接口 Queue<E>

结果

这个队列头，或 null如果队列为空

isEmpty

public boolean isEmpty()

返回 true如果队列不包含元素。

Specified by:

isEmpty 接口 Collection<E>

重写：

isEmpty 方法重写，继承类 AbstractCollection<E>

结果

true如果队列不包含元素

size

public int size()

返回此队列中的元素的数目。如果此队列包含多 Integer.MAX_VALUE元素，返回

请注意，与大多数集合不同，此方法不是一个常数时间操作。由于这些队列的异步性质，确定当前元素的当前数量需要一个O（n）遍历。此外，如果在该方法的执行过程中添加或删除元素，则返回的结果可能是不准确的。因此，这种方法通常是不是非常有用的并发应用程序。

Integer.MAX_VALUE。

Specified by:

size 接口 Collection<E>

Specified by:

size 方法重写，继承类 AbstractCollection<E>

结果

这个队列中的元素的数目

contains

public boolean contains(Object o)

返回 true如果此队列包含指定的元素。更正式地说，返回 true当且仅当该队列包含至少一个元素 e这样 o.equals(e)。

Specified by:

contains 接口 Collection<E>

重写：

contains 方法重写，继承类 AbstractCollection<E>

参数

o对象需要检查该队列中的遏制

结果

true如果此队列包含指定的元素

remove

public boolean remove(Object o)

从该队列中移除指定元素的一个实例，如果它是存在的。更正式地说，删除一个元素 e这样 o.equals(e)，如果此队列包含一个或多个这样的元素。返回 true如果此队列包含指定元素（或等价地，如果调用的结果这个队列改变）。

Specified by:

remove 接口 Collection<E>

重写：

remove 方法重写，继承类 AbstractCollection<E>

参数

o元素被从队列中删除，如果存在

结果

true如果调用的结果改变了这个队列

addAll

public boolean addAll(Collection<? extends E> c)

追加指定集合的所有元素到这个队列的末尾，按他们的指定集合的迭代器返回。试图 addAll一队列本身造成 IllegalArgumentException。

Specified by:

addAll 接口 Collection<E>

重写：

addAll 方法重写，继承类 AbstractQueue<E>

参数

c -被插入到这个队列中的元素

结果

true如果调用的结果改变了这个队列

异常

NullPointerException -如果指定集合或其任何元素都是空的

IllegalArgumentException -如果集合是这个队列

另请参见：

AbstractQueue.add(Object)

toArray

public Object[] toArray()

返回一个数组，包含这个队列中的所有元素，在适当的顺序。

返回的数组将是“安全”的，在这个队列中没有引用它的引用。（换句话说，这种方法必须分配一个新的数组）。因此，调用方可以自由修改返回的数组。

此方法作为基于数组和基于集合的原料药之间的桥梁。

Specified by:

toArray 接口 Collection<E>

重写：

toArray 方法重写，继承类 AbstractCollection<E>

结果

包含在这个队列中的所有元素的数组

toArray

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

返回一个包含此队列中所有元素的数组，在适当的顺序；返回的数组的运行时类型是指定的数组的运行时类型。如果队列安装在指定的数组中，则返回队列中。否则，一个新的数组被分配与指定数组的运行时类型和该队列的大小。

如果此队列符合指定数组中剩余的空间（即数组有比这更多的元素，在队列）阵列立即结束的队列的元素设置为null。

像toArray()方法，该方法作为之间的桥梁，基于阵列和基于集合API。此外，该方法允许对输出数组的运行时类型的精确控制，并在某些情况下，可用于节省分配成本。

假设是已知x队列只包含字符串。下面的代码可以用来倾倒排队到新分配的数组String：

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

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

Specified by:

toArray 接口 Collection<E>

重写：

toArray 方法重写，继承类 AbstractCollection<E>

参数类型

T -数组的运行时类型包含集合

参数

a -进入队列的元素被存储数组，如果它足够大；否则，一个新的运行时类型相同的数组分配给这个目的

结果

包含在这个队列中的所有元素的数组

异常

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

NullPointerException -如果指定的数组是空的

iterator

public Iterator<E> iterator()

在这个队列中的元素上返回一个正确的顺序。元素将从第一（头）返回到最后（尾）。

返回的迭代器是weakly consistent。

Specified by:

iterator 接口 Iterable<E>

Specified by:

iterator 接口 Collection<E>

Specified by:

iterator 方法重写，继承类 AbstractCollection<E>

结果

在这个队列中的元素的迭代器在适当的顺序

spliterator

public Spliterator<E> spliterator()

返回队列中的元素在这一 Spliterator。

返回的spliterator是weakly consistent。

报告的Spliterator Spliterator.CONCURRENT，Spliterator.ORDERED，和Spliterator.NONNULL。

Specified by:

spliterator 接口 Iterable<E>

Specified by:

spliterator 接口 Collection<E>

Implementation Note:

的 Spliterator trySplit允许有限的并行实现。

结果

在该队列中的元素的 Spliterator

从以下版本开始：

一点八