模块 java.base
包 java.util.concurrent

类 ConcurrentLinkedQueue<E>

java.lang.Object
java.util.AbstractCollection <E>
java.util.AbstractQueue <E>
java.util.concurrent.ConcurrentLinkedQueue<E>
类型参数：
E - 此队列中保存的元素类型
所有已实现的接口：
Serializable , Iterable<E> , Collection<E> , Queue<E>
public class ConcurrentLinkedQueue<E> extends AbstractQueue <E> implements Queue <E>, Serializable
基于链接节点的无限线程安全队列。该队列对元素进行 FIFO（先进先出）排序。队列的 head 是队列中时间最长的元素。队列的 tail 是在队列中时间最短的元素。新元素插入队列尾部，队列检索操作获取队列头部元素。当许多线程将共享对公共集合的访问时，ConcurrentLinkedQueue 是一个合适的选择。与大多数其他并发集合实现一样，此类不允许使用 null 元素。

此实现采用高效的 non-blocking 算法，该算法基于 Maged M. Michael 和 Michael L. Scott 在 简单快速实用的非阻塞和阻塞并发队列算法 中描述的算法。

迭代器是弱一致，在创建迭代器时或自创建迭代器后的某个时刻返回反映队列状态的元素。他们做 not throw ConcurrentModificationException ，并可能与其他操作同时进行。自创建迭代器以来队列中包含的元素将恰好返回一次。

请注意，与大多数集合不同，size 方法是 NOT 恒定时间操作。由于这些队列的异步特性，确定当前元素数量需要遍历元素，因此如果在遍历期间修改此集合，则可能会报告不准确的结果。

添加、删除或检查多个元素的批量操作，例如 addAll(java.util.Collection<? extends E>) 、removeIf(java.util.function.Predicate<? super E>) 或 forEach(java.util.function.Consumer<? super E>) ，not 保证以原子方式执行。例如，与 addAll 操作并发的 forEach 遍历可能只会观察到一些添加的元素。

此类及其迭代器实现了 Queue 和 Iterator 接口的所有 optional 方法。

内存一致性影响：与其他并发集合一样，在将对象放入 ConcurrentLinkedQueue 发生在之前 之前线程中的操作是在另一个线程中从 ConcurrentLinkedQueue 访问或删除该元素之后的操作。

此类是 Java 集合框架 的成员。

自从：
1.5
参见：

  • 构造方法总结

    构造方法
    构造方法
    描述
    ConcurrentLinkedQueue()
    创建一个最初为空的 ConcurrentLinkedQueue。
    ConcurrentLinkedQueue(Collection<? extends E> c)
    创建一个 ConcurrentLinkedQueue 最初包含给定集合的元素，按集合迭代器的遍历顺序添加。

  • 方法总结

    修饰符和类型
    方法
    描述
    boolean
    add(E e)
    将指定元素插入此队列的尾部。
    boolean
    addAll(Collection<? extends E> c)
    将指定集合中的所有元素追加到此队列的末尾，按照它们由指定集合的迭代器返回的顺序。
    void
    clear()
    从此队列中删除所有元素。
    boolean
    contains(Object o)
    如果此队列包含指定元素，则返回 true。
    void
    forEach(Consumer<? super E> action)
    对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或操作引发异常。
    boolean
    isEmpty()
    如果此队列不包含任何元素，则返回 true。
    Iterator<E>
    iterator()
    按正确顺序返回此队列中元素的迭代器。
    boolean
    offer(E e)
    将指定元素插入此队列的尾部。
    E
    peek()
    检索但不删除此队列的头部，如果此队列为空，则返回 null。
    E
    poll()
    检索并删除此队列的头部，如果此队列为空，则返回 null。
    boolean
    remove(Object o)
    从此队列中移除指定元素的单个实例（如果存在）。
    boolean
    removeAll(Collection<?> c)
    删除此集合的所有也包含在指定集合中的元素（可选操作）。
    boolean
    removeIf(Predicate<? super E> filter)
    移除此集合中满足给定谓词的所有元素。
    boolean
    retainAll(Collection<?> c)
    仅保留此集合中包含在指定集合中的元素（可选操作）。
    int
    size()
    返回此队列中的元素数。
    Spliterator<E>
    spliterator()
    在此队列中的元素上返回一个 Spliterator 。
    Object[]
    toArray()
    以正确的顺序返回包含此队列中所有元素的数组。
    <T> T[]
    toArray(T[] a)
    以适当的顺序返回一个包含此队列中所有元素的数组；返回数组的运行时类型是指定数组的类型。

    在类 java.util.AbstractQueue 中声明的方法

    clear, element, remove

    在类 java.util.AbstractCollection 中声明的方法

    containsAll, toString

    在类 java.lang.Object 中声明的方法

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

    在接口 java.util.Collection 中声明的方法

    containsAll, equals, hashCode, parallelStream, stream, toArray

    在接口 java.util.Queue 中声明的方法

    element, remove

  • 构造方法详细信息

    • ConcurrentLinkedQueue

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

    • ConcurrentLinkedQueue

      public ConcurrentLinkedQueue(Collection <? extends E > c)
      创建一个 ConcurrentLinkedQueue 最初包含给定集合的元素，按集合迭代器的遍历顺序添加。
      参数：
      c - 最初包含的元素集合
      抛出：
      NullPointerException - 如果指定的集合或其任何元素为空

  • 方法详情

    • add

      public boolean add(E  e)
      将指定元素插入此队列的尾部。由于队列是无界的，此方法永远不会抛出 IllegalStateException 或返回 false 。
      指定者：
      add 在接口 Collection<E> 中
      指定者：
      add 在接口 Queue<E> 中
      重写：
      add 在类 AbstractQueue<E> 中
      参数：
      e - 要添加的元素
      返回：
      true（由 Collection.add(E) 指定）
      抛出：
      NullPointerException - 如果指定元素为空

    • offer

      public boolean offer(E  e)
      将指定元素插入此队列的尾部。由于队列是无界的，此方法永远不会返回 false 。
      指定者：
      offer 在接口 Queue<E> 中
      参数：
      e - 要添加的元素
      返回：
      true（由 Queue.offer(E) 指定）
      抛出：
      NullPointerException - 如果指定元素为空

    • poll

      public E  poll()
      从接口 Queue 复制的描述
      检索并删除此队列的头部，如果此队列为空，则返回 null。
      指定者：
      poll 在接口 Queue<E> 中
      返回：
      此队列的头部，或 null 如果此队列为空

    • peek

      public E  peek()
      从接口 Queue 复制的描述
      检索但不删除此队列的头部，如果此队列为空，则返回 null。
      指定者：
      peek 在接口 Queue<E> 中
      返回：
      此队列的头部，或 null 如果此队列为空

    • isEmpty

      public boolean isEmpty()
      如果此队列不包含任何元素，则返回 true。
      指定者：
      isEmpty 在接口 Collection<E> 中
      重写：
      isEmpty 在类 AbstractCollection<E> 中
      返回：
      true 如果这个队列不包含任何元素

    • size

      public int size()
      返回此队列中的元素数。如果此队列包含超过 Integer.MAX_VALUE 个元素，则返回 Integer.MAX_VALUE 。

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

      指定者：
      size 在接口 Collection<E> 中
      返回：
      此队列中的元素数

    • contains

      public boolean contains(Object  o)
      如果此队列包含指定元素，则返回 true。更正式地说，返回 true 当且仅当此队列包含至少一个元素 e 使得 o.equals(e) 。
      指定者：
      contains 在接口 Collection<E> 中
      重写：
      contains 在类 AbstractCollection<E> 中
      参数：
      o - 要检查此队列中包含的对象
      返回：
      true 如果此队列包含指定元素

    • remove

      public boolean remove(Object  o)
      从此队列中移除指定元素的单个实例（如果存在）。更正式地说，如果此队列包含一个或多个此类元素，则删除一个元素 e 使得 o.equals(e) 。如果此队列包含指定元素，则返回 true（或者等效地，如果此队列因调用而更改）。
      指定者：
      remove 在接口 Collection<E> 中
      重写：
      remove 在类 AbstractCollection<E> 中
      参数：
      o - 要从此队列中删除的元素（如果存在）
      返回：
      true 如果此队列因调用而更改

    • addAll

      public boolean addAll(Collection <? extends E > c)
      将指定集合中的所有元素追加到此队列的末尾，按照它们由指定集合的迭代器返回的顺序。尝试 addAll 队列自身导致 IllegalArgumentException 。
      指定者：
      addAll 在接口 Collection<E> 中
      重写：
      addAll 在类 AbstractQueue<E> 中
      参数：
      c - 要插入此队列的元素
      返回：
      true 如果此队列因调用而更改
      抛出：
      NullPointerException - 如果指定的集合或其任何元素为空
      IllegalArgumentException - 如果集合是这个队列
      参见：

    • toArray

      public Object [] toArray()
      以正确的顺序返回包含此队列中所有元素的数组。

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

      此方法充当基于数组和基于集合的 API 之间的桥梁。

      指定者：
      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() 相同。
      指定者：
      toArray 在接口 Collection<E> 中
      重写：
      toArray 在类 AbstractCollection<E> 中
      类型参数：
      T - 包含集合的数组的组件类型
      参数：
      a - 要存储队列元素的数组，如果它足够大的话；否则，为此分配一个相同运行时类型的新数组
      返回：
      包含此队列中所有元素的数组
      抛出：
      ArrayStoreException - 如果指定数组的运行时类型不是此队列中每个元素的运行时类型的超类型
      NullPointerException - 如果指定数组为空

    • iterator

      public Iterator <E > iterator()
      按正确顺序返回此队列中元素的迭代器。元素将按从第一个（头）到最后一个（尾）的顺序返回。

      返回的迭代器是 弱一致 。

      指定者：
      iterator 在接口 Collection<E> 中
      指定者：
      iterator 在接口 Iterable<E> 中
      指定者：
      iterator 在类 AbstractCollection<E> 中
      返回：
      以适当顺序对该队列中的元素进行迭代

    • spliterator

      public Spliterator <E > spliterator()
      在此队列中的元素上返回一个 Spliterator 。

      返回的拆分器是 弱一致 。

      Spliterator 报告 Spliterator.CONCURRENT 、Spliterator.ORDERED 和 Spliterator.NONNULL 。

      指定者：
      spliterator 在接口 Collection<E> 中
      指定者：
      spliterator 在接口 Iterable<E> 中
      实现注意事项：
      Spliterator 实现 trySplit 以允许有限的并行性。
      返回：
      a Spliterator 遍历此队列中的元素
      自从：
      1.8

    • removeIf

      public boolean removeIf(Predicate <? super E > filter)
      从接口 Collection 复制的描述
      移除此集合中满足给定谓词的所有元素。迭代期间或由谓词抛出的错误或运行时异常将传递给调用者。
      指定者：
      removeIf 在接口 Collection<E> 中
      参数：
      filter - 为要删除的元素返回 true 的谓词
      返回：
      true 如果删除了任何元素
      抛出：
      NullPointerException - 如果指定的过滤器为空

    • removeAll

      public boolean removeAll(Collection <?> c)
      从类复制的描述：AbstractCollection
      删除此集合的所有也包含在指定集合中的元素（可选操作）。此调用返回后，此集合将不包含与指定集合共有的元素。
      指定者：
      removeAll 在接口 Collection<E> 中
      重写：
      removeAll 在类 AbstractCollection<E> 中
      参数：
      c - 包含要从此集合中删除的元素的集合
      返回：
      true 如果此集合因调用而更改
      抛出：
      NullPointerException - 如果此集合包含一个或多个空元素并且指定的集合不支持空元素 (optional)，或者如果指定的集合为空
      参见：

    • retainAll

      public boolean retainAll(Collection <?> c)
      从类复制的描述：AbstractCollection
      仅保留此集合中包含在指定集合中的元素（可选操作）。换句话说，从该集合中移除所有未包含在指定集合中的元素。
      指定者：
      retainAll 在接口 Collection<E> 中
      重写：
      retainAll 在类 AbstractCollection<E> 中
      参数：
      c - 包含要保留在此集合中的元素的集合
      返回：
      true 如果此集合因调用而更改
      抛出：
      NullPointerException - 如果此集合包含一个或多个空元素并且指定的集合不允许空元素 (optional)，或者如果指定的集合为空
      参见：

    • clear

      public void clear()
      从类复制的描述：AbstractQueue
      从此队列中删除所有元素。此调用返回后队列将为空。

      此实现重复调用 poll 直到它返回 null 。

      指定者：
      clear 在接口 Collection<E> 中
      重写：
      clear 在类 AbstractQueue<E> 中

    • forEach

      public void forEach(Consumer <? super E > action)
      从接口 Iterable 复制的描述
      对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或操作引发异常。如果指定了迭代顺序，则将按迭代顺序执行操作。操作抛出的异常被转发给调用者。

      如果操作执行修改元素的底层源的副作用，则此方法的行为是未指定的，除非重写类已指定并发修改策略。

      指定者：
      forEach 在接口 Iterable<E> 中
      参数：
      action - 对每个元素执行的操作
      抛出：
      NullPointerException - 如果指定的操作为空