LinkedBlockingQueue

目录搜索

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

java.util.concurrent
类 LinkedBlockingQueue<E>

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


类型参数：: E - 此 collection 中所保存元素的类型。

所有已实现的接口：: Serializable, Iterable<E>, Collection<E>, BlockingQueue<E>, Queue<E>

public class LinkedBlockingQueue<E>
extends AbstractQueue<E>
implements BlockingQueue<E>, Serializable

一个基于已链接节点的、范围任意的 blocking queue。此队列按 FIFO（先进先出）排序元素。队列的头部是在队列中时间最长的元素。队列的尾部是在队列中时间最短的元素。新元素插入到队列的尾部，并且队列获取操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。

可选的容量范围构造方法参数作为防止队列过度扩展的一种方法。如果未指定容量，则它等于 Integer.MAX_VALUE。除非插入节点会使队列超出容量，否则每次插入后会动态地创建链接节点。

此类及其迭代器实现 Collection 和 Iterator 接口的所有可选方法。

此类是 Java Collections Framework 的成员。

从以下版本开始：: 1.5
另请参见：: 序列化表格

构造方法摘要
`LinkedBlockingQueue()` 创建一个容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`。
`LinkedBlockingQueue(Collection<? extends E> c)` 创建一个容量是 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`，最初包含给定 collection 的元素，元素按该 collection 迭代器的遍历顺序添加。
`LinkedBlockingQueue(int capacity)` 创建一个具有给定（固定）容量的 `LinkedBlockingQueue`。

方法摘要

void clear()
从队列彻底移除所有元素。

int drainTo(Collection<? super E> c)
移除此队列中所有可用的元素，并将它们添加到给定 collection 中。

int drainTo(Collection<? super E> c, int maxElements)
最多从此队列中移除给定数量的可用元素，并将这些元素添加到给定 collection 中。

Iterator<E> iterator()
返回在队列中的元素上按适当顺序进行迭代的迭代器。

boolean offer(E e)
将指定元素插入到此队列的尾部（如果立即可行且不会超出此队列的容量），在成功时返回 true，如果此队列已满，则返回 false。

boolean offer(E e, long timeout, TimeUnit unit)
将指定元素插入到此队列的尾部，如有必要，则等待指定的时间以使空间变得可用。

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

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

E poll(long timeout, TimeUnit unit)
获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。

void put(E e)
将指定元素插入到此队列的尾部，如有必要，则等待空间变得可用。

int remainingCapacity()
返回理想情况下（没有内存和资源约束）此队列可接受并且不会被阻塞的附加元素数量。

boolean remove(Object o)
从此队列移除指定元素的单个实例（如果存在）。

int size()
返回队列中的元素个数。

E take()
获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。

Object[] toArray()
返回按适当顺序包含此队列中所有元素的数组。




<T> T[]

toArray(T[] a)
返回按适当顺序包含此队列中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

String toString()
返回此 collection 的字符串表示形式。

从类 java.util.AbstractQueue 继承的方法
`add, addAll, element, remove`

从类 java.util.AbstractCollection 继承的方法
`contains, containsAll, isEmpty, removeAll, retainAll`

从类 java.lang.Object 继承的方法
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

从接口 java.util.concurrent.BlockingQueue 继承的方法
`add, contains`

从接口 java.util.Queue 继承的方法
`element, remove`

从接口 java.util.Collection 继承的方法
`addAll, containsAll, equals, hashCode, isEmpty, removeAll, retainAll`

构造方法详细信息

public LinkedBlockingQueue()

创建一个容量为 Integer.MAX_VALUE 的 LinkedBlockingQueue。

LinkedBlockingQueue

public LinkedBlockingQueue(int capacity)

创建一个具有给定（固定）容量的 LinkedBlockingQueue。

参数：: capacity - 队列的容量
抛出：: IllegalArgumentException - 如果 capacity 未大于 0

LinkedBlockingQueue

public LinkedBlockingQueue(Collection<? extends E> c)

创建一个容量是 Integer.MAX_VALUE 的 LinkedBlockingQueue，最初包含给定 collection 的元素，元素按该 collection 迭代器的遍历顺序添加。

参数：: c - 最初所包含元素所属的 collection
抛出：: NullPointerException - 如果指定 collection 或其所有元素均为 null

方法详细信息

size

public int size()

返回队列中的元素个数。

指定者：: 接口 Collection<E> 中的 size
指定者：: 类 AbstractCollection<E> 中的 size

返回：: 队列中的元素个数

remainingCapacity

public int remainingCapacity()

返回理想情况下（没有内存和资源约束）此队列可接受并且不会被阻塞的附加元素数量。该数量总是等于此队列的初始容量，小于队列的当前 size。

注意，不能总是通过检查 remainingCapacity 来断定试图插入一个元素是否成功，因为可能是另一个线程将插入或移除某个元素。

指定者：: 接口 BlockingQueue<E> 中的 remainingCapacity

返回：: 剩余容量

put

public void put(E e)
         throws InterruptedException

将指定元素插入到此队列的尾部，如有必要，则等待空间变得可用。

指定者：: 接口 BlockingQueue<E> 中的 put

参数：: e - 要添加的元素
抛出：: InterruptedException - 如果在等待时被中断; NullPointerException - 如果指定元素为 null

offer

public boolean offer(E e,
                     long timeout,
                     TimeUnit unit)
              throws InterruptedException

将指定元素插入到此队列的尾部，如有必要，则等待指定的时间以使空间变得可用。

指定者：: 接口 BlockingQueue<E> 中的 offer

参数：: e - 要添加的元素; timeout - 放弃之前等待的时间长度，以 unit 为时间单位; unit - 确定如何解释 timeout 参数的 TimeUnit

返回：

如果成功，则返回 true；如果在空间可用前超出了指定的时间，则返回 false。

抛出：

InterruptedException - 如果在等待时被中断

NullPointerException - 如果指定元素为 null

offer

public boolean offer(E e)

将指定元素插入到此队列的尾部（如果立即可行且不会超出此队列的容量），在成功时返回 true，如果此队列已满，则返回 false。当使用有容量限制的队列时，此方法通常要优于 add 方法，后者可能无法插入元素，而只是抛出一个异常。

指定者：: 接口 BlockingQueue<E> 中的 offer
指定者：: 接口 Queue<E> 中的 offer

参数：: e - 要添加的元素
返回：: 如果该元素已添加到此队列，则返回 true；否则返回 false
抛出：: NullPointerException - 如果指定元素为 null

take

public E take()
       throws InterruptedException

从接口 BlockingQueue 复制的描述

获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。

指定者：: 接口 BlockingQueue<E> 中的 take

返回：: 此队列的头部
抛出：: InterruptedException - 如果在等待时被中断

poll

public E poll(long timeout,
              TimeUnit unit)
       throws InterruptedException

从接口 BlockingQueue 复制的描述

获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。

指定者：: 接口 BlockingQueue<E> 中的 poll

参数：: timeout - 放弃之前要等待的时间长度，用 unit 的时间单位表示; unit - 确定如何解释 timeout 参数的 TimeUnit

返回：

此队列的头部；如果在元素可用前超过了指定的等待时间，则返回 null

抛出：

InterruptedException - 如果在等待时被中断

poll

public E poll()

从接口 Queue 复制的描述

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

指定者：: 接口 Queue<E> 中的 poll

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

peek

public E peek()

从接口 Queue 复制的描述

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

指定者：: 接口 Queue<E> 中的 peek

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

remove

public boolean remove(Object o)

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

指定者：: 接口 Collection<E> 中的 remove
指定者：: 接口 BlockingQueue<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

toString

public String toString()

从类 AbstractCollection 复制的描述

返回此 collection 的字符串表示形式。该字符串表示形式由 collection 元素的列表组成，这些元素按其迭代器返回的顺序排列，并用方括号 ("[]") 括起来。相邻元素由字符 ", "（逗号加空格）分隔。通过 String.valueOf(Object) 可以将元素转换成字符串。

覆盖：: 类 AbstractCollection<E> 中的 toString

返回：: 此 collection 的字符串表示形式

clear

public void clear()

从队列彻底移除所有元素。此调用返回后队列为空。

指定者：: 接口 Collection<E> 中的 clear
覆盖：: 类 AbstractQueue<E> 中的 clear

drainTo

public int drainTo(Collection<? super E> c)

从接口 BlockingQueue 复制的描述

移除此队列中所有可用的元素，并将它们添加到给定 collection 中。此操作可能比反复轮询此队列更有效。在试图向 collection c 中添加元素没有成功时，可能导致在抛出相关异常时，元素会同时在两个 collection 中出现，或者在其中一个 collection 中出现，也可能在两个 collection 中都不出现。如果试图将一个队列放入自身队列中，则会导致 IllegalArgumentException 异常。此外，如果正在进行此操作时修改指定的 collection，则此操作行为是不确定的。

指定者：: 接口 BlockingQueue<E> 中的 drainTo

参数：: c - 接收传输元素的 collection
返回：: 传输元素的数量
抛出：: UnsupportedOperationException - 如果指定 collection 不支持添加元素; ClassCastException - 如果此队列元素的类不允许将其添加到指定 collection; NullPointerException - 如果指定 collection 为 null; IllegalArgumentException - 如果指定 collection 是此队列，或者此队列元素的某些属性不允许将其添加到指定 collection

drainTo

public int drainTo(Collection<? super E> c,
                   int maxElements)

从接口 BlockingQueue 复制的描述

最多从此队列中移除给定数量的可用元素，并将这些元素添加到给定 collection 中。在试图向 collection c 中添加元素没有成功时，可能导致在抛出相关异常时，元素会同时在两个 collection 中出现，或者在其中一个 collection 中出现，也可能在两个 collection 中都不出现。如果试图将一个队列放入自身队列中，则会导致 IllegalArgumentException 异常。此外，如果正在进行此操作时修改指定的 collection，则此操作行为是不确定的。

指定者：: 接口 BlockingQueue<E> 中的 drainTo

参数：: c - 接收传输元素的 collection; maxElements - 传输元素的最大数量

返回：

传输元素的数量

抛出：

UnsupportedOperationException - 如果指定 collection 不支持添加元素

ClassCastException - 如果此队列元素的类不允许将其添加到指定 collection

NullPointerException - 如果指定 collection 为 null

IllegalArgumentException - 如果指定 collection 是此队列，或者此队列元素的某些属性不允许将其添加到指定 collection

iterator

public Iterator<E> iterator()

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

指定者：: 接口 Iterable<E> 中的 iterator
指定者：: 接口 Collection<E> 中的 iterator
指定者：: 类 AbstractCollection<E> 中的 iterator

返回：: 按适当顺序对队列中的元素进行迭代的迭代器

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

java.util.concurrent 类 LinkedBlockingQueue<E>

LinkedBlockingQueue

LinkedBlockingQueue

LinkedBlockingQueue

size

remainingCapacity

put

offer

offer

take

poll

poll

peek

remove

toArray

toArray

toString

clear

drainTo

drainTo

iterator

java.util.concurrent
类 LinkedBlockingQueue<E>