Module java.base

软件包 java.util.concurrent

Class LinkedTransferQueue<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractQueue<E>

java.util.concurrent.LinkedTransferQueue<E>

参数类型

E - 保存在此队列中的元素的类型

All Implemented Interfaces:

Serializable ， Iterable<E> ， Collection<E> ， BlockingQueue<E> ， TransferQueue<E> ， Queue<E>

public class LinkedTransferQueue<E>
extends AbstractQueue<E>
implements TransferQueue<E>, Serializable

基于链接节点的无界TransferQueue 。 这个队列相对于任何给定的生产者订购元素FIFO（先进先出）。 队列的头部是那些已经排队的元素是一些生产者的最长时间。 队列的尾部是那些已经在队列上的元素是一些生产者的最短时间。

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

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

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

内存一致性效果：与其他并发集合一样，在将对象放入LinkedTransferQueue happen-before之后的线程中的操作，随后从另一个线程中的LinkedTransferQueue访问或删除该元素。

这个类是Java Collections Framework的成员。

从以下版本开始：

1.7

另请参见：

Serialized Form

构造方法摘要

构造方法

Constructor	描述
LinkedTransferQueue()	创建一个最初的空 LinkedTransferQueue 。
LinkedTransferQueue(Collection<? extends E> c)	创建一个 LinkedTransferQueue最初包含给定集合的元素，以集合的迭代器的遍历顺序添加。

方法摘要

Modifier and Type	方法	描述
boolean	add(E e)	在该队列的尾部插入指定的元素。
void	clear()	从此队列中删除所有元素。
boolean	contains(Object o)	如果此队列包含指定的元素，则返回 true 。
int	drainTo(Collection<? super E> c)	从该队列中删除所有可用的元素，并将它们添加到给定的集合中。
int	drainTo(Collection<? super E> c, int maxElements)	最多从该队列中删除给定数量的可用元素，并将它们添加到给定的集合中。
void	forEach(Consumer<? super E> action)	对 Iterable每个元素执行给定的操作，直到所有元素都被处理或者动作引发异常。
int	getWaitingConsumerCount()	通过 BlockingQueue.take()或定时 poll返回等待接收元素的消费者数量的估计。
boolean	hasWaitingConsumer()	返回 true ，如果有至少一个消费者等待经由以接收元件 BlockingQueue.take()或定时 poll 。
boolean	isEmpty()	如果此队列不包含元素，则返回 true 。
Iterator<E>	iterator()	以正确的顺序返回该队列中的元素的迭代器。
boolean	offer(E e)	在该队列的尾部插入指定的元素。
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()	始终返回 Integer.MAX_VALUE因为 LinkedTransferQueue不受容量限制。
boolean	remove(Object o)	从该队列中删除指定元素的单个实例（如果存在）。
boolean	removeAll(Collection<?> c)	删除指定集合中包含的所有此集合的元素（可选操作）。
boolean	removeIf(Predicate<? super E> filter)	删除满足给定谓词的此集合的所有元素。
boolean	retainAll(Collection<?> c)	仅保留此集合中包含在指定集合中的元素（可选操作）。
int	size()	返回此队列中的元素数。
Spliterator<E>	spliterator()	返回此队列中的元素Spliterator 。
E	take()	检索并删除此队列的头，如有必要，等待元素可用。
Object[]	toArray()	以适当的顺序返回一个包含此队列中所有元素的数组。
<T> T[]	toArray(T[] a)	以适当的顺序返回包含此队列中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
String	toString()	返回此集合的字符串表示形式。
void	transfer(E e)	将元素转移给消费者，如有必要，等待。
boolean	tryTransfer(E e)	如果可能的话，将元件立即转移给等待的消费者。
boolean	tryTransfer(E e, long timeout, TimeUnit unit)	如果可以在超时过程之前将元素传送给消费者。

Methods inherited from class java.util.AbstractCollection

containsAll

Methods inherited from class java.util.AbstractQueue

addAll, element, remove

Methods inherited from interface java.util.Collection

addAll, containsAll, equals, hashCode, parallelStream, stream

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

构造方法详细信息

LinkedTransferQueue

public LinkedTransferQueue()

创建一个最初的空 LinkedTransferQueue 。

LinkedTransferQueue

public LinkedTransferQueue(Collection<? extends E> c)

创建一个 LinkedTransferQueue最初包含给定集合的元素，以集合的迭代器的遍历顺序添加。

参数

c - 最初包含的元素的集合

异常

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

方法详细信息

toString

public String toString()

描述从类别复制： AbstractCollection

返回此集合的字符串表示形式。 字符串表示由集合的元素的列表按照它们的迭代器返回的顺序包含在方括号（ "[]" ）中。 相邻元素由字符", " （逗号和空格）分隔。 元素将转换为字符串，如String.valueOf(Object) 。

重写：

toString在 AbstractCollection<E>

结果

此集合的字符串表示形式

toArray

public Object[] toArray()

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

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

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

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 - 如果指定的数组为空

spliterator

public Spliterator<E> spliterator()

返回此队列中的元素Spliterator 。

返回的分配器是weakly consistent 。

该Spliterator报告Spliterator.CONCURRENT ， Spliterator.ORDERED ，并Spliterator.NONNULL 。

Specified by:

spliterator在接口 Collection<E>

Specified by:

spliterator在接口 Iterable<E>

Implementation Note:

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

结果

一个 Spliterator在这个队列中的元素

从以下版本开始：

1.8

put

public void put(E e)

在该队列的尾部插入指定的元素。 由于队列无限制，此方法将永远不会阻止。

Specified by:

put在接口 BlockingQueue<E>

参数

e - 要添加的元素

异常

NullPointerException - 如果指定的元素为空

offer

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

在该队列的尾部插入指定的元素。 由于队列无限制，此方法将永远不会阻止或返回false 。

Specified by:

offer在接口 BlockingQueue<E>

参数

e - 要添加的元素

timeout - 放弃之前等待多长时间，以 unit为单位

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

结果

true （由 BlockingQueue.offer指定）

异常

NullPointerException - 如果指定的元素为空

offer

public boolean offer(E e)

在该队列的尾部插入指定的元素。 队列无限制时，此方法永远不会返回false 。

Specified by:

offer在接口 BlockingQueue<E>

Specified by:

offer在接口 Queue<E>

参数

e - 要添加的元素

结果

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

异常

NullPointerException - 如果指定的元素为空

add

public boolean add(E e)

在该队列的尾部插入指定的元素。 由于队列无限制，此方法将永远不会抛出IllegalStateException或返回false 。

Specified by:

add接口 BlockingQueue<E>

Specified by:

add在接口 Collection<E>

Specified by:

add在接口 Queue<E>

重写：

add在 AbstractQueue<E>

参数

e - 要添加的元素

结果

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

异常

NullPointerException - 如果指定的元素为空

tryTransfer

public boolean tryTransfer(E e)

如果可能的话，将元件立即转移给等待的消费者。

更准确地说，如果存在已经等待接收消费者的消费者（ take()或定时poll ），则立即转移指定的元素，否则返回false而不对该元素进行排队。

Specified by:

tryTransfer在接口 TransferQueue<E>

参数

e - 要传输的元素

结果

true如果元素被转移，否则为 false

异常

NullPointerException - 如果指定的元素为空

transfer

public void transfer(E e)
              throws InterruptedException

将元素转移给消费者，如有必要，等待。

更准确地说，如果存在已经等待接收消费者的消费者（ take()或定时poll ），则立即传输指定的元素，否则将指定的元素插入到该队列的尾部，并等待消费者收到该元素。

Specified by:

transfer在接口 TransferQueue<E>

参数

e - 要传输的元素

异常

NullPointerException - 如果指定的元素为空

InterruptedException - 如果在等待时中断，在这种情况下元素不会被排入队列

tryTransfer

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

如果可以在超时过程之前将元素传送给消费者。

更确切地说，如果存在已经等待接收消费者的消费者（ take()或定时poll ）， 则会立即转移指定的元素，否则在该队列的尾部插入指定的元素，并等待消费者收到该元素，返回false如果在元素可以传输之前经过了指定的等待时间。

Specified by:

tryTransfer在接口 TransferQueue<E>

参数

e - 要传输的元素

timeout - 放弃之前等待多久，以 unit为单位

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

结果

true如果成功，或 false如果在完成之前经过了指定的等待时间，在这种情况下，元素不会排入队列

异常

NullPointerException - 如果指定的元素为空

InterruptedException - 如果在等待时中断，在这种情况下元素不会被排入队列

take

public E take()
       throws InterruptedException

说明从界面BlockingQueue复制

检索并删除此队列的头，如有必要，等待元素可用。

Specified by:

take在接口 BlockingQueue<E>

结果

这个队列的头

异常

InterruptedException - 如果中断等待

poll

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

说明从界面BlockingQueue复制

检索并删除此队列的头，等待指定的等待时间（如有必要）使元素变为可用。

Specified by:

poll在接口 BlockingQueue<E>

参数

timeout - 放弃之前等待多久，以 unit为单位

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

结果

该队列的头部，如果在元素可用之前经过了指定的等待时间， null

异常

InterruptedException - 如果在等待时中断

poll

public E poll()

描述从接口Queue复制

检索并删除此队列的头部，如果此队列为空，则返回 null 。

Specified by:

poll在接口 Queue<E>

结果

这个队列的头，或 null如果这个队列是空的

drainTo

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

描述从接口BlockingQueue复制

从该队列中删除所有可用的元素，并将它们添加到给定的集合中。 此操作可能比重复轮询此队列更有效。 尝试向集合c添加元素时遇到的故障可能导致在抛出关联的异常时，元素既不在两个集合中，也可能不是两个集合。 尝试将排队排队自身会导致IllegalArgumentException 。 此外，如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。

Specified by:

drainTo在接口 BlockingQueue<E>

参数

c - 传输元素的集合

结果

转移的元素数量

异常

NullPointerException - 如果指定的集合为空

IllegalArgumentException - 如果指定的集合是此队列，或该队列的某个元素的某些属性阻止将其添加到指定的集合

drainTo

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

描述从接口BlockingQueue复制

最多从该队列中删除给定数量的可用元素，并将它们添加到给定的集合中。 尝试向集合c添加元素时遇到的失败可能导致在抛出关联的异常时，元素既不在两个集合中，也可能不是两个集合。 尝试将排队排队自身会导致IllegalArgumentException 。 此外，如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。

Specified by:

drainTo在接口 BlockingQueue<E>

参数

c - 将元素传输到的集合

maxElements - 要传输的元素的最大数量

结果

转移的元素数量

异常

NullPointerException - 如果指定的集合为空

IllegalArgumentException - 如果指定的集合是此队列，或此队列的某个元素的某些属性会阻止将其添加到指定的集合

iterator

public Iterator<E> iterator()

以正确的顺序返回该队列中的元素的迭代器。 元素将按照从头（头）到最后（尾）的顺序返回。

返回的迭代器是weakly consistent 。

Specified by:

iterator在接口 Collection<E>

Specified by:

iterator在接口 Iterable<E>

Specified by:

iterator在 AbstractCollection<E>

结果

在该队列中的元素以适当的顺序迭代

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如果此队列不包含元素

hasWaitingConsumer

public boolean hasWaitingConsumer()

描述从接口TransferQueue复制

返回true ，如果有至少一个消费者等待经由以接收元件BlockingQueue.take()或定时poll 。 返回值代表一时的状态。

Specified by:

hasWaitingConsumer在接口 TransferQueue<E>

结果

true如果至少有一个等待消费者

size

public int size()

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

请注意，与大多数集合不同，此方法不是一个常时操作。 由于这些队列的异步性质，确定当前的元素数需要O（n）遍历。

Specified by:

size在接口 Collection<E>

Specified by:

size在 AbstractCollection<E>

结果

此队列中的元素数

getWaitingConsumerCount

public int getWaitingConsumerCount()

描述从接口TransferQueue复制

通过BlockingQueue.take()或定时poll返回等待接收元素的消费者数量的估计。 返回值是一个近似的瞬间状态，如果消费者已经完成或放弃等待，这可能是不准确的。 该值可能对监控和启发式有用，但不适用于同步控制。 这种方法的实施可能比TransferQueue.hasWaitingConsumer()明显慢。

Specified by:

getWaitingConsumerCount在接口 TransferQueue<E>

结果

消费者等待接收元素的数量

remove

public boolean remove(Object o)

从该队列中删除指定元素的单个实例（如果存在）。 更正式地，删除元素e使得o.equals(e) ，如果该队列包含一个或多个这样的元素。 如果此队列包含指定的元素（或等效地，如果此队列作为调用的结果而更改），则返回true 。

Specified by:

remove在接口 BlockingQueue<E>

Specified by:

remove在接口 Collection<E>

重写：

remove在 AbstractCollection<E>

参数

o - 要从此队列中删除的元素（如果存在）

结果

true如果此队列由于调用而更改

contains

public boolean contains(Object o)

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

Specified by:

contains在接口 BlockingQueue<E>

Specified by:

contains在接口 Collection<E>

重写：

contains在 AbstractCollection<E>

参数

o - 要检查此队列中的遏制的对象

结果

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

remainingCapacity

public int remainingCapacity()

始终返回 Integer.MAX_VALUE因为 LinkedTransferQueue不受容量限制。

Specified by:

remainingCapacity在接口 BlockingQueue<E>

结果

Integer.MAX_VALUE （由 BlockingQueue.remainingCapacity指定）

removeIf

public boolean removeIf(Predicate<? super E> filter)

描述从接口Collection复制

删除满足给定谓词的此集合的所有元素。 在迭代或谓词中抛出的错误或运行时异常被转发给调用者。

Specified by:

removeIf在接口 Collection<E>

参数

filter - 要删除的元素返回 true的谓词

结果

true如果有任何元素被删除

异常

NullPointerException - 如果指定的过滤器为空

removeAll

public boolean removeAll(Collection<?> c)

说明从类别复制： AbstractCollection

删除指定集合中包含的所有此集合的元素（可选操作）。 此调用返回后，此集合将不包含与指定集合相同的元素。

Specified by:

removeAll在接口 Collection<E>

重写：

removeAll在 AbstractCollection<E>

参数

c - 包含要从此集合中删除的元素的集合

结果

true如果这个集合由于调用而改变了

异常

NullPointerException - 如果此集合包含一个或多个空元素，并且指定的集合不支持空元素（ optional ），或者如果指定的集合为空

另请参见：

AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)

retainAll

public boolean retainAll(Collection<?> c)

说明从类别复制AbstractCollection

仅保留此集合中包含在指定集合中的元素（可选操作）。 换句话说，从该集合中删除所有不包含在指定集合中的元素。

Specified by:

retainAll在接口 Collection<E>

重写：

retainAll在 AbstractCollection<E>

参数

c - 包含要保留在此集合中的元素的集合

结果

true如果该收集因呼叫而更改

异常

NullPointerException - 如果此集合包含一个或多个空元素，并且指定的集合不允许空元素（ optional ），或者如果指定的集合为空

另请参见：

AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)

clear

public void clear()

描述从类别复制： AbstractQueue

从此队列中删除所有元素。 此呼叫返回后队列将为空。

这个实现反复调用poll，直到它返回null 。

Specified by:

clear在接口 Collection<E>

重写：

clear在 AbstractQueue<E>

forEach

public void forEach(Consumer<? super E> action)

描述从接口Iterable复制

对Iterable每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。 如果指定了该顺序，则按迭代的顺序执行操作。 动作抛出的异常被转发给呼叫者。

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

Specified by:

forEach在接口 Iterable<E>

参数

action - 要对每个元素执行的操作

异常

NullPointerException - 如果指定的动作为空