# BlockingQueue

public interface **BlockingQueue** implements [Queue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html)\<E\>

|---|---|---|
| Known Indirect Subclasses [ArrayBlockingQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ArrayBlockingQueue.html)\<E\>, [BlockingDeque](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingDeque.html)\<E\>, [DelayQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/DelayQueue.html)\<E extends [Delayed](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Delayed.html)\>, [LinkedBlockingDeque](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/LinkedBlockingDeque.html)\<E\>, [LinkedBlockingQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/LinkedBlockingQueue.html)\<E\>, [LinkedTransferQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/LinkedTransferQueue.html)\<E\>, [PriorityBlockingQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/PriorityBlockingQueue.html)\<E\>, [SynchronousQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/SynchronousQueue.html)\<E\>, [TransferQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TransferQueue.html)\<E\> |---|---| | [ArrayBlockingQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ArrayBlockingQueue.html)\<E\> | A bounded {@linkplain BlockingQueue blocking queue} backed by an array. | | [BlockingDeque](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingDeque.html)\<E\> | A `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Deque.html` that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for space to become available in the deque when storing an element. | | [DelayQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/DelayQueue.html)\<E extends [Delayed](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Delayed.html)\> | An unbounded {@linkplain BlockingQueue blocking queue} of `Delayed` elements, in which an element can only be taken when its delay has expired. | | [LinkedBlockingDeque](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/LinkedBlockingDeque.html)\<E\> | An optionally-bounded {@linkplain BlockingDeque blocking deque} based on linked nodes. | | [LinkedBlockingQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/LinkedBlockingQueue.html)\<E\> | An optionally-bounded {@linkplain BlockingQueue blocking queue} based on linked nodes. | | [LinkedTransferQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/LinkedTransferQueue.html)\<E\> | An unbounded `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TransferQueue.html` based on linked nodes. | | [PriorityBlockingQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/PriorityBlockingQueue.html)\<E\> | An unbounded {@linkplain BlockingQueue blocking queue} that uses the same ordering rules as class `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/PriorityQueue.html` and supplies blocking retrieval operations. | | [SynchronousQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/SynchronousQueue.html)\<E\> | A {@linkplain BlockingQueue blocking queue} in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa. | | [TransferQueue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TransferQueue.html)\<E\> | A `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html` in which producers may wait for consumers to receive elements. | |||

A `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html` that additionally supports operations
that wait for the queue to become non-empty when retrieving an
element, and wait for space to become available in the queue when
storing an element.

`BlockingQueue` methods come in four forms, with different ways
of handling operations that cannot be satisfied immediately, but may be
satisfied at some point in the future:
one throws an exception, the second returns a special value (either
`null` or `false`, depending on the operation), the third
blocks the current thread indefinitely until the operation can succeed,
and the fourth blocks for only a given maximum time limit before giving
up. These methods are summarized in the following table:

|---|---|---|---|---|
|   | *Throws exception* | *Special value* | *Blocks* | *Times out* |
| **Insert** | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#add(E)` | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#offer(E)` | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#put(E)` | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#offer(E,%20long,%20java.util.concurrent.TimeUnit)` |
| **Remove** | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#remove()` | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#poll()` | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#take()` | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#poll(long,%20java.util.concurrent.TimeUnit)` |
| **Examine** | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#element()` | `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#peek()` | *not applicable* | *not applicable* |
[Summary of BlockingQueue methods]

A `BlockingQueue` does not accept `null` elements.
Implementations throw `NullPointerException` on attempts
to `add`, `put` or `offer` a `null`. A
`null` is used as a sentinel value to indicate failure of
`poll` operations.

A `BlockingQueue` may be capacity bounded. At any given
time it may have a `remainingCapacity` beyond which no
additional elements can be `put` without blocking.
A `BlockingQueue` without any intrinsic capacity constraints always
reports a remaining capacity of `Integer.MAX_VALUE`.

`BlockingQueue` implementations are designed to be used
primarily for producer-consumer queues, but additionally support
the `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html` interface. So, for example, it is
possible to remove an arbitrary element from a queue using
`remove(x)`. However, such operations are in general
*not* performed very efficiently, and are intended for only
occasional use, such as when a queued message is cancelled.

`BlockingQueue` implementations are thread-safe. All
queuing methods achieve their effects atomically using internal
locks or other forms of concurrency control. However, the
*bulk* Collection operations `addAll`,
`containsAll`, `retainAll` and `removeAll` are
*not* necessarily performed atomically unless specified
otherwise in an implementation. So it is possible, for example, for
`addAll(c)` to fail (throwing an exception) after adding
only some of the elements in `c`.

A `BlockingQueue` does *not* intrinsically support
any kind of "close" or "shutdown" operation to
indicate that no more items will be added. The needs and usage of
such features tend to be implementation-dependent. For example, a
common tactic is for producers to insert special
*end-of-stream* or *poison* objects, that are
interpreted accordingly when taken by consumers.


Usage example, based on a typical producer-consumer scenario.
Note that a `BlockingQueue` can safely be used with multiple
producers and multiple consumers.

     class Producer implements Runnable {
       private final BlockingQueue queue;
       Producer(BlockingQueue q) { queue = q; }
       public void run() {
         try {
           while (true) { queue.put(produce()); }
         } catch (InterruptedException ex) { ... handle ...}
       }
       Object produce() { ... }
     }

     class Consumer implements Runnable {
       private final BlockingQueue queue;
       Consumer(BlockingQueue q) { queue = q; }
       public void run() {
         try {
           while (true) { consume(queue.take()); }
         } catch (InterruptedException ex) { ... handle ...}
       }
       void consume(Object x) { ... }
     }

     class Setup {
       void main() {
         BlockingQueue q = new SomeQueueImplementation();
         Producer p = new Producer(q);
         Consumer c1 = new Consumer(q);
         Consumer c2 = new Consumer(q);
         new Thread(p).start();
         new Thread(c1).start();
         new Thread(c2).start();
       }
     }

Memory consistency effects: As with other concurrent
collections, actions in a thread prior to placing an object into a
`BlockingQueue`
[*happen-before*](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/package-summary#MemoryVisibility)
actions subsequent to the access or removal of that element from
the `BlockingQueue` in another thread.

### Public Method Summary

|---|---|
| abstract boolean | [add](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#add(E))(E e) Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning `true` upon success and throwing an `IllegalStateException` if no space is currently available. |
| abstract boolean | [contains](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#contains(java.lang.Object))([Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) o) Returns `true` if this queue contains the specified element. |
| abstract int | [drainTo](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#drainTo(java.util.Collection<?%20super%20E>))([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<? super E\> c) Removes all available elements from this queue and adds them to the given collection. |
| abstract int | [drainTo](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#drainTo(java.util.Collection<?%20super%20E>,%20int))([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<? super E\> c, int maxElements) Removes at most the given number of available elements from this queue and adds them to the given collection. |
| abstract boolean | [offer](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#offer(E))(E e) Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning `true` upon success and `false` if no space is currently available. |
| abstract boolean | [offer](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#offer(E,%20long,%20java.util.concurrent.TimeUnit))(E e, long timeout, [TimeUnit](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TimeUnit.html) unit) Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available. |
| abstract E | [poll](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#poll(long,%20java.util.concurrent.TimeUnit))(long timeout, [TimeUnit](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TimeUnit.html) unit) Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an element to become available. |
| abstract void | [put](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#put(E))(E e) Inserts the specified element into this queue, waiting if necessary for space to become available. |
| abstract int | [remainingCapacity](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#remainingCapacity())() Returns the number of additional elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking, or `Integer.MAX_VALUE` if there is no intrinsic limit. |
| abstract boolean | [remove](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#remove(java.lang.Object))([Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) o) Removes a single instance of the specified element from this queue, if it is present. |
| abstract E | [take](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#take())() Retrieves and removes the head of this queue, waiting if necessary until an element becomes available. |

### Inherited Method Summary

From interface [java.util.Queue](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html)

|---|---|
| abstract boolean | [add](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#add(E))(E e) Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning `true` upon success and throwing an `IllegalStateException` if no space is currently available. |
| abstract E | [element](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#element())() Retrieves, but does not remove, the head of this queue. |
| abstract boolean | [offer](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#offer(E))(E e) Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions. |
| abstract E | [peek](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#peek())() Retrieves, but does not remove, the head of this queue, or returns `null` if this queue is empty. |
| abstract E | [poll](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#poll())() Retrieves and removes the head of this queue, or returns `null` if this queue is empty. |
| abstract E | [remove](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Queue.html#remove())() Retrieves and removes the head of this queue. |

From interface [java.util.Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)

|---|---|
| abstract boolean | [add](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#add(E))(E e) Ensures that this collection contains the specified element (optional operation). |
| abstract boolean | [addAll](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#addAll(java.util.Collection<?%20extends%20E>))([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<? extends E\> c) Adds all of the elements in the specified collection to this collection (optional operation). |
| abstract void | [clear](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#clear())() Removes all of the elements from this collection (optional operation). |
| abstract boolean | [contains](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#contains(java.lang.Object))([Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) o) Returns true if this collection contains the specified element. |
| abstract boolean | [containsAll](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#containsAll(java.util.Collection<?>))([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<?\> c) Returns true if this collection contains all of the elements in the specified collection. |
| abstract boolean | [equals](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#equals(java.lang.Object))([Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) o) Compares the specified object with this collection for equality. |
| abstract int | [hashCode](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#hashCode())() Returns the hash code value for this collection. |
| abstract boolean | [isEmpty](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#isEmpty())() Returns true if this collection contains no elements. |
| abstract [Iterator](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Iterator.html)\<E\> | [iterator](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#iterator())() Returns an iterator over the elements in this collection. |
| [Stream](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/stream/Stream.html)\<E\> | [parallelStream](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#parallelStream())() Returns a possibly parallel `Stream` with this collection as its source. |
| abstract boolean | [remove](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#remove(java.lang.Object))([Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) o) Removes a single instance of the specified element from this collection, if it is present (optional operation). |
| abstract boolean | [removeAll](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#removeAll(java.util.Collection<?>))([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<?\> c) Removes all of this collection's elements that are also contained in the specified collection (optional operation). |
| boolean | [removeIf](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#removeIf(java.util.function.Predicate<?%20super%20E>))([Predicate](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/function/Predicate.html)\<? super E\> filter) Removes all of the elements of this collection that satisfy the given predicate. |
| abstract boolean | [retainAll](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#retainAll(java.util.Collection<?>))([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<?\> c) Retains only the elements in this collection that are contained in the specified collection (optional operation). |
| abstract int | [size](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#size())() Returns the number of elements in this collection. |
| [Spliterator](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Spliterator.html)\<E\> | [spliterator](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#spliterator())() Creates a `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Spliterator.html` over the elements in this collection. |
| [Stream](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/stream/Stream.html)\<E\> | [stream](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#stream())() Returns a sequential `Stream` with this collection as its source. |
| abstract \<T\> T\[\] | [toArray](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#toArray(T[]))(T\[\] a) Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. |
| abstract [Object\[\]](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) | [toArray](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#toArray())() Returns an array containing all of the elements in this collection. |

From interface [java.lang.Iterable](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Iterable.html)

|---|---|
| void | [forEach](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Iterable.html#forEach(java.util.function.Consumer<?%20super%20T>))([Consumer](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/function/Consumer.html)\<? super T\> action) Performs the given action for each element of the `Iterable` until all elements have been processed or the action throws an exception. |
| abstract [Iterator](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Iterator.html)\<E\> | [iterator](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Iterable.html#iterator())() Returns an iterator over elements of type `T`. |
| [Spliterator](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Spliterator.html)\<E\> | [spliterator](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Iterable.html#spliterator())() Creates a `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Spliterator.html` over the elements described by this `Iterable`. |

## Public Methods

#### public abstract boolean
**add**
(E e)

Inserts the specified element into this queue if it is possible to do
so immediately without violating capacity restrictions, returning
`true` upon success and throwing an
`IllegalStateException` if no space is currently available.
When using a capacity-restricted queue, it is generally preferable to
use `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#offer(E)`.

##### Parameters

| e | the element to add |
|---|---|

##### Returns

- `true` (as specified by `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#add(E)`)

##### Throws

| [IllegalStateException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/IllegalStateException.html) | if the element cannot be added at this time due to capacity restrictions |
| [ClassCastException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/ClassCastException.html) | if the class of the specified element prevents it from being added to this queue |
| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if the specified element is null |
| [IllegalArgumentException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/IllegalArgumentException.html) | if some property of the specified element prevents it from being added to this queue |
|---|---|

#### public abstract boolean
**contains**
([Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) o)

Returns `true` if this queue contains the specified element.
More formally, returns `true` if and only if this queue contains
at least one element `e` such that `o.equals(e)`.

##### Parameters

| o | object to be checked for containment in this queue |
|---|---|

##### Returns

- `true` if this queue contains the specified element

##### Throws

| [ClassCastException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/ClassCastException.html) | if the class of the specified element is incompatible with this queue ([optional](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#optional-restrictions)) |
| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if the specified element is null ([optional](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#optional-restrictions)) |
|---|---|

#### public abstract int
**drainTo**
([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<? super E\> c)

Removes all available elements from this queue and adds them
to the given collection. This operation may be more
efficient than repeatedly polling this queue. A failure
encountered while attempting to add elements to
collection `c` may result in elements being in neither,
either or both collections when the associated exception is
thrown. Attempts to drain a queue to itself result in
`IllegalArgumentException`. Further, the behavior of
this operation is undefined if the specified collection is
modified while the operation is in progress.

##### Parameters

| c | the collection to transfer elements into |
|---|---|

##### Returns

- the number of elements transferred

##### Throws

| [UnsupportedOperationException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/UnsupportedOperationException.html) | if addition of elements is not supported by the specified collection |
| [ClassCastException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/ClassCastException.html) | if the class of an element of this queue prevents it from being added to the specified collection |
| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if the specified collection is null |
| [IllegalArgumentException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/IllegalArgumentException.html) | if the specified collection is this queue, or some property of an element of this queue prevents it from being added to the specified collection |
|---|---|

#### public abstract int
**drainTo**
([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<? super E\> c, int maxElements)

Removes at most the given number of available elements from
this queue and adds them to the given collection. A failure
encountered while attempting to add elements to
collection `c` may result in elements being in neither,
either or both collections when the associated exception is
thrown. Attempts to drain a queue to itself result in
`IllegalArgumentException`. Further, the behavior of
this operation is undefined if the specified collection is
modified while the operation is in progress.

##### Parameters

| c | the collection to transfer elements into |
| maxElements | the maximum number of elements to transfer |
|---|---|

##### Returns

- the number of elements transferred

##### Throws

| [UnsupportedOperationException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/UnsupportedOperationException.html) | if addition of elements is not supported by the specified collection |
| [ClassCastException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/ClassCastException.html) | if the class of an element of this queue prevents it from being added to the specified collection |
| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if the specified collection is null |
| [IllegalArgumentException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/IllegalArgumentException.html) | if the specified collection is this queue, or some property of an element of this queue prevents it from being added to the specified collection |
|---|---|

#### public abstract boolean
**offer**
(E e)

Inserts the specified element into this queue if it is possible to do
so immediately without violating capacity restrictions, returning
`true` upon success and `false` if no space is currently
available. When using a capacity-restricted queue, this method is
generally preferable to `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/BlockingQueue.html#add(E)`, which can fail to insert an
element only by throwing an exception.

##### Parameters

| e | the element to add |
|---|---|

##### Returns

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

##### Throws

| [ClassCastException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/ClassCastException.html) | if the class of the specified element prevents it from being added to this queue |
| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if the specified element is null |
| [IllegalArgumentException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/IllegalArgumentException.html) | if some property of the specified element prevents it from being added to this queue |
|---|---|

#### public abstract boolean
**offer**
(E e, long timeout, [TimeUnit](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TimeUnit.html) unit)

Inserts the specified element into this queue, waiting up to the
specified wait time if necessary for space to become available.

##### Parameters

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

##### Returns

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

##### Throws

| [InterruptedException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/InterruptedException.html) | if interrupted while waiting |
| [ClassCastException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/ClassCastException.html) | if the class of the specified element prevents it from being added to this queue |
| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if the specified element is null |
| [IllegalArgumentException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/IllegalArgumentException.html) | if some property of the specified element prevents it from being added to this queue |
|---|---|

#### public abstract E
**poll**
(long timeout, [TimeUnit](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TimeUnit.html) unit)

Retrieves and removes the head of this queue, waiting up to the
specified wait time if necessary for an element to become available.

##### Parameters

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

##### Returns

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

##### Throws

| [InterruptedException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/InterruptedException.html) | if interrupted while waiting |
|---|---|

#### public abstract void
**put**
(E e)

Inserts the specified element into this queue, waiting if necessary
for space to become available.

##### Parameters

| e | the element to add |
|---|---|

##### Throws

| [InterruptedException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/InterruptedException.html) | if interrupted while waiting |
| [ClassCastException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/ClassCastException.html) | if the class of the specified element prevents it from being added to this queue |
| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if the specified element is null |
| [IllegalArgumentException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/IllegalArgumentException.html) | if some property of the specified element prevents it from being added to this queue |
|---|---|

#### public abstract int
**remainingCapacity**
()

Returns the number of additional elements that this queue can ideally
(in the absence of memory or resource constraints) accept without
blocking, or `Integer.MAX_VALUE` if there is no intrinsic
limit.

Note that you *cannot* always tell if an attempt to insert
an element will succeed by inspecting `remainingCapacity`
because it may be the case that another thread is about to
insert or remove an element.

##### Returns

- the remaining capacity

#### public abstract boolean
**remove**
([Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) o)

Removes a single instance of the specified element from this queue,
if it is present. More formally, removes an element `e` such
that `o.equals(e)`, if this queue contains one or more such
elements.
Returns `true` if this queue contained the specified element
(or equivalently, if this queue changed as a result of the call).

##### Parameters

| o | element to be removed from this queue, if present |
|---|---|

##### Returns

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

##### Throws

| [ClassCastException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/ClassCastException.html) | if the class of the specified element is incompatible with this queue ([optional](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#optional-restrictions)) |
| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if the specified element is null ([optional](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html#optional-restrictions)) |
|---|---|

#### public abstract E
**take**
()

Retrieves and removes the head of this queue, waiting if necessary
until an element becomes available.

##### Returns

- the head of this queue

##### Throws

| [InterruptedException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/InterruptedException.html) | if interrupted while waiting |
|---|---|