compact1, compact2, compact3

java.util.concurrent

Class LinkedBlockingQueue<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractQueue<E>

java.util.concurrent.LinkedBlockingQueue<E>

参数类型

E -元素举行此集合中的类型

All Implemented Interfaces:

Serializable， Iterable ， Collection ， BlockingQueue ， Queue

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

一个可选择的有界 blocking queue基于链接节点。这个队列的命令元素的FIFO（先进先出）。队列的头是已在队列中的元素，是最长的时间。队列的尾部是已在队列中的元素最短的时间。新的元素插入在队列的尾部，并在队列的头部获取元素的队列检索操作。链接的队列通常有更高的吞吐量比基于阵列的队列，但在大多数并发应用程序的可预测的性能。

可选的容量绑定构造函数的参数作为一种方法，以防止过度的队列扩展。的能力，如果没有指定，等于Integer.MAX_VALUE。链接的节点是动态创建的，除非这会带来容量的队列，否则每个插入都会被动态创建的链接。

这个类和它的迭代器实现所有的可选方法的Collection和Iterator接口。

这个班的一员 Java Collections Framework。

从以下版本开始：

一点五

另请参见：

Serialized Form

构造方法摘要

构造方法

Constructor and Description
LinkedBlockingQueue() 创建一个容量 Integer.MAX_VALUE LinkedBlockingQueue。
LinkedBlockingQueue(Collection<? extends E> c) 创建一个容量 Integer.MAX_VALUE LinkedBlockingQueue，最初包含元素的集合，加入集合的迭代器遍历顺序。
LinkedBlockingQueue(int capacity) 创建一个 LinkedBlockingQueue与给定的（固定的）能力。

方法摘要

Modifier and Type	Method and Description
void	clear() 自动删除所有的从这个队列元素。
boolean	contains(Object o) 返回 true如果此队列包含指定的元素。
int	drainTo(Collection<? super E> c) 从这个队列中删除所有可用的元素，并将它们添加到给定的集合中。
int	drainTo(Collection<? super E> c, int maxElements) 从这个队列中移除给定数量的可用元素，并将它们添加到给定的集合中。
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() 返回此队列中的元素的数目。
Spliterator<E>	spliterator() 返回队列中的元素在这一 Spliterator。
E	take() 检索并移除此队列的头，在必要时等待，直到一个元素可用。
Object[]	toArray() 返回一个数组，包含这个队列中的所有元素，在适当的顺序。
<T> T[]	toArray(T[] a) 返回一个包含此队列中所有元素的数组，在适当的顺序；返回的数组的运行时类型是指定的数组的运行时类型。
String	toString() 返回此集合的字符串表示形式。

Methods inherited from class java.util.AbstractQueue

add, addAll, element, remove

Methods inherited from class java.util.AbstractCollection

containsAll, isEmpty, removeAll, retainAll

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.concurrent.BlockingQueue

add

Methods inherited from interface java.util.Queue

element, remove

Methods inherited from interface java.util.Collection

addAll, containsAll, equals, hashCode, isEmpty, parallelStream, removeAll, removeIf, retainAll, stream

Methods inherited from interface java.lang.Iterable

forEach

Constructor Detail

LinkedBlockingQueue

public LinkedBlockingQueue()

创建一个容量 Integer.MAX_VALUE LinkedBlockingQueue。

LinkedBlockingQueue

public LinkedBlockingQueue(int capacity)

创建一个与给定的 LinkedBlockingQueue（固定的）能力。

参数

capacity -这个队列容量

异常

IllegalArgumentException -如果 capacity不大于零

LinkedBlockingQueue

public LinkedBlockingQueue(Collection<? extends E> c)

创建一个容量 Integer.MAX_VALUE LinkedBlockingQueue，最初包含元素的集合，加入集合的迭代器遍历顺序。

参数

c -最初包含元素的集合

异常

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

方法详细信息

size

public int size()

返回此队列中的元素的数目。

Specified by:

size 接口 Collection<E>

Specified by:

size 方法重写，继承类 AbstractCollection<E>

结果

这个队列中的元素的数目

remainingCapacity

public int remainingCapacity()

返回这个队列可以理想地（在内存或资源约束的情况下）接受不阻塞的额外元素的数量。这是始终等于初始容量的排队少这个队列的当前 size。

注意，你不能总是告诉如果试图插入一个元素将通过检查remainingCapacity成功因为它可能的情况是，另一个线程要插入或删除一个元素。

Specified by:

remainingCapacity 接口 BlockingQueue<E>

结果

剩余容量

put

public void put(E e)
         throws InterruptedException

在这个队列的尾部插入指定的元素，在必要时等待空间可用。

Specified by:

put 接口 BlockingQueue<E>

参数

e -元素添加

异常

InterruptedException如果中断等待

NullPointerException -如果指定元素为null

offer

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

在这个队列的尾部插入指定的元素，在必要时等待空间到指定的等待时间，以获得可用的空间。

Specified by:

offer 接口 BlockingQueue<E>

参数

e -元素添加

timeout -多久才放弃等待，在单位 unit

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

结果

true如果成功，或 false如果指定的等待时间过去之前可用空间

异常

InterruptedException如果中断等待

NullPointerException -如果指定元素为null

offer

public boolean offer(E e)

插入指定元素在这个队列的尾部是否有可能立即这样做不超过容量，还 true在成功和 false如果队列满。使用容量限制队列时，这种方法是最好的方法 add，可不能只通过抛出异常，插入一个元素。

Specified by:

offer 接口 BlockingQueue<E>

Specified by:

offer 接口 Queue<E>

参数

e -元素添加

结果

true如果元素被添加到这个队列，否则 false

异常

NullPointerException -如果指定元素为null

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 - TimeUnit确定如何解释 timeout参数

结果

这个队列头，或 null如果指定的等待时间过去之前一个元素是可用的

异常

InterruptedException如果中断等待

poll

public E poll()

从接口复制的描述： Queue

检索并移除此队列的头，或返回 null如果队列为空。

Specified by:

poll 接口 Queue<E>

结果

这个队列头，或 null如果队列为空

peek

public E peek()

从接口复制的描述： Queue

检索，但不删除，这个队列头，或返回 null如果队列为空。

Specified by:

peek 接口 Queue<E>

结果

这个队列头，或 null如果队列为空

remove

public boolean remove(Object o)

从该队列中移除指定元素的一个实例，如果它是存在的。更正式地说，删除一个元素 e这样 o.equals(e)，如果此队列包含一个或多个这样的元素。返回 true如果此队列包含指定元素（或等价地，如果调用的结果这个队列改变）。

Specified by:

remove 接口 Collection<E>

Specified by:

remove 接口 BlockingQueue<E>

重写：

remove 方法重写，继承类 AbstractCollection<E>

参数

o元素被从队列中删除，如果存在

结果

true如果调用的结果改变了这个队列

contains

public boolean contains(Object o)

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

Specified by:

contains 接口 Collection<E>

Specified by:

contains 接口 BlockingQueue<E>

重写：

contains 方法重写，继承类 AbstractCollection<E>

参数

o对象需要检查该队列中的遏制

结果

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

toArray

public Object[] toArray()

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

返回的数组将是“安全”的，在这个队列中没有引用它的引用。（换句话说，这种方法必须分配一个新的数组）。因此，调用方可以自由修改返回的数组。

此方法作为基于数组和基于集合的原料药之间的桥梁。

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

toString

public String toString()

从阶级复制的描述： AbstractCollection

返回此集合的字符串表示形式。的字符串表示形式由一列它们的迭代器返回的顺序集合的元素，在方括号内（ "[]"）。相邻的元素是由人物 ", "隔开（逗号和空格）。元素转换为字符串的 String.valueOf(Object)。

重写：

toString 方法重写，继承类 AbstractCollection<E>

结果

此集合的字符串表示

clear

public void clear()

自动删除所有的从这个队列元素。此调用返回后队列将是空的。

Specified by:

clear 接口 Collection<E>

重写：

clear 方法重写，继承类 AbstractQueue<E>

drainTo

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

从接口复制的描述： BlockingQueue

从这个队列中删除所有可用的元素，并将它们添加到给定的集合中。此操作可能比重复轮询此队列更有效。一个在试图收集 c添加元素可能会导致元素在没有遭遇过失败，或集合时相关的异常被抛出。试图排队列本身造成 IllegalArgumentException。此外，当操作正在进行中时，此操作的行为是不确定的，如果指定的集合被修改了。

Specified by:

drainTo 接口 BlockingQueue<E>

参数

c -收集传递元素

结果

传输的元素数

异常

UnsupportedOperationException如果添加元素不按指定集合的支持

ClassCastException -如果该队列的元素类型阻止其加入指定集合

NullPointerException -如果指定集合为空

IllegalArgumentException -如果指定集合的队列，该队列或一个元素的一些特性可以防止它被添加到指定的集合

drainTo

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

从接口复制的描述： BlockingQueue

从这个队列中移除给定数量的可用元素，并将它们添加到给定的集合中。一个在试图收集 c添加元素可能会导致元素在没有遭遇过失败，或集合时相关的异常被抛出。试图排队列本身造成 IllegalArgumentException。此外，如果指定的收集是在操作进行修改此操作的行为是未定义的。

Specified by:

drainTo 接口 BlockingQueue<E>

参数

c -收集传递元素

maxElements -元素的最大数量的转移

结果

传输的元素数

异常

UnsupportedOperationException如果添加元素不按指定集合的支持

ClassCastException -如果该队列的元素类型阻止其加入指定集合

NullPointerException -如果指定集合为空

IllegalArgumentException -如果指定集合的队列，该队列或一个元素的一些特性可以防止它被添加到指定的集合

iterator

public Iterator<E> iterator()

在这个队列中的元素上返回一个正确的顺序。元素将从第一（头）返回到最后（尾）。

返回的迭代器是weakly consistent。

Specified by:

iterator 接口 Iterable<E>

Specified by:

iterator 接口 Collection<E>

Specified by:

iterator 方法重写，继承类 AbstractCollection<E>

结果

在这个队列中的元素的迭代器在适当的顺序

spliterator

public Spliterator<E> spliterator()

返回队列中的元素在这一 Spliterator。

返回的spliterator是weakly consistent。

报告的Spliterator Spliterator.CONCURRENT，Spliterator.ORDERED，和Spliterator.NONNULL。

Specified by:

spliterator 接口 Iterable<E>

Specified by:

spliterator 接口 Collection<E>

Implementation Note:

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

结果

在该队列中的元素的 Spliterator

从以下版本开始：

一点八