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

另请参见：

Serialized Form

构造方法摘要

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

方法摘要

所有方法实例方法具体的方法
变量和类型	方法	描述
`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`每个元素执行给定操作，直到处理 `Iterable`所有元素或操作引发异常。
`Iterator<E>`	`iterator()`	以适当的顺序返回此队列中元素的迭代器。
`boolean`	`offer(E e)`	插入指定的元素在这个队列的尾部，如果有可能立即这样做不超过该队列的容量，返回 `true`在成功和 `false`如果此队列已满。
`boolean`	`offer(E e, long timeout, TimeUnit unit)`	在指定的元素尾部插入指定的元素，必要时等待指定的等待时间以使空间可用。
`void`	`put(E e)`	将指定的元素插入此队列的尾部，等待空间变为可用。
`int`	`remainingCapacity()`	返回理想情况下（在没有内存或资源约束的情况下）此队列可以无阻塞地接受的其他元素的数量。
`boolean`	`remove(Object o)`	从此队列中删除指定元素的单个实例（如果存在）。
`boolean`	`removeAll(Collection<?> c)`	删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。
`boolean`	`removeIf(Predicate<? super E> filter)`	删除此集合中满足给定谓词的所有元素。
`boolean`	`retainAll(Collection<?> c)`	仅保留此集合中包含在指定集合中的元素（可选操作）。
`int`	`size()`	返回此队列中的元素数。
`Spliterator<E>`	`spliterator()`	在此队列中的元素上返回`Spliterator` 。
`Object[]`	`toArray()`	以适当的顺序返回包含此队列中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`	以适当的顺序返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。

声明方法的类 java.util.AbstractQueue
add, addAll, element, remove

声明方法的类 java.util.AbstractCollection
containsAll, isEmpty, toString

声明方法的类 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

声明方法的接口 java.util.concurrent.BlockingQueue
add, poll, take

声明方法的接口 java.util.Collection
addAll, containsAll, equals, hashCode, isEmpty, parallelStream, stream, toArray

声明方法的接口 java.util.Queue
element, peek, poll, remove

- 构造方法详细信息
  - LinkedBlockingQueue
```
public LinkedBlockingQueue()
```
    创建 LinkedBlockingQueue ，容量为 Integer.MAX_VALUE 。
  - LinkedBlockingQueue
```
public LinkedBlockingQueue(int capacity)
```
    创建具有给定（固定）容量的 LinkedBlockingQueue 。
    
    参数
    
    capacity - 此队列的容量
    
    异常
    
    IllegalArgumentException - 如果 capacity不大于零
  - LinkedBlockingQueue
```
public LinkedBlockingQueue(Collection<? extends E> c)
```
    创建 LinkedBlockingQueue容量为 Integer.MAX_VALUE ，最初包含给定集合中的元素，添加在收集迭代器的遍历顺序。
    
    参数
    
    c - 最初包含的元素集合
    
    异常
    
    NullPointerException - 如果指定的集合或其任何元素为null
- 方法详细信息
  - size
```
public int size()
```
    返回此队列中的元素数。
    
    Specified by:
    
    size在界面 Collection<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
  - 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如果此队列包含指定的元素
  - toArray
```
public Object[] toArray()
```
    以适当的顺序返回包含此队列中所有元素的数组。
    返回的数组将是“安全的”，因为此队列不会保留对它的引用。（换句话说，此方法必须分配一个新数组）。因此调用者可以自由修改返回的数组。
    
    此方法充当基于阵列和基于集合的API之间的桥梁。
    
    Specified by:
    
    toArray in interface Collection<E>
    
    重写：
    
    toArray类 AbstractCollection<E>
    
    结果
    
    包含此队列中所有元素的数组
  - toArray
```
public <T> T[] toArray(T[] a)
```
    以适当的顺序返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。如果队列适合指定的数组，则返回其中。否则，将使用指定数组的运行时类型和此队列的大小分配新数组。
    如果此队列适合指定的数组且有空间（即，数组的元素多于此队列），则紧跟在队列末尾的数组中的元素将设置为null 。
    
    与toArray()方法一样，此方法充当基于数组的API和基于集合的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 - 如果指定的数组为null
  - clear
```
public void clear()
```
    以原子方式删除此队列中的所有元素。此调用返回后，队列将为空。
    
    Specified by:
    
    clear in interface 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 - 如果指定的集合为null
    
    IllegalArgumentException - 如果指定的集合是此队列，或此队列的某个元素的某些属性阻止将其添加到指定的集合
  - drainTo
```
public int drainTo(Collection<? super E> c,
                   int maxElements)
```
    从界面复制的说明： BlockingQueue
    
    从该队列中删除最多给定数量的可用元素，并将它们添加到给定集合中。尝试将元素添加到集合c遇到的故障可能导致在抛出关联的异常时元素既不在集合中，也不在集合中。尝试将队列排入自身会导致IllegalArgumentException 。此外，如果在操作正在进行时修改了指定的集合，则此操作的行为是不确定的。
    
    Specified by:
    
    drainTo in interface BlockingQueue<E>
    
    参数
    
    c - 将元素转换为的集合
    
    maxElements - 要传输的最大元素数
    
    结果
    
    转移的元素数量
    
    异常
    
    UnsupportedOperationException - 如果指定集合不支持添加元素
    
    ClassCastException - 如果此队列的元素的类阻止将其添加到指定的集合中
    
    NullPointerException - 如果指定的集合为null
    
    IllegalArgumentException - 如果指定的集合是此队列，或者此队列的某个元素的某些属性阻止将其添加到指定的集合
  - iterator
```
public Iterator<E> iterator()
```
    以适当的顺序返回此队列中元素的迭代器。元素将从第一个（头部）到最后一个（尾部）按顺序返回。
    返回的迭代器是weakly consistent 。
    
    Specified by:
    
    iterator在界面 Collection<E>
    
    Specified by:
    
    iterator在界面 Iterable<E>
    
    Specified by:
    
    iterator在类 AbstractCollection<E>
    
    结果
    
    以适当的顺序在此队列中的元素上的迭代器
  - spliterator
```
public Spliterator<E> spliterator()
```
    在此队列中的元素上返回Spliterator 。
    返回的分裂器是weakly consistent 。
    
    该Spliterator报告Spliterator.CONCURRENT ， Spliterator.ORDERED和Spliterator.NONNULL 。
    
    Specified by:
    
    spliterator in interface Collection<E>
    
    Specified by:
    
    spliterator在界面 Iterable<E>
    
    Implementation Note:
    
    Spliterator实现了 trySplit以允许有限的并行性。
    
    结果
    
    对此队列中的元素进行 Spliterator
    
    从以下版本开始：
    
    1.8
  - forEach
```
public void forEach(Consumer<? super E> action)
```
    从界面复制的说明： Iterable
    
    对Iterable每个元素执行给定操作，直到处理Iterable所有元素或操作引发异常。如果指定了该顺序，则按迭代顺序执行操作。操作抛出的异常将转发给调用者。
    如果操作执行修改元素的基础源的副作用，则此方法的行为未指定，除非重写类已指定并发修改策略。
    
    Specified by:
    
    forEach在界面 Iterable<E>
    
    参数
    
    action - 要为每个元素执行的操作
    
    异常
    
    NullPointerException - 如果指定的操作为null
  - removeIf
```
public boolean removeIf(Predicate<? super E> filter)
```
    从界面复制的说明： Collection
    
    删除此集合中满足给定谓词的所有元素。在迭代期间或通过谓词抛出的错误或运行时异常被中继到调用者。
    
    Specified by:
    
    removeIf在界面 Collection<E>
    
    参数
    
    filter - 一个谓词，它返回 true表示要删除的元素
    
    结果
    
    true是否删除了任何元素
    
    异常
    
    NullPointerException - 如果指定的过滤器为null
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    复制自类的说明： AbstractCollection
    
    删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。此调用返回后，此集合将不包含与指定集合相同的元素。
    
    Specified by:
    
    removeAll在界面 Collection<E>
    
    重写：
    
    removeAll在类 AbstractCollection<E>
    
    参数
    
    c - 包含要从此集合中删除的元素的集合
    
    结果
    
    true如果此集合因呼叫而更改
    
    异常
    
    NullPointerException - 如果此集合包含一个或多个null元素且指定的集合不支持null元素（ optional ），或者指定的集合为null
    
    另请参见：
    
    AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    复制自类的说明： AbstractCollection
    
    仅保留此集合中包含在指定集合中的元素（可选操作）。换句话说，从此集合中删除未包含在指定集合中的所有元素。
    
    Specified by:
    
    retainAll在界面 Collection<E>
    
    重写：
    
    retainAll在类 AbstractCollection<E>
    
    参数
    
    c - 包含要在此集合中保留的元素的集合
    
    结果
    
    true如果此集合因调用而更改
    
    异常
    
    NullPointerException - 如果此集合包含一个或多个null元素且指定的集合不允许null元素（ optional ），或者指定的集合为null
    
    另请参见：
    
    AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)

Class LinkedBlockingQueue<E>

构造方法摘要

方法摘要

声明方法的类 java.util.AbstractQueue

声明方法的类 java.util.AbstractCollection

声明方法的类 java.lang.Object

声明方法的接口 java.util.concurrent.BlockingQueue

声明方法的接口 java.util.Collection

声明方法的接口 java.util.Queue

构造方法详细信息

LinkedBlockingQueue

LinkedBlockingQueue

LinkedBlockingQueue

方法详细信息

size

remainingCapacity

put

offer

offer

remove

contains

toArray

toArray

clear

drainTo

drainTo

iterator

spliterator

forEach

removeIf

removeAll

retainAll