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

基于链表节点的可选边界阻塞队列。此队列按FIFO（先进先出）顺序排列元素。队列的头部是队列中已存在时间最长的元素。队列的尾部是队列中已存在时间最短的元素。新元素被插入到队列的尾部，队列检索操作获取队列头部的元素。链式队列通常比基于数组的队列具有更高的吞吐量，但在大多数并发应用程序中性能不太可预测。

可选的容量限制构造函数参数用作防止队列过度扩展的方法。如果未指定容量，则等于Integer.MAX_VALUE。除非这会使队列超过容量，否则在每次插入时动态创建链接节点。

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

此类是Java集合框架的成员。

自 JDK 版本:

1.5

另请参阅:

Constructor Summary

Constructors

Constructor

Description

LinkedBlockingQueue()

创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue。

LinkedBlockingQueue(int capacity)

创建一个具有给定（固定）容量的LinkedBlockingQueue。

LinkedBlockingQueue(Collection<? extends E> c)

创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue，最初包含给定集合的元素，按照集合迭代器的遍历顺序添加。
Method Summary

Modifier and Type

Method

Description

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的每个元素执行给定操作，直到所有元素都已处理或操作引发异常。

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)

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

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)

返回一个包含此队列中所有元素的数组，按正确顺序排列；返回数组的运行时类型与指定数组的类型相同。

Methods declared in class java.util.AbstractQueue
add, addAll, element, remove

Methods declared in class java.util.AbstractCollection
containsAll, isEmpty, toString

Methods declared in class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods declared in interface java.util.concurrent.BlockingQueue
add

Methods declared in interface java.util.Collection
addAll, containsAll, equals, hashCode, isEmpty, parallelStream, stream, toArray

Methods declared in interface java.util.Queue
element, remove

Constructor Details
- 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 - 如果指定的集合或其任何元素为null
Method Details
- size
  
  public int size()
  
  返回此队列中的元素数量。
  
  指定者:
  
  size 在接口 Collection<E>中
  
  返回:
  
  此队列中的元素数量
- remainingCapacity
  
  public int remainingCapacity()
  
  返回此队列理想情况下（在没有内存或资源约束的情况下）可以接受的附加元素数量，这始终等于此队列的初始容量减去此队列的当前size。
  请注意，您不能仅通过检查remainingCapacity来确定插入元素的尝试是否成功，因为可能会出现另一个线程即将插入或移除元素的情况。
  
  指定者:
  
  remainingCapacity 在接口 BlockingQueue<E>中
  
  返回:
  
  剩余容量
- put
  
  public void put(E e) throws InterruptedException
  
  将指定的元素插入到此队列的尾部，如有必要，等待空间变得可用。
  
  指定者:
  
  put 在接口 BlockingQueue<E>中
  
  参数:
  
  e - 要添加的元素
  
  抛出:
  
  InterruptedException - 在等待时被中断
  
  NullPointerException - 如果指定的元素为null
- offer
  
  public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException
  
  将指定的元素插入到此队列的尾部，如有必要，等待指定的等待时间以便空间变得可用。
  
  指定者:
  
  offer 在接口 BlockingQueue<E>中
  
  参数:
  
  e - 要添加的元素
  
  timeout - 放弃之前等待的时间长度，以unit为单位
  
  unit - 一个TimeUnit，用于解释timeout参数
  
  返回:
  
  如果成功，则返回true，如果指定的等待时间在空间可用之前过去，则返回false
  
  抛出:
  
  InterruptedException - 在等待时被中断
  
  NullPointerException - 如果指定的元素为null
- offer
  
  public boolean offer(E e)
  
  如果可能立即执行而不超过队列容量，则将指定的元素插入到此队列的尾部，成功时返回true，如果此队列已满则返回false。在使用容量受限队列时，此方法通常优于方法add，后者只能通过抛出异常来插入元素失败。
  
  指定者:
  
  offer 在接口 BlockingQueue<E>中指定
  
  指定者:
  
  offer 在接口 Queue<E>中指定
  
  参数:
  
  e - 要添加的元素
  
  返回值:
  
  如果元素已添加到此队列，则为true，否则为false
  
  抛出:
  
  NullPointerException - 如果指定的元素为null
- take
  
  public E take() throws InterruptedException
  
  从接口复制的描述: BlockingQueue
  
  检索并移除此队列的头部，如果必要，将等待直到有元素可用。
  
  指定者:
  
  take 在接口 BlockingQueue<E>中指定
  
  返回值:
  
  此队列的头部
  
  抛出:
  
  InterruptedException - 如果在等待时被中断
- poll
  
  public E poll(long timeout, TimeUnit unit) throws InterruptedException
  
  从接口复制的描述: BlockingQueue
  
  检索并移除此队列的头部，如果必要，将等待指定的等待时间，直到有元素可用。
  
  指定者:
  
  poll 在接口 BlockingQueue<E>中指定
  
  参数:
  
  timeout - 等待放弃的时间长度，以unit为单位
  
  unit - 一个TimeUnit，用于解释timeout参数
  
  返回值:
  
  此队列的头部，如果在指定的等待时间之前没有元素可用，则为null
  
  抛出:
  
  InterruptedException - 如果在等待时被中断
- poll
  
  public E poll()
  
  从接口复制的描述: Queue
  
  检索并移除此队列的头部，如果此队列为空则返回null。
  
  指定者:
  
  poll 在接口 Queue<E>中指定
  
  返回值:
  
  此队列的头部，如果此队列为空则返回null
- peek
  
  public E peek()
  
  从接口复制的描述: Queue
  
  检索但不移除此队列的头部，如果此队列为空则返回null。
  
  指定者:
  
  peek 在接口 Queue<E>中指定
  
  返回值:
  
  此队列的头部，如果此队列为空则返回null
- remove
  
  public boolean remove(Object o)
  
  从此队列中移除指定元素的一个实例（如果存在）。更正式地说，移除一个元素e，使得o.equals(e)，如果此队列包含一个或多个这样的元素，则返回true（或者等效地，如果此队列由于调用而更改，则返回true）。
  
  指定者:
  
  remove 在接口 BlockingQueue<E>中指定
  
  指定者:
  
  remove 在接口 Collection<E>中指定
  
  覆盖:
  
  remove 在类 AbstractCollection<E>中覆盖
  
  参数:
  
  o - 如果存在，则从此队列中移除的元素
  
  返回值:
  
  如果此队列由于调用而更改，则为true
- contains
  
  public boolean contains(Object o)
  
  如果此队列包含指定元素，则返回true。更正式地说，如果此队列包含至少一个元素e，使得o.equals(e)，则返回true。
  
  指定者:
  
  contains 在接口 BlockingQueue<E>中指定
  
  指定者:
  
  contains 在接口 Collection<E>中指定
  
  覆盖:
  
  contains 在类 AbstractCollection<E>中覆盖
  
  参数:
  
  o - 要在此队列中检查包含性的对象
  
  返回值:
  
  如果此队列包含指定元素，则为true
- toArray
  
  public Object[] toArray()
  
  返回一个包含此队列中所有元素的数组，按正确顺序排列。
  返回的数组将是“安全”的，因为此队列不维护对它的任何引用。（换句话说，此方法必须分配一个新数组）。因此，调用者可以自由修改返回的数组。
  
  此方法充当基于数组和基于集合的API之间的桥梁。
  
  指定者:
  
  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()相同。
  指定者:
  
  toArray 在接口 Collection<E>中指定
  
  覆盖:
  
  toArray 在类 AbstractCollection<E>中覆盖
  
  类型参数:
  
  T - 包含集合的数组的组件类型
  
  参数:
  
  a - 要存储队列元素的数组，如果足够大；否则，将为此目的分配一个具有相同运行时类型的新数组
  
  返回值:
  
  包含此队列中所有元素的数组
  
  抛出:
  
  ArrayStoreException - 如果指定数组的运行时类型不是此队列中每个元素的运行时类型的超类型
  
  NullPointerException - 如果指定数组为null
- clear
  
  public void clear()
  
  原子性地从此队列中移除所有元素。此调用返回后，队列将为空。
  
  指定由：
  
  clear 在接口 Collection<E>中
  
  覆盖：
  
  clear 在类 AbstractQueue<E>中
- drainTo
  
  public int drainTo(Collection<? super E> c)
  
  从接口中复制的描述： BlockingQueue
  
  从此队列中移除所有可用元素并将它们添加到给定的集合中。此操作可能比重复轮询此队列更有效。在尝试将元素添加到集合时遇到故障可能导致元素既不在集合中，也不在队列中，也可能在抛出相关异常时同时存在于两者中。尝试将队列排空到自身会导致 IllegalArgumentException 。此外，如果在操作正在进行时修改了指定的集合，则此操作的行为是未定义的。
  
  指定由：
  
  drainTo 在接口 BlockingQueue<E>中
  
  参数：
  
  c - 要传输元素的集合
  
  返回：
  
  传输的元素数量
  
  抛出：
  
  UnsupportedOperationException - 如果指定集合不支持添加元素
  
  ClassCastException - 如果此队列的元素类别阻止将其添加到指定集合中
  
  NullPointerException - 如果指定集合为null
  
  IllegalArgumentException - 如果指定集合为此队列，或者此队列的某个元素属性阻止将其添加到指定集合中
- drainTo
  
  public int drainTo(Collection<? super E> c, int maxElements)
  
  从接口中复制的描述： BlockingQueue
  
  从此队列中最多移除给定数量的可用元素并将其添加到给定的集合中。在尝试将元素添加到集合时遇到故障可能导致元素既不在集合中，也不在队列中，也可能在抛出相关异常时同时存在于两者中。尝试将队列排空到自身会导致 IllegalArgumentException 。此外，如果在操作正在进行时修改了指定的集合，则此操作的行为是未定义的。
  
  指定由：
  
  drainTo 在接口 BlockingQueue<E>中
  
  参数：
  
  c - 要传输元素的集合
  
  maxElements - 要传输的最大元素数量
  
  返回：
  
  传输的元素数量
  
  抛出：
  
  UnsupportedOperationException - 如果指定集合不支持添加元素
  
  ClassCastException - 如果此队列的元素类别阻止将其添加到指定集合中
  
  NullPointerException - 如果指定集合为null
  
  IllegalArgumentException - 如果指定集合为此队列，或者此队列的某个元素属性阻止将其添加到指定集合中
- iterator
  
  public Iterator<E> iterator()
  
  返回此队列中元素的迭代器，按正确顺序返回元素。元素将按从第一个（头部）到最后一个（尾部）的顺序返回。
  返回的迭代器是弱一致的。
  
  指定由：
  
  iterator 在接口 Collection<E>中
  
  指定由：
  
  iterator 在接口 Iterable<E>中
  
  指定由：
  
  iterator 在类 AbstractCollection<E>中
  
  返回：
  
  按正确顺序返回此队列中元素的迭代器
- spliterator
  
  public Spliterator<E> spliterator()
  
  返回此队列中元素的Spliterator。
  返回的分割迭代器是弱一致的。
  
  Spliterator报告Spliterator.CONCURRENT、Spliterator.ORDERED和Spliterator.NONNULL。
  
  指定由：
  
  spliterator 在接口 Collection<E>中
  
  指定由：
  
  spliterator 在接口 Iterable<E>中
  
  实现注意：
  
  Spliterator实现trySplit以允许有限的并行性。
  
  返回：
  
  此队列中元素的Spliterator
  
  自1.8起：
  
  1.8
- forEach
  
  public void forEach(Consumer<? super E> action)
  
  从接口中复制的描述： Iterable
  
  对Iterable的每个元素执行给定操作，直到所有元素都已处理或操作引发异常。如果指定了迭代顺序，则按迭代顺序执行操作。操作引发的异常将传递给调用者。
  如果操作执行会修改元素的底层来源并产生副作用，则此方法的行为是未指定的，除非覆盖类已指定了并发修改策略。
  
  指定由：
  
  forEach 在接口 Iterable<E>中
  
  参数：
  
  action - 要对每个元素执行的操作
  
  抛出：
  
  NullPointerException - 如果指定的操作为null
- removeIf
  
  public boolean removeIf(Predicate<? super E> filter)
  
  从接口中复制的描述： Collection
  
  移除满足给定谓词的此集合的所有元素。在迭代期间抛出的错误或运行时异常或由谓词抛出的异常将传递给调用者。
  
  指定由：
  
  removeIf 在接口 Collection<E>中
  
  参数：
  
  filter - 返回true以移除元素的谓词
  
  返回：
  
  如果已移除任何元素，则为true
  
  抛出：
  
  NullPointerException - 如果指定的过滤器为null
- removeAll
  
  public boolean removeAll(Collection<?> c)
  
  从类中复制的描述： AbstractCollection
  
  移除此集合中也包含在指定集合中的所有元素（可选操作）。调用此方法后，此集合将不包含与指定集合共有的任何元素。
  指定者:
  
  removeAll 在接口 Collection<E>中
  
  覆盖:
  
  removeAll 在类 AbstractCollection<E>中
  
  参数:
  
  c - 包含要从此集合中移除的元素的集合
  
  返回值:
  
  true 如果此集合由于调用而发生更改
  
  抛出:
  
  NullPointerException - 如果此集合包含一个或多个空元素，并且指定的集合不支持空元素（可选）或指定的集合为null
  
  参见:
  
  AbstractCollection.remove(Object)
  
  AbstractCollection.contains(Object)
- retainAll
  
  public boolean retainAll(Collection<?> c)
  
  从类中复制的描述: AbstractCollection
  
  仅保留此集合中包含在指定集合中的元素（可选操作）。换句话说，从此集合中删除不包含在指定集合中的所有元素。
  指定者:
  
  retainAll 在接口 Collection<E>中
  
  覆盖:
  
  retainAll 在类 AbstractCollection<E>中
  
  参数:
  
  c - 包含要在此集合中保留的元素的集合
  
  返回值:
  
  true 如果此集合由于调用而发生更改
  
  抛出:
  
  NullPointerException - 如果此集合包含一个或多个空元素，并且指定的集合不允许空元素（可选）或指定的集合为null
  
  参见:
  
  AbstractCollection.remove(Object)
  
  AbstractCollection.contains(Object)

Class LinkedBlockingQueue<E>

Constructor Summary

Method Summary

Methods declared in class java.util.AbstractQueue

Methods declared in class java.util.AbstractCollection

Methods declared in class java.lang.Object

Methods declared in interface java.util.concurrent.BlockingQueue

Methods declared in interface java.util.Collection

Methods declared in interface java.util.Queue

Constructor Details

LinkedBlockingQueue

LinkedBlockingQueue

LinkedBlockingQueue

Method Details

size

remainingCapacity

put

offer

offer

take

poll

poll

peek

remove

contains

toArray

toArray

clear

drainTo

drainTo

iterator

spliterator

forEach

removeIf

removeAll

retainAll