站内搜索: 请输入搜索关键词
当前页面: 在线文档首页 > JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

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

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

java.util.concurrent
类 SynchronousQueue<E>

java.lang.Object
  继承者 java.util.AbstractCollection<E>
      继承者 java.util.AbstractQueue<E>
          继承者 java.util.concurrent.SynchronousQueue<E>
类型参数：
E - 此集合保持的元素类型。
所有已实现的接口：
Serializable, Iterable<E>, Collection<E>, BlockingQueue<E>, Queue<E>
public class SynchronousQueue<E>
extends AbstractQueue<E>
implements BlockingQueue<E>, Serializable

一种阻塞队列，其中每个 put 必须等待一个 take，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。不能在同步队列上进行 peek，因为仅在试图要取得元素时，该元素才存在；除非另一个线程试图移除某个元素，否则也不能（使用任何方法）添加元素；也不能迭代队列，因为其中没有元素可用于迭代。队列的头 是尝试添加到队列中的首个已排队线程元素；如果没有已排队线程，则不添加元素并且头为 null。对于其他 Collection 方法（例如 contains），SynchronousQueue 作为一个空集合。此队列不允许 null 元素。

同步队列类似于 CSP 和 Ada 中使用的 rendezvous 信道。它非常适合于传递性设计，在这种设计中，在一个线程中运行的对象要将某些信息、事件或任务传递给在另一个线程中运行的对象，它就必须与该对象同步。

对于正在等待的生产者和使用者线程而言，此类支持可选的公平排序策略。默认情况下不保证这种排序。但是，使用公平设置为 true 所构造的队列可保证线程以 FIFO 的顺序进行访问。公平通常会降低吞吐量，但是可以减小可变性并避免得不到服务。

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

此类是 Java Collections Framework 的成员。

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

构造方法摘要
SynchronousQueue()
          创建一个具有非公平访问策略的 SynchronousQueue。
SynchronousQueue(boolean fair)
          创建一个具有指定公平策略的 SynchronousQueue。
 
方法摘要
 void clear()
          不执行任何操作。
 boolean contains(Object o)
          始终返回 false。
 boolean containsAll(Collection<?> c)
          除非给定集合为空，否则返回 false。
 int drainTo(Collection<? super E> c)
          移除此队列中所有可用的元素，并将它们添加到给定 collection 中。
 int drainTo(Collection<? super E> c, int maxElements)
          最多从此队列中移除给定数量的可用元素，并将这些元素添加到给定 collection 中。
 boolean isEmpty()
          始终返回 true。
 Iterator<E> iterator()
          返回一个空迭代器，其中 hasNext 始终返回 false。
 boolean offer(E o)
          如果另一个线程正在等待接收指定的元素，则将其插入此队列。
 boolean offer(E o, long timeout, TimeUnit unit)
          将指定的元素插入到此队列，如有必要则等待指定的时间，以便另一个线程接收它。
 E peek()
          始终返回 null。
 E poll()
          如果另一个线程当前正要使用某个元素，则检索并移除此队列的头。
 E poll(long timeout, TimeUnit unit)
          检索并移除此队列的头，如有必要则等待指定的时间，以便另一个线程插入它。
 void put(E o)
          将指定的元素添加到此队列，如有必要则等待另一个线程接收它。
 int remainingCapacity()
          始终返回 0。
 boolean remove(Object o)
          始终返回 false。
 boolean removeAll(Collection<?> c)
          始终返回 false。
 boolean retainAll(Collection<?> c)
          始终返回 false。
 int size()
          始终返回 0。
 E take()
          检索并移除此队列的头，如有必要则等待另一个线程插入它。
 Object[] toArray()
          返回一个 0 长度的数组。
<T> T[]
toArray(T[] a)
          将指定数组的第 0 个元素设置为 null（如果该数组有非 0 的长度）并返回它。
 
从类 java.util.AbstractQueue 继承的方法
add, addAll, element, remove
 
从类 java.util.AbstractCollection 继承的方法
toString
 
从类 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, equals, hashCode
 

构造方法详细信息

SynchronousQueue

public SynchronousQueue()
创建一个具有非公平访问策略的 SynchronousQueue。

SynchronousQueue

public SynchronousQueue(boolean fair)
创建一个具有指定公平策略的 SynchronousQueue。

参数：
fair - 如果为 true，则线程以 FIFO 的顺序竞争访问；否则顺序是未指定的。
方法详细信息

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 - 一个 TimeUnit，确定如何解释 timeout 参数。
返回：
如果成功，则返回 true，如果使用者出现前已超出指定的等待时间，则返回 false。
抛出：
InterruptedException - 如果等待时发生中断。
NullPointerException - 如果指定的元素为 null。

take

public E take()
       throws InterruptedException
检索并移除此队列的头，如有必要则等待另一个线程插入它。

指定者：
接口 BlockingQueue<E> 中的 take
返回：
队列的头。
抛出：
InterruptedException - 如果等待时发生中断。

poll

public E poll(long timeout,
              TimeUnit unit)
       throws InterruptedException
检索并移除此队列的头，如有必要则等待指定的时间，以便另一个线程插入它。

指定者：
接口 BlockingQueue<E> 中的 poll
参数：
timeout - 放弃前等待多长时间，以 unit 为时间单位。
unit - 一个 TimeUnit，确定如何解释 timeout 参数。
返回：
队列的头，如果该元素出现前已超出指定的等待时间，则返回 null。
抛出：
InterruptedException - 如果等待时发生中断。

offer

public boolean offer(E o)
如果另一个线程正在等待接收指定的元素，则将其插入此队列。

指定者：
接口 BlockingQueue<E> 中的 offer
指定者：
接口 Queue<E> 中的 offer
参数：
o - 要添加的元素。
返回：
如果可以将该元素插入此队列，则返回 true；否则返回 false。
抛出：
NullPointerException - 如果指定的元素为 null。

poll

public E poll()
如果另一个线程当前正要使用某个元素，则检索并移除此队列的头。

指定者：
接口 Queue<E> 中的 poll
返回：
队列的头，如果没有元素可用，则返回 null。

isEmpty

public boolean isEmpty()
始终返回 true。SynchronousQueue 没有内部容量。

指定者：
接口 Collection<E> 中的 isEmpty
覆盖：
类 AbstractCollection<E> 中的 isEmpty
返回：
true

size

public int size()
始终返回 0。SynchronousQueue 没有内部容量。

指定者：
接口 Collection<E> 中的 size
指定者：
类 AbstractCollection<E> 中的 size
返回：
0。

remainingCapacity

public int remainingCapacity()
始终返回 0。SynchronousQueue 没有内部容量。

指定者：
接口 BlockingQueue<E> 中的 remainingCapacity
返回：
0。

clear

public void clear()
不执行任何操作。SynchronousQueue 没有内部容量。

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

contains

public boolean contains(Object o)
始终返回 false。SynchronousQueue 没有内部容量。

指定者：
接口 Collection<E> 中的 contains
覆盖：
类 AbstractCollection<E> 中的 contains
参数：
o - 元素
返回：
false

remove

public boolean remove(Object o)
始终返回 false。SynchronousQueue 没有内部容量。

指定者：
接口 Collection<E> 中的 remove
覆盖：
类 AbstractCollection<E> 中的 remove
参数：
o - 要移除的元素
返回：
false

containsAll

public boolean containsAll(Collection<?> c)
除非给定集合为空，否则返回 false。SynchronousQueue 没有内部容量。

指定者：
接口 Collection<E> 中的 containsAll
覆盖：
类 AbstractCollection<E> 中的 containsAll
参数：
c - 集合
返回：
除非给定集合为空，否则返回 false
另请参见：
AbstractCollection.contains(Object)

removeAll

public boolean removeAll(Collection<?> c)
始终返回 false。SynchronousQueue 没有内部容量。

指定者：
接口 Collection<E> 中的 removeAll
覆盖：
类 AbstractCollection<E> 中的 removeAll
参数：
c - 集合
返回：
false
另请参见：
AbstractCollection.remove(Object), AbstractCollection.contains(Object)

retainAll

public boolean retainAll(Collection<?> c)
始终返回 false。SynchronousQueue 没有内部容量。

指定者：
接口 Collection<E> 中的 retainAll
覆盖：
类 AbstractCollection<E> 中的 retainAll
参数：
c - 集合
返回：
false
另请参见：
AbstractCollection.remove(Object), AbstractCollection.contains(Object)

peek

public E peek()
始终返回 null。除非 SynchronousQueue 正在等待，否则不返回元素。

指定者：
接口 Queue<E> 中的 peek
返回：
null

iterator

public Iterator<E> iterator()
返回一个空迭代器，其中 hasNext 始终返回 false。

指定者：
接口 Iterable<E> 中的 iterator
指定者：
接口 Collection<E> 中的 iterator
指定者：
类 AbstractCollection<E> 中的 iterator
返回：
空迭代器

toArray

public Object[] toArray()
返回一个 0 长度的数组。

指定者：
接口 Collection<E> 中的 toArray
覆盖：
类 AbstractCollection<E> 中的 toArray
返回：
一个 0 长度的数组

toArray

public <T> T[] toArray(T[] a)
将指定数组的第 0 个元素设置为 null（如果该数组有非 0 的长度）并返回它。

指定者：
接口 Collection<E> 中的 toArray
覆盖：
类 AbstractCollection<E> 中的 toArray
参数：
a - 数组
返回：
指定的数组

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 - 传输元素的最大数量
返回：
传输元素的数量。
概述  软件包   类  使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 5.0
 上一个类   下一个类 框架    无框架    
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

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