Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels) Summary: [Methods](https://developer.android.com/reference/java/util/concurrent/BlockingQueue#pubmethods) \| [Inherited Methods](https://developer.android.com/reference/java/util/concurrent/BlockingQueue#inhmethods)

# BlockingQueue


`
public


interface
BlockingQueue
`


`


implements

https://developer.android.com/reference/java/util/Queue<E>


`

|---|
| java.util.concurrent.BlockingQueue\<E\> |

|---|
| Known indirect subclasses [ArrayBlockingQueue](https://developer.android.com/reference/java/util/concurrent/ArrayBlockingQueue)\<E\>, [BlockingDeque](https://developer.android.com/reference/java/util/concurrent/BlockingDeque)\<E\>, [DelayQueue](https://developer.android.com/reference/java/util/concurrent/DelayQueue)\<E extends [Delayed](https://developer.android.com/reference/java/util/concurrent/Delayed)\>, [LinkedBlockingDeque](https://developer.android.com/reference/java/util/concurrent/LinkedBlockingDeque)\<E\>, [LinkedBlockingQueue](https://developer.android.com/reference/java/util/concurrent/LinkedBlockingQueue)\<E\>, [LinkedTransferQueue](https://developer.android.com/reference/java/util/concurrent/LinkedTransferQueue)\<E\>, [PriorityBlockingQueue](https://developer.android.com/reference/java/util/concurrent/PriorityBlockingQueue)\<E\>, [SynchronousQueue](https://developer.android.com/reference/java/util/concurrent/SynchronousQueue)\<E\>, [TransferQueue](https://developer.android.com/reference/java/util/concurrent/TransferQueue)\<E\> |---|---| | [ArrayBlockingQueue](https://developer.android.com/reference/java/util/concurrent/ArrayBlockingQueue)\<E\> | A bounded [blocking queue](https://developer.android.com/reference/java/util/concurrent/BlockingQueue) backed by an array. | | [BlockingDeque](https://developer.android.com/reference/java/util/concurrent/BlockingDeque)\<E\> | A `https://developer.android.com/reference/java/util/Deque` 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://developer.android.com/reference/java/util/concurrent/DelayQueue)\<E extends [Delayed](https://developer.android.com/reference/java/util/concurrent/Delayed)\> | An unbounded [blocking queue](https://developer.android.com/reference/java/util/concurrent/BlockingQueue) of `https://developer.android.com/reference/java/util/concurrent/Delayed` elements, in which an element generally becomes eligible for removal when its delay has expired. | | [LinkedBlockingDeque](https://developer.android.com/reference/java/util/concurrent/LinkedBlockingDeque)\<E\> | An optionally-bounded [blocking deque](https://developer.android.com/reference/java/util/concurrent/BlockingDeque) based on linked nodes. | | [LinkedBlockingQueue](https://developer.android.com/reference/java/util/concurrent/LinkedBlockingQueue)\<E\> | An optionally-bounded [blocking queue](https://developer.android.com/reference/java/util/concurrent/BlockingQueue) based on linked nodes. | | [LinkedTransferQueue](https://developer.android.com/reference/java/util/concurrent/LinkedTransferQueue)\<E\> | An unbounded `https://developer.android.com/reference/java/util/concurrent/TransferQueue` based on linked nodes. | | [PriorityBlockingQueue](https://developer.android.com/reference/java/util/concurrent/PriorityBlockingQueue)\<E\> | An unbounded [blocking queue](https://developer.android.com/reference/java/util/concurrent/BlockingQueue) that uses the same ordering rules as class `https://developer.android.com/reference/java/util/PriorityQueue` and supplies blocking retrieval operations. | | [SynchronousQueue](https://developer.android.com/reference/java/util/concurrent/SynchronousQueue)\<E\> | A [blocking queue](https://developer.android.com/reference/java/util/concurrent/BlockingQueue) in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa. | | [TransferQueue](https://developer.android.com/reference/java/util/concurrent/TransferQueue)\<E\> | A `https://developer.android.com/reference/java/util/concurrent/BlockingQueue` in which producers may wait for consumers to receive elements. | |

<br />

*** ** * ** ***

A `https://developer.android.com/reference/java/util/Queue` 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 |
[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://developer.android.com/reference/java/util/Collection` 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://developer.android.com/reference/java/util/concurrent/package-summary#MemoryVisibility)
actions subsequent to the access or removal of that element from
the `BlockingQueue` in another thread.

This interface is a member of the
[Java Collections Framework](https://reference/java/util/package-summary.html#CollectionsFramework).

## Summary

| ### Public methods ||
|---|---|
| ` abstract boolean` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#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` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#contains(java.lang.Object)(https://developer.android.com/reference/java/lang/Object o) ` Returns `true` if this queue contains the specified element. |
| ` abstract int` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#drainTo(java.util.Collection<?%20super%20E>)(https://developer.android.com/reference/java/util/Collection<? super E> c) ` Removes all available elements from this queue and adds them to the given collection. |
| ` abstract int` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#drainTo(java.util.Collection<?%20super%20E>,%20int)(https://developer.android.com/reference/java/util/Collection<? 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` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#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` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#offer(E,%20long,%20java.util.concurrent.TimeUnit)(E e, long timeout, https://developer.android.com/reference/java/util/concurrent/TimeUnit unit) ` Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available. |
| ` abstract E` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#poll(long,%20java.util.concurrent.TimeUnit)(long timeout, https://developer.android.com/reference/java/util/concurrent/TimeUnit 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` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#put(E)(E e) ` Inserts the specified element into this queue, waiting if necessary for space to become available. |
| ` abstract int` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#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` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#remove(java.lang.Object)(https://developer.android.com/reference/java/lang/Object o) ` Removes a single instance of the specified element from this queue, if it is present. |
| ` abstract E` | ` https://developer.android.com/reference/java/util/concurrent/BlockingQueue#take()() ` Retrieves and removes the head of this queue, waiting if necessary until an element becomes available. |

| ### Inherited methods |
|---|---|
| From interface ` https://developer.android.com/reference/java/util/Queue ` |---|---| | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Queue#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` | ` https://developer.android.com/reference/java/util/Queue#element()() ` Retrieves, but does not remove, the head of this queue. | | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Queue#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` | ` https://developer.android.com/reference/java/util/Queue#peek()() ` Retrieves, but does not remove, the head of this queue, or returns `null` if this queue is empty. | | ` abstract E` | ` https://developer.android.com/reference/java/util/Queue#poll()() ` Retrieves and removes the head of this queue, or returns `null` if this queue is empty. | | ` abstract E` | ` https://developer.android.com/reference/java/util/Queue#remove()() ` Retrieves and removes the head of this queue. | ||
| From interface ` https://developer.android.com/reference/java/util/Collection ` |---|---| | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Collection#add(E)(E e) ` Ensures that this collection contains the specified element (optional operation). | | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Collection#addAll(java.util.Collection<?%20extends%20E>)(https://developer.android.com/reference/java/util/Collection<? extends E> c) ` Adds all of the elements in the specified collection to this collection (optional operation). | | ` abstract void` | ` https://developer.android.com/reference/java/util/Collection#clear()() ` Removes all of the elements from this collection (optional operation). | | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Collection#contains(java.lang.Object)(https://developer.android.com/reference/java/lang/Object o) ` Returns `true` if this collection contains the specified element. | | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Collection#containsAll(java.util.Collection<?>)(https://developer.android.com/reference/java/util/Collection<?> c) ` Returns `true` if this collection contains all of the elements in the specified collection. | | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Collection#equals(java.lang.Object)(https://developer.android.com/reference/java/lang/Object o) ` Compares the specified object with this collection for equality. | | ` abstract int` | ` https://developer.android.com/reference/java/util/Collection#hashCode()() ` Returns the hash code value for this collection. | | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Collection#isEmpty()() ` Returns `true` if this collection contains no elements. | | ` abstract https://developer.android.com/reference/java/util/Iterator<E>` | ` https://developer.android.com/reference/java/util/Collection#iterator()() ` Returns an iterator over the elements in this collection. | | ` default https://developer.android.com/reference/java/util/stream/Stream<E>` | ` https://developer.android.com/reference/java/util/Collection#parallelStream()() ` Returns a possibly parallel `Stream` with this collection as its source. | | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Collection#remove(java.lang.Object)(https://developer.android.com/reference/java/lang/Object o) ` Removes a single instance of the specified element from this collection, if it is present (optional operation). | | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Collection#removeAll(java.util.Collection<?>)(https://developer.android.com/reference/java/util/Collection<?> c) ` Removes all of this collection's elements that are also contained in the specified collection (optional operation). | | ` default boolean` | ` https://developer.android.com/reference/java/util/Collection#removeIf(java.util.function.Predicate<?%20super%20E>)(https://developer.android.com/reference/java/util/function/Predicate<? super E> filter) ` Removes all of the elements of this collection that satisfy the given predicate (optional operation). | | ` abstract boolean` | ` https://developer.android.com/reference/java/util/Collection#retainAll(java.util.Collection<?>)(https://developer.android.com/reference/java/util/Collection<?> c) ` Retains only the elements in this collection that are contained in the specified collection (optional operation). | | ` abstract int` | ` https://developer.android.com/reference/java/util/Collection#size()() ` Returns the number of elements in this collection. | | ` default https://developer.android.com/reference/java/util/Spliterator<E>` | ` https://developer.android.com/reference/java/util/Collection#spliterator()() ` Creates a `https://developer.android.com/reference/java/util/Spliterator` over the elements in this collection. | | ` default https://developer.android.com/reference/java/util/stream/Stream<E>` | ` https://developer.android.com/reference/java/util/Collection#stream()() ` Returns a sequential `Stream` with this collection as its source. | | ` abstract <T> T[]` | ` https://developer.android.com/reference/java/util/Collection#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 https://developer.android.com/reference/java/lang/Object` | ` https://developer.android.com/reference/java/util/Collection#toArray()() ` Returns an array containing all of the elements in this collection. | | ` default <T> T[]` | ` https://developer.android.com/reference/java/util/Collection#toArray(java.util.function.IntFunction<T[]>)(https://developer.android.com/reference/java/util/function/IntFunction<T[]> generator) ` Returns an array containing all of the elements in this collection, using the provided `generator` function to allocate the returned array. | ||
| From interface ` https://developer.android.com/reference/java/lang/Iterable ` |---|---| | ` default void` | ` https://developer.android.com/reference/java/lang/Iterable#forEach(java.util.function.Consumer<?%20super%20T>)(https://developer.android.com/reference/java/util/function/Consumer<? 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 https://developer.android.com/reference/java/util/Iterator<E>` | ` https://developer.android.com/reference/java/lang/Iterable#iterator()() ` Returns an iterator over elements of type `T`. | | ` default https://developer.android.com/reference/java/util/Spliterator<E>` | ` https://developer.android.com/reference/java/lang/Iterable#spliterator()() ` Creates a `https://developer.android.com/reference/java/util/Spliterator` over the elements described by this `Iterable`. | ||

## Public methods

### add

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
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://developer.android.com/reference/java/util/concurrent/BlockingQueue#offer(E)`.

<br />

| Parameters ||
|---|---|
| `e` | `E`: the element to add <br /> |

| Returns ||
|---|---|
| `boolean` | `true` (as specified by `https://developer.android.com/reference/java/util/Collection#add(E)`) <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/ClassCastException` | if the class of the specified element prevents it from being added to this queue |
| `https://developer.android.com/reference/java/lang/IllegalArgumentException` | if some property of the specified element prevents it from being added to this queue |
| `https://developer.android.com/reference/java/lang/IllegalStateException` | if the element cannot be added at this time due to capacity restrictions |
| `https://developer.android.com/reference/java/lang/NullPointerException` | if the specified element is null |

### contains

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
public abstract boolean contains (Object 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)`.

<br />

| Parameters ||
|---|---|
| `o` | `Object`: object to be checked for containment in this queue <br /> |

| Returns ||
|---|---|
| `boolean` | `true` if this queue contains the specified element <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/ClassCastException` | if the class of the specified element is incompatible with this queue ([optional](https://reference/java/util/Collection.html#optional-restrictions)) |
| `https://developer.android.com/reference/java/lang/NullPointerException` | if the specified element is null ([optional](https://reference/java/util/Collection.html#optional-restrictions)) |

### drainTo

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
public abstract int drainTo (Collection<? 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.

<br />

| Parameters ||
|---|---|
| `c` | `Collection`: the collection to transfer elements into <br /> |

| Returns ||
|---|---|
| `int` | the number of elements transferred <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/ClassCastException` | if the class of an element of this queue prevents it from being added to the specified collection |
| `https://developer.android.com/reference/java/lang/IllegalArgumentException` | 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 |
| `https://developer.android.com/reference/java/lang/NullPointerException` | if the specified collection is null |
| `https://developer.android.com/reference/java/lang/UnsupportedOperationException` | if addition of elements is not supported by the specified collection |

### drainTo

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
public abstract int drainTo (Collection<? 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.

<br />

| Parameters ||
|---|---|
| `c` | `Collection`: the collection to transfer elements into <br /> |
| `maxElements` | `int`: the maximum number of elements to transfer <br /> |

| Returns ||
|---|---|
| `int` | the number of elements transferred <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/ClassCastException` | if the class of an element of this queue prevents it from being added to the specified collection |
| `https://developer.android.com/reference/java/lang/IllegalArgumentException` | 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 |
| `https://developer.android.com/reference/java/lang/NullPointerException` | if the specified collection is null |
| `https://developer.android.com/reference/java/lang/UnsupportedOperationException` | if addition of elements is not supported by the specified collection |

### offer

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
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://developer.android.com/reference/java/util/concurrent/BlockingQueue#add(E)`, which can fail to insert an
element only by throwing an exception.

<br />

| Parameters ||
|---|---|
| `e` | `E`: the element to add <br /> |

| Returns ||
|---|---|
| `boolean` | `true` if the element was added to this queue, else `false` <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/ClassCastException` | if the class of the specified element prevents it from being added to this queue |
| `https://developer.android.com/reference/java/lang/IllegalArgumentException` | if some property of the specified element prevents it from being added to this queue |
| `https://developer.android.com/reference/java/lang/NullPointerException` | if the specified element is null |

### offer

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
public abstract boolean offer (E e, 
                long timeout, 
                TimeUnit unit)
```

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

<br />

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

| Returns ||
|---|---|
| `boolean` | `true` if successful, or `false` if the specified waiting time elapses before space is available <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/ClassCastException` | if the class of the specified element prevents it from being added to this queue |
| `https://developer.android.com/reference/java/lang/IllegalArgumentException` | if some property of the specified element prevents it from being added to this queue |
| `https://developer.android.com/reference/java/lang/InterruptedException` | if interrupted while waiting |
| `https://developer.android.com/reference/java/lang/NullPointerException` | if the specified element is null |

### poll

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
public abstract E poll (long timeout, 
                TimeUnit unit)
```

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

<br />

| Parameters ||
|---|---|
| `timeout` | `long`: how long to wait before giving up, in units of `unit` <br /> |
| `unit` | `TimeUnit`: a `TimeUnit` determining how to interpret the `timeout` parameter <br /> |

| Returns ||
|---|---|
| `E` | the head of this queue, or `null` if the specified waiting time elapses before an element is available <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/InterruptedException` | if interrupted while waiting |

### put

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
public abstract void put (E e)
```

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

<br />

| Parameters ||
|---|---|
| `e` | `E`: the element to add <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/ClassCastException` | if the class of the specified element prevents it from being added to this queue |
| `https://developer.android.com/reference/java/lang/IllegalArgumentException` | if some property of the specified element prevents it from being added to this queue |
| `https://developer.android.com/reference/java/lang/InterruptedException` | if interrupted while waiting |
| `https://developer.android.com/reference/java/lang/NullPointerException` | if the specified element is null |

### remainingCapacity

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
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.

<br />

| Returns ||
|---|---|
| `int` | the remaining capacity <br /> |

### remove

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
public abstract boolean remove (Object 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).

<br />

| Parameters ||
|---|---|
| `o` | `Object`: element to be removed from this queue, if present <br /> |

| Returns ||
|---|---|
| `boolean` | `true` if this queue changed as a result of the call <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/ClassCastException` | if the class of the specified element is incompatible with this queue ([optional](https://reference/java/util/Collection.html#optional-restrictions)) |
| `https://developer.android.com/reference/java/lang/NullPointerException` | if the specified element is null ([optional](https://reference/java/util/Collection.html#optional-restrictions)) |

### take

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
public abstract E take ()
```

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

<br />

| Returns ||
|---|---|
| `E` | the head of this queue <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/InterruptedException` | if interrupted while waiting |