Most visited

Recently visited

Results for

Added in API level 1

Summary: Ctors | Methods | Inherited Methods | [Expand All]

ArrayBlockingQueue

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

java.lang.Object
↳	java.util.AbstractCollection<E>
	↳	java.util.AbstractQueue<E>
		↳	java.util.concurrent.ArrayBlockingQueue<E>

由数组支持的有界的blocking queue 。该队列命令元素FIFO（先进先出）。队列头是最长时间在队列中的元素。队列的尾部是已经在队列上的最短时间的元素。新元素插入到队列尾部，队列检索操作获取队列头部的元素。

这是一个经典的“有界缓冲区”，其中一个固定大小的数组包含生产者插入的元素，并由消费者提取。一旦创建，容量不能改变。尝试将put元素放入完整队列将导致操作阻塞; 尝试take来自空队列的元素将同样阻塞。

该类支持订购等待生产者和消费者线程的可选公平策略。默认情况下，这个顺序不能保证。但是，以公平性设置为true的队列授予按FIFO顺序的线程访问权限。公平性通常会降低吞吐量，但会降低可变性并避免饥饿。

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

Summary

Public constructors
`ArrayBlockingQueue(int capacity)` 使用给定（固定）容量和默认访问策略创建 `ArrayBlockingQueue` 。
`ArrayBlockingQueue(int capacity, boolean fair)` 创建具有给定（固定）容量和指定访问策略的 `ArrayBlockingQueue` 。
`ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)` 创建具有给定（固定）容量的 `ArrayBlockingQueue` ，指定的访问策略并初始包含给定集合的元素，并按集合迭代器的遍历顺序添加。

Public methods
`boolean`	`add(E e)` 在插入此队列的尾部，如果有可能立即这样做不超过该队列的容量，返回指定的元素 `true`成功时与抛出 `IllegalStateException`如果此队列已满。
`void`	`clear()` 从这个队列中删除所有元素。
`boolean`	`contains(Object o)` 如果此队列包含指定的元素，则返回 `true` 。
`int`	`drainTo(Collection<? super E> c, int maxElements)` 最多从此队列中移除给定数量的可用元素，并将它们添加到给定集合中。
`int`	`drainTo(Collection<? super E> c)` 从该队列中移除所有可用的元素，并将它们添加到给定的集合中。
`Iterator<E>`	`iterator()` 以正确的顺序返回此队列中元素的迭代器。
`boolean`	`offer(E e)` 插入指定的元素在这个队列的尾部，如果有可能立即这样做不超过该队列的容量，返回 `true`在成功和 `false`如果此队列已满。
`boolean`	`offer(E e, long timeout, TimeUnit unit)` 在该队列的尾部插入指定的元素，如果队列已满，则等待指定的等待时间以使空间变为可用。
`E`	`peek()` 检索但不移除此队列的头部，或者如果此队列为空，则返回 `null` 。
`E`	`poll(long timeout, TimeUnit unit)` 检索并删除此队列的头部，如果元素变为可用，则等待达到指定的等待时间。
`E`	`poll()` 检索并删除此队列的头部，或者如果此队列为空，则返回 `null` 。
`void`	`put(E e)` 在队列的尾部插入指定的元素，等待队列满时空间变为可用。
`int`	`remainingCapacity()` 返回此队列理想情况下（在没有内存或资源约束的情况下）无阻塞地接受的其他元素的数量。
`boolean`	`remove(Object o)` 从该队列中移除指定元素的单个实例（如果存在）。
`int`	`size()` 返回此队列中的元素数量。
`Spliterator<E>`	`spliterator()` 返回此队列中元素的 `Spliterator` 。
`E`	`take()` 检索并删除此队列的头部，如果需要等待，直到元素变为可用。
`<T> T[]`	`toArray(T[] a)` 以适当的顺序返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。
`Object[]`	`toArray()` 以适当的顺序返回包含此队列中所有元素的数组。
`String`	`toString()` 返回此集合的字符串表示形式。

Inherited methods

From class java.util.AbstractQueue

From class java.util.AbstractCollection

`boolean`	`add(E e)` 确保此集合包含指定的元素（可选操作）。这个实现总是抛出一个 `UnsupportedOperationException` 。
`boolean`	`addAll(Collection<? extends E> c)` 将指定集合中的所有元素添加到此集合（可选操作）。该实现迭代指定的集合，并将迭代器返回的每个对象依次添加到该集合中。
`void`	`clear()` 从该集合中删除所有元素（可选操作）。此实现迭代该集合，使用 `Iterator.remove`操作删除每个元素。
`boolean`	`contains(Object o)` 如果此集合包含指定的元素，则返回 `true` 。该实现迭代集合中的元素，依次检查每个元素是否与指定元素相等。
`boolean`	`containsAll(Collection<?> c)` 如果此集合包含指定集合中的所有元素，则返回 `true` 。此实现迭代指定的集合，依次检查迭代器返回的每个元素，以查看它是否包含在此集合中。
`boolean`	`isEmpty()` 如果此集合不包含元素，则返回 `true` 。该实现返回 `size() == 0` 。
`abstract Iterator<E>`	`iterator()` 返回此集合中包含的元素的迭代器。
`boolean`	`remove(Object o)` 从该集合中移除指定元素的单个实例（如果存在）（可选操作）。该实现迭代查找指定元素的集合。
`boolean`	`removeAll(Collection<?> c)` 删除指定集合中包含的所有此集合的元素（可选操作）。该实现迭代该集合，依次检查迭代器返回的每个元素，以查看它是否包含在指定集合中。
`boolean`	`retainAll(Collection<?> c)` 仅保留包含在指定集合中的此集合中的元素（可选操作）。该实现迭代该集合，依次检查迭代器返回的每个元素，以查看它是否包含在指定集合中。
`abstract int`	`size()` 返回此集合中的元素数量。
`<T> T[]`	`toArray(T[] a)` 返回包含此集合中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。该实现返回一个数组，其中包含由该集合的迭代器以相同顺序返回的所有元素，并存储在数组的连续元素中，从索引 `0`开始。
`Object[]`	`toArray()` 返回包含此集合中所有元素的数组。该实现返回一个数组，其中包含由该集合的迭代器返回的所有元素，该数组按照相同的顺序存储在数组的连续元素中，从索引 `0`开始。
`String`	`toString()` 返回此集合的字符串表示形式。

From class java.lang.Object

From interface java.util.Queue

From interface java.util.Collection

`abstract boolean`	`add(E e)` 确保此集合包含指定的元素（可选操作）。
`abstract boolean`	`addAll(Collection<? extends E> c)` 将指定集合中的所有元素添加到此集合（可选操作）。
`abstract void`	`clear()` 从该集合中删除所有元素（可选操作）。
`abstract boolean`	`contains(Object o)` 如果此集合包含指定的元素，则返回 `true` 。
`abstract boolean`	`containsAll(Collection<?> c)` 如果此集合包含指定集合中的所有元素，则返回 `true` 。
`abstract boolean`	`equals(Object o)` 将指定的对象与此集合进行比较以获得相等性。
`abstract int`	`hashCode()` 返回此集合的哈希码值。
`abstract boolean`	`isEmpty()` 如果此集合不包含元素，则返回 `true` 。
`abstract Iterator<E>`	`iterator()` 返回此集合中元素的迭代器。
`default Stream<E>`	`parallelStream()` 返回一个可能与此集合并行的 `Stream`作为其源。
`abstract boolean`	`remove(Object o)` 从该集合中移除指定元素的单个实例（如果存在）（可选操作）。
`abstract boolean`	`removeAll(Collection<?> c)` 删除指定集合中包含的所有此集合的元素（可选操作）。
`default boolean`	`removeIf(Predicate<? super E> filter)` 删除此集合中满足给定谓词的所有元素。
`abstract boolean`	`retainAll(Collection<?> c)` 仅保留包含在指定集合中的此集合中的元素（可选操作）。
`abstract int`	`size()` 返回此集合中的元素数量。
`default Spliterator<E>`	`spliterator()` 在此集合中的元素上创建一个 `Spliterator` 。
`default Stream<E>`	`stream()` 以此集合作为源返回一个连续的 `Stream` 。
`abstract <T> T[]`	`toArray(T[] a)` 返回包含此集合中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。
`abstract Object[]`	`toArray()` 返回包含此集合中所有元素的数组。

From interface java.util.concurrent.BlockingQueue

`abstract boolean`	`add(E e)` 将指定的元素插入此队列中，如果它是立即可行且不会违反容量限制，返回 `true`在成功和抛出 `IllegalStateException` ，如果当前没有空间可用。
`abstract boolean`	`contains(Object o)` 如果此队列包含指定的元素，则返回 `true` 。
`abstract int`	`drainTo(Collection<? super E> c)` 从该队列中移除所有可用的元素，并将它们添加到给定的集合中。
`abstract int`	`drainTo(Collection<? super E> c, int maxElements)` 最多从此队列中移除给定数量的可用元素，并将它们添加到给定集合中。
`abstract boolean`	`offer(E e)` 将指定的元素插入此队列中，如果它是立即可行且不会违反容量限制，返回 `true`在成功和 `false`如果当前没有空间可用。
`abstract boolean`	`offer(E e, long timeout, TimeUnit unit)` 将指定的元素插入此队列中，如有必要，等待指定的等待时间以使空间变为可用。
`abstract E`	`poll(long timeout, TimeUnit unit)` 检索并删除此队列的头部，如果元素变为可用，则等待达到指定的等待时间。
`abstract void`	`put(E e)` 将指定的元素插入此队列，等待空间变得可用时。
`abstract int`	`remainingCapacity()` 如果没有内部限制，则返回此队列理想情况下（在没有内存或资源约束的情况下）接受而没有阻塞的附加元素的数量，或者 `Integer.MAX_VALUE` 。
`abstract boolean`	`remove(Object o)` 从该队列中移除指定元素的单个实例（如果存在）。
`abstract E`	`take()` 检索并删除此队列的头部，如果需要等待，直到元素变为可用。

From interface java.lang.Iterable

Public constructors

ArrayBlockingQueue

Added in API level 1

ArrayBlockingQueue (int capacity)

使用给定（固定）容量和默认访问策略创建 ArrayBlockingQueue 。

Parameters
`capacity`	`int`: the capacity of this queue

Throws
`IllegalArgumentException`	if `capacity < 1`

ArrayBlockingQueue

Added in API level 1

ArrayBlockingQueue (int capacity, 
                boolean fair)

创建具有给定（固定）容量和指定访问策略的 ArrayBlockingQueue 。

Parameters
`capacity`	`int`: the capacity of this queue
`fair`	`boolean`: if `true` then queue accesses for threads blocked on insertion or removal, are processed in FIFO order; if `false` the access order is unspecified.

Throws
`IllegalArgumentException`	if `capacity < 1`

ArrayBlockingQueue

Added in API level 1

ArrayBlockingQueue (int capacity, 
                boolean fair, 
                Collection<? extends E> c)

使用给定（固定）容量，指定的访问策略创建 ArrayBlockingQueue ，并初始包含给定集合的元素，并按集合迭代器的遍历顺序添加。

Parameters
`capacity`	`int`: the capacity of this queue
`fair`	`boolean`: if `true` then queue accesses for threads blocked on insertion or removal, are processed in FIFO order; if `false` the access order is unspecified.
`c`	`Collection`: the collection of elements to initially contain

Throws
`IllegalArgumentException`	if `capacity` is less than `c.size()`, or less than 1.
`NullPointerException`	if the specified collection or any of its elements are null

Public methods

add

Added in API level 1

boolean add (E e)

在插入此队列的尾部，如果有可能立即这样做不超过该队列的容量，返回指定的元素 true成功时与抛出 IllegalStateException如果此队列已满。

Parameters
`e`	`E`: the element to add

Returns
`boolean`	`true` (as specified by `add(E)`)

Throws
`IllegalStateException`	if this queue is full
`NullPointerException`	if the specified element is null

clear

Added in API level 1

void clear ()

从这个队列中删除所有元素。此通话返回后，队列将为空。

contains

Added in API level 1

boolean contains (Object o)

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

Parameters
`o`	`Object`: object to be checked for containment in this queue

Returns
`boolean`	`true` if this queue contains the specified element

drainTo

Added in API level 1

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

最多从此队列中移除给定数量的可用元素，并将它们添加到给定集合中。尝试将元素添加到集合c遇到的故障可能导致元素不在任何集合中，或者在引发关联的异常时集合都不集中。尝试将队列IllegalArgumentException自身导致IllegalArgumentException 。此外，如果在操作正在进行时修改了指定的集合，则此操作的行为未定义。

Parameters
`c`	`Collection`: the collection to transfer elements into
`maxElements`	`int`: the maximum number of elements to transfer

Returns
`int`	the number of elements transferred

Throws
`UnsupportedOperationException`
`ClassCastException`
`NullPointerException`
`IllegalArgumentException`

drainTo

Added in API level 1

int drainTo (Collection<? super E> c)

从该队列中移除所有可用的元素，并将它们添加到给定的集合中。该操作可能比重复轮询该队列更有效。尝试将元素添加到集合c遇到的故障可能导致元素不在任何集合中，或者在引发关联的异常时集合都不集中。尝试将队列排空到自身导致IllegalArgumentException 。此外，如果在操作正在进行时修改了指定的集合，则此操作的行为未定义。

Parameters
`c`	`Collection`: the collection to transfer elements into

Returns
`int`	the number of elements transferred

Throws
`UnsupportedOperationException`
`ClassCastException`
`NullPointerException`
`IllegalArgumentException`

iterator

Added in API level 1

Iterator<E> iterator ()

以正确的顺序返回此队列中元素的迭代器。元素将从第一个（头部）到最后一个（尾部）按顺序返回。

返回的迭代器是 weakly consistent 。

Returns
`Iterator<E>`	an iterator over the elements in this queue in proper sequence

offer

Added in API level 1

boolean offer (E e)

插入指定的元素在这个队列的尾部，如果有可能立即这样做不超过该队列的容量，返回true在成功和false如果此队列已满。此方法通常比方法add(E) ，它只能通过抛出异常来插入元素。

Parameters
`e`	`E`: the element to add

Returns
`boolean`	`true` if the element was added to this queue, else `false`

Throws
`NullPointerException`	if the specified element is null

offer

Added in API level 1

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

在该队列的尾部插入指定的元素，如果队列已满，则等待指定的等待时间以使空间变为可用。

Parameters
`e`	`E`: the element to add
`timeout`	`long`: how long to wait before giving up, in units of `unit`
`unit`	`TimeUnit`: a `TimeUnit` determining how to interpret the `timeout` parameter

Returns
`boolean`	`true` if successful, or `false` if the specified waiting time elapses before space is available

Throws
`InterruptedException`
`NullPointerException`

peek

Added in API level 1

E peek ()

检索但不移除此队列的头部;如果此队列为空，则返回 null 。

Returns
`E`	the head of this queue, or `null` if this queue is empty

poll

Added in API level 1

E poll (long timeout, 
                TimeUnit unit)

检索并删除此队列的头部，如果元素变为可用，则等待达到指定的等待时间。

Parameters
`timeout`	`long`: how long to wait before giving up, in units of `unit`
`unit`	`TimeUnit`: a `TimeUnit` determining how to interpret the `timeout` parameter

Returns
`E`	the head of this queue, or `null` if the specified waiting time elapses before an element is available

Throws
`InterruptedException`

poll

Added in API level 1

E poll ()

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

Returns
`E`	the head of this queue, or `null` if this queue is empty

put

Added in API level 1

void put (E e)

在队列的尾部插入指定的元素，等待队列满时空间变为可用。

Parameters
`e`	`E`: the element to add

Throws
`InterruptedException`
`NullPointerException`

remainingCapacity

Added in API level 1

int remainingCapacity ()

返回此队列理想情况下（在没有内存或资源约束的情况下）无阻塞地接受的其他元素的数量。这总是等于此队列的初始容量减去此队列的当前size 。

请注意，您不能总是通过检查 remainingCapacity来判断尝试插入元素是否成功，因为可能是另一个线程即将插入或移除元素。

Returns
`int`	the remaining capacity

remove

Added in API level 1

boolean remove (Object o)

从该队列中移除指定元素的单个实例（如果存在）。更正式地说，删除一个元素e ，使得o.equals(e) ，如果这个队列包含一个或多个这样的元素。如果此队列包含指定的元素（或者等同于此队列因呼叫而更改），则返回true 。

在基于循环阵列的队列中去除内部元素本质上是一种缓慢且具有破坏性的操作，因此只能在特殊情况下进行，理想情况下只有当队列已知不能被其他线程访问时。

Parameters
`o`	`Object`: element to be removed from this queue, if present

Returns
`boolean`	`true` if this queue changed as a result of the call

size

Added in API level 1

int size ()

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

Returns
`int`	the number of elements in this queue

spliterator

Added in API level 24

Spliterator<E> spliterator ()

返回此队列中元素的 Spliterator 。

返回的分隔符是 weakly consistent 。

该 Spliterator报告 CONCURRENT ， ORDERED ，并 NONNULL 。

Implementation Note:

The Spliterator implements trySplit to permit limited parallelism.

Returns
`Spliterator<E>`	a `Spliterator` over the elements in this queue

take

Added in API level 1

E take ()

检索并删除此队列的头部，如果需要等待，直到元素变为可用。

Returns
`E`	the head of this queue

Throws
`InterruptedException`

toArray

Added in API level 1

T[] toArray (T[] a)

以适当的顺序返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。如果队列适合指定的数组，则返回其中。否则，将使用指定数组的运行时类型和此队列的大小分配一个新数组。

如果此队列适合指定阵列，并有空余空间（即阵列具有比此队列更多的元素），则紧随队列尾部的阵列中的元素将设置为 null 。

与toArray()方法一样，此方法充当基于数组和基于集合的API之间的桥梁。此外，该方法允许精确控制输出数组的运行时类型，并且在某些情况下可以用于节省分配成本。

假设x是已知只包含字符串的队列。以下代码可用于将队列转储到新分配的String阵列中：

 String[] y = x.toArray(new String[0]);

Note that toArray(new Object[0]) is identical in function to toArray().

Parameters
`a`	`T`: the array into which the elements of the queue are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose

Returns
`T[]`	an array containing all of the elements in this queue

Throws
`ArrayStoreException`	if the runtime type of the specified array is not a supertype of the runtime type of every element in this queue
`NullPointerException`	if the specified array is null

toArray

Added in API level 1

Object[] toArray ()

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

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

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

Returns
`Object[]`	an array containing all of the elements in this queue

toString

Added in API level 1

String toString ()

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

Returns
`String`	a string representation of this collection

Interfaces

Classes

Enums

Exceptions

Most visited

Recently visited

Results for

ArrayBlockingQueue

Summary

Public constructors

Public methods

Inherited methods

Public constructors

ArrayBlockingQueue

ArrayBlockingQueue

ArrayBlockingQueue

Public methods

add

clear

contains

drainTo

drainTo

iterator

offer

offer

peek

poll

poll

put

remainingCapacity

remove

size

spliterator

Implementation Note:

take

toArray

toArray

toString