当前页面: 在线文档首页 > JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

LinkedBlockingQueue (Java 2 Platform SE 5.0) - JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

概述  软件包   类  使用  树  已过时  索引  帮助		JavaTM 2 Platform Standard Ed. 5.0
上一个类   下一个类	框架    无框架
摘要： 嵌套 | 字段 | 构造方法 | 方法	详细信息： 字段 | 构造方法 | 方法

---

java.util.concurrent
类 LinkedBlockingQueue<E>

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

类型参数：

E - 集合中所保存元素的类型。

所有已实现的接口：

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，最初包含给定集合的元素，元素按该集合迭代器的遍历顺序添加。
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 o)           如果可能，在队列尾部插入指定的元素，如果队列已满则立即返回。
boolean	offer(E o, long timeout, TimeUnit unit)           在队列尾插入指定的元素，如有必要，则等待指定的时间以使空间变得可用。
E	peek()           检索，但是不移除此队列的头，如果此队列为空，则返回 null。
E	poll()           检索并移除此队列的头，如果此队列为空，则返回 null。
E	poll(long timeout, TimeUnit unit)           检索并移除此队列的头部，如果此队列中没有任何元素，则等待指定等待的时间（如果有必要）。
void	put(E o)           将指定的元素添加到队列的尾部，如有必要，则等待空间变得可用。
int	remainingCapacity()           返回理想情况下（没有内存和资源约束）此队列可接受并且不会被阻塞的元素数量。
boolean	remove(Object o)           从此队列移除指定元素的单个实例（如果存在）。
int	size()           返回队列中的元素个数。
E	take()           检索并移除此队列的头部，如果此队列不存在任何元素，则一直等待。
Object[]	toArray()           返回包含此 collection 中所有元素的数组。
<T> T[]	toArray(T[] a)           返回包含此 collection 中所有元素的数组；返回数组的运行时类型是指定数组的类型。
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

 

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

 

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

 

构造方法详细信息

LinkedBlockingQueue

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，最初包含给定集合的元素，元素按该集合迭代器的遍历顺序添加。

参数：

c - 最初所包含元素所属的集合。

抛出：

NullPointerException - 如果 c 或其中的任意元素为 null。

方法详细信息

size

public int size()

返回队列中的元素个数。

指定者：

接口 Collection<E> 中的 size

指定者：

类 AbstractCollection<E> 中的 size

返回：

队列中的元素个数。

---

remainingCapacity

public int remainingCapacity()

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

注意，不能 总是通过检查 remainingCapacity 来断定试图 add 一个元素是否成功，因为可能是等待的使用者已经准备好从一个已满的队列 take 某个元素。

指定者：

接口 BlockingQueue<E> 中的 remainingCapacity

返回：

剩余容量

---

put

public void put(E o)
         throws InterruptedException

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

指定者：

接口 BlockingQueue<E> 中的 put

参数：

o - 要添加的元素。

抛出：

InterruptedException - 如果在等待时中断。

NullPointerException - 如果指定的元素为 null。

---

offer

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

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

指定者：

接口 BlockingQueue<E> 中的 offer

参数：

o - 要添加的元素。

timeout - 放弃前等待多长时间，单位是 unit。

unit - 确定如何解释 timeout 参数的 TimeUnit。

返回：

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

抛出：

InterruptedException - 如果等待时中断。

NullPointerException - 如果指定的元素为 null。

---

offer

public boolean offer(E o)

如果可能，在队列尾部插入指定的元素，如果队列已满则立即返回。

指定者：

接口 BlockingQueue<E> 中的 offer

指定者：

接口 Queue<E> 中的 offer

参数：

o - 要添加的元素。

返回：

如果可以向此队列添加元素，则返回 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)

从此队列移除指定元素的单个实例（如果存在）。

指定者：

接口 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 的元素的数组。

---

toString

public String toString()

从类 AbstractCollection 复制的描述

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

此实现会创建一个空字符串缓冲区，追加一个左方括号，然后在 collection 上进行迭代，依次追加每个元素的字符串表示形式。每追加一个元素后（最后一个元素除外），将追加字符串 ", "。最后，追加一个右括号。从字符串缓冲区获取一个字符串并返回它。

覆盖：

类 AbstractCollection<E> 中的 toString

返回：

此 collection 的字符串表示形式。

---

clear

public void clear()

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

指定者：

接口 Collection<E> 中的 clear

覆盖：

类 AbstractQueue<E> 中的 clear

---

drainTo

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

从接口 BlockingQueue 复制的描述

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

指定者：

接口 BlockingQueue<E> 中的 drainTo

参数：

c - 接收传输元素的 collection

返回：

传输元素的数量。

---

drainTo

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

从接口 BlockingQueue 复制的描述

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

指定者：

接口 BlockingQueue<E> 中的 drainTo

参数：

c - 接收传输元素的 collection

maxElements - 传输元素的最大数量

返回：

传输元素的数量。

---

iterator

public Iterator<E> iterator()

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

指定者：

接口 Iterable<E> 中的 iterator

指定者：

接口 Collection<E> 中的 iterator

指定者：

类 AbstractCollection<E> 中的 iterator

返回：

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

---

概述  软件包   类  使用  树  已过时  索引  帮助		JavaTM 2 Platform Standard Ed. 5.0
上一个类   下一个类	框架    无框架
摘要： 嵌套 | 字段 | 构造方法 | 方法	详细信息： 字段 | 构造方法 | 方法

---

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

版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。