Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JavaTM 2 Platform Standard Ed. 5.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.util.concurrent
Interface BlockingQueue<E>

Type Parameters:
  `E` - the type of elements held in this collection

All Superinterfaces:
  Collection<E>, Iterable<E>, Queue<E>

All Known Implementing Classes:
  ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue

    public interface BlockingQueue<E>

extends Queue<E>

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

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 `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();
       }
     }

This interface is a member of the Java Collections Framework.

Since:
  1.5

Method Summary
`boolean` | `add(E o)` Adds the specified element to this queue if it is possible to do so immediately, returning `true` upon success, else throwing an IllegalStateException.
`int` | `drainTo(Collection<? super E> c)` Removes all available elements from this queue and adds them into the given collection.
`int` | `drainTo(Collection<? super E> c, int maxElements)` Removes at most the given number of available elements from this queue and adds them into the given collection.
`boolean` | `offer(E o)` Inserts the specified element into this queue, if possible.
`boolean` | `offer(E o, long timeout, TimeUnit unit)` Inserts the specified element into this queue, waiting if necessary up to the specified wait time for space to become available.
`E` | `poll(long timeout, TimeUnit unit)` Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time if no elements are present on this queue.
`void` | `put(E o)` Adds the specified element to this queue, waiting if necessary for space to become available.
`int` | `remainingCapacity()` Returns the number of 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.
`E` | `take()` Retrieves and removes the head of this queue, waiting if no elements are present on this queue.

Methods inherited from interface java.util.Queue
`element, peek, poll, remove`

Methods inherited from interface java.util.Collection
`addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray`

Method Detail

### offer

    boolean offer(E o)

  Inserts the specified element into this queue, if possible. When using queues that may impose insertion restrictions (for example capacity bounds), method `offer` is generally preferable to method `Collection.add(E)`, which can fail to insert an element only by throwing an exception.

  Specified by:
    `offer` in interface `Queue<E>`
  Parameters:
    `o` - the element to add.
  Returns:
    `true` if it was possible to add the element to this queue, else `false`
  Throws:
    `NullPointerException` - if the specified element is `null`

### offer

    boolean offer(E o,
                  long timeout,
                  TimeUnit unit)
                  throws InterruptedException

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

  Parameters:
    `o` - 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` - if interrupted while waiting.
    `NullPointerException` - if the specified element is `null`.

### poll

    E poll(long timeout,
           TimeUnit unit)
           throws InterruptedException

  Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time if no elements are present on this queue.

  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 present.
  Throws:
    `InterruptedException` - if interrupted while waiting.

### take

    E take()
           throws InterruptedException

  Retrieves and removes the head of this queue, waiting if no elements are present on this queue.

  Returns:
    the head of this queue
  Throws:
    `InterruptedException` - if interrupted while waiting.

### put

    void put(E o)
             throws InterruptedException

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

  Parameters:
    `o` - the element to add
  Throws:
    `InterruptedException` - if interrupted while waiting.
    `NullPointerException` - if the specified element is `null`.

### remainingCapacity

    int remainingCapacity()

  Returns the number of 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 `add` an element will succeed by inspecting `remainingCapacity` because it may be the case that another thread is about to `put` or `take` an element.

  Returns:
    the remaining capacity

### add

    boolean add(E o)

  Adds the specified element to this queue if it is possible to do so immediately, returning `true` upon success, else throwing an IllegalStateException.

  Specified by:
    `add` in interface `Collection<E>`
  Parameters:
    `o` - the element
  Returns:
    `true` (as per the general contract of `Collection.add`).
  Throws:
    `NullPointerException` - if the specified element is `null`
    `IllegalStateException` - if element cannot be added

### drainTo

    int drainTo(Collection<? super E> c)

  Removes all available elements from this queue and adds them into 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:
    `NullPointerException` - if c is null
    `IllegalArgumentException` - if c is this queue

### drainTo

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

  Removes at most the given number of available elements from this queue and adds them into 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:
    `NullPointerException` - if c is null
    `IllegalArgumentException` - if c is this queue

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JavaTM 2 Platform Standard Ed. 5.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Submit a bug or feature
For further API reference and developer documentation, see Java 2 SDK SE Developer Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

Copyright 2004 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.