java.util.concurrent

Class LinkedBlockingDeque<E>

Implemented Interfaces:
BlockingDeque<E>, BlockingQueue<E>, Collection<E>, Deque<E>, Iterable<E>, Queue<E>, Serializable

public class LinkedBlockingDeque<E>
extends AbstractQueue<E>
implements BlockingDeque<E>, Serializable

An optionally-bounded blocking deque based on linked nodes.

The optional capacity bound constructor argument serves as a way to prevent excessive expansion. The capacity, if unspecified, is equal to Integer.MAX_VALUE. Linked nodes are dynamically created upon each insertion unless this would bring the deque above capacity.

Most operations run in constant time (ignoring time spent blocking). Exceptions include remove, removeFirstOccurrence, removeLastOccurrence, contains, iterator.remove(), and the bulk operations, all of which run in linear time.

This class and its iterator implement all of the optional methods of the Collection and Iterator interfaces.

This class is a member of the ../../../../technotes/guides/collections/index.html"> Java Collections Framework.

Since:
1.6
See Also:
Serialized Form

Constructor Summary

LinkedBlockingDeque()
Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE.
LinkedBlockingDeque(E> c)
Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE, initially containing the elements of the given collection, added in traversal order of the collection's iterator.
LinkedBlockingDeque(int capacity)
Creates a LinkedBlockingDeque with the given (fixed) capacity.

Method Summary

T[] toArray(T[] a)
Returns an array containing all of the elements in this deque, in proper sequence; the runtime type of the returned array is that of the specified array.
boolean
add(E e)
Inserts the specified element at the end of this deque unless it would violate capacity restrictions.
void
addFirst(E e)
void
addLast(E e)
void
clear()
Atomically removes all of the elements from this deque.
boolean
contains(Object o)
Returns true if this deque contains the specified element.
Iterator
descendingIterator()
Returns an iterator over the elements in this deque in reverse sequential order.
int
drainTo(E> c)
int
drainTo(E> c, int maxElements)
E
element()
Retrieves, but does not remove, the head of the queue represented by this deque.
E
getFirst()
E
getLast()
Iterator
iterator()
Returns an iterator over the elements in this deque in proper sequence.
boolean
offer(E e)
boolean
offer(E e, long timeout, TimeUnit unit)
boolean
offerFirst(E e)
boolean
offerFirst(E e, long timeout, TimeUnit unit)
boolean
offerLast(E e)
boolean
offerLast(E e, long timeout, TimeUnit unit)
E
peek()
Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque), or returns null if this deque is empty.
E
peekFirst()
Retrieves, but does not remove, the first element of this deque, or returns null if this deque is empty.
E
peekLast()
Retrieves, but does not remove, the last element of this deque, or returns null if this deque is empty.
E
poll()
Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), or returns null if this deque is empty.
E
poll(long timeout, TimeUnit unit)
E
pollFirst()
Retrieves and removes the first element of this deque, or returns null if this deque is empty.
E
pollFirst(long timeout, TimeUnit unit)
E
pollLast()
Retrieves and removes the last element of this deque, or returns null if this deque is empty.
E
pollLast(long timeout, TimeUnit unit)
E
pop()
void
push(E e)
void
put(E e)
void
putFirst(E e)
void
putLast(E e)
int
remainingCapacity()
Returns the number of additional elements that this deque can ideally (in the absence of memory or resource constraints) accept without blocking.
E
remove()
Retrieves and removes the head of the queue represented by this deque.
boolean
remove(Object o)
Removes the first occurrence of the specified element from this deque.
E
removeFirst()
boolean
removeFirstOccurrence(Object o)
Removes the first occurrence of the specified element from this deque.
E
removeLast()
boolean
removeLastOccurrence(Object o)
Removes the last occurrence of the specified element from this deque.
int
size()
Returns the number of elements in this deque.
E
take()
E
takeFirst()
E
takeLast()
Object[]
toArray()
Returns an array containing all of the elements in this deque, in proper sequence (from first to last element).
String
toString()

Methods inherited from class java.util.AbstractQueue<E>

add, addAll, clear, element, remove

Methods inherited from class java.util.AbstractCollection<E>

T[] toArray, add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toString

Methods inherited from class java.lang.Object

clone, equals, extends Object> getClass, finalize, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

LinkedBlockingDeque

public LinkedBlockingDeque()
Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE.

LinkedBlockingDeque

public LinkedBlockingDeque(E> c)
Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE, initially containing the elements of the given collection, added in traversal order of the collection's iterator.
Parameters:
c - the collection of elements to initially contain
Throws:
NullPointerException - if the specified collection or any of its elements are null

LinkedBlockingDeque

public LinkedBlockingDeque(int capacity)
Creates a LinkedBlockingDeque with the given (fixed) capacity.
Parameters:
capacity - the capacity of this deque
Throws:
IllegalArgumentException - if capacity is less than 1

Method Details

T[] toArray

public  T[] toArray(T[] a)
Returns an array containing all of the elements in this deque, in proper sequence; the runtime type of the returned array is that of the specified array. If the deque fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this deque.

If this deque fits in the specified array with room to spare (i.e., the array has more elements than this deque), the element in the array immediately following the end of the deque is set to null.

Like the toArray() method, this method acts as bridge between array-based and collection-based APIs. Further, this method allows precise control over the runtime type of the output array, and may, under certain circumstances, be used to save allocation costs.

Suppose x is a deque known to contain only strings. The following code can be used to dump the deque into a newly allocated array of String:

     String[] y = x.toArray(new String[0]);
Note that toArray(new Object[0]) is identical in function to toArray().
Specified by:
T[] toArray in interface Collection<E>
Overrides:
T[] toArray in interface AbstractCollection<E>
Parameters:
a - the array into which the elements of the deque are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose
Returns:
an array containing all of the elements in this deque
Throws:
ArrayStoreException - if the runtime type of the specified array is not a supertype of the runtime type of every element in this deque
NullPointerException - if the specified array is null

add

public boolean add(E e)
Inserts the specified element at the end of this deque unless it would violate capacity restrictions. When using a capacity-restricted deque, it is generally preferable to use method offer.

This method is equivalent to addLast(E).

Specified by:
add in interface BlockingDeque<E>
add in interface BlockingQueue<E>
add in interface Queue<E>
add in interface Collection<E>
add in interface Deque<E>
Overrides:
add in interface AbstractQueue<E>
Throws:
IllegalStateException - if the element cannot be added at this time due to capacity restrictions
NullPointerException - if the specified element is null

addFirst

public void addFirst(E e)
Specified by:
addFirst in interface BlockingDeque<E>
addFirst in interface Deque<E>

addLast

public void addLast(E e)
Specified by:
addLast in interface BlockingDeque<E>
addLast in interface Deque<E>

clear

public void clear()
Atomically removes all of the elements from this deque. The deque will be empty after this call returns.
Specified by:
clear in interface Collection<E>
Overrides:
clear in interface AbstractQueue<E>

contains

public boolean contains(Object o)
Returns true if this deque contains the specified element. More formally, returns true if and only if this deque contains at least one element e such that o.equals(e).
Specified by:
contains in interface BlockingDeque<E>
contains in interface BlockingQueue<E>
contains in interface Collection<E>
contains in interface Deque<E>
Overrides:
contains in interface AbstractCollection<E>
Parameters:
o - object to be checked for containment in this deque
Returns:
true if this deque contains the specified element

descendingIterator

public Iterator descendingIterator()
Returns an iterator over the elements in this deque in reverse sequential order. The elements will be returned in order from last (tail) to first (head). The returned Iterator is a "weakly consistent" iterator that will never throw ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
Specified by:
descendingIterator in interface Deque<E>

drainTo

public int drainTo(E> c)
Specified by:
drainTo in interface BlockingQueue<E>

drainTo

public int drainTo(E> c,
                   int maxElements)
Specified by:
drainTo in interface BlockingQueue<E>

element

public E element()
Retrieves, but does not remove, the head of the queue represented by this deque. This method differs from peek only in that it throws an exception if this deque is empty.

This method is equivalent to getFirst.

Specified by:
element in interface BlockingDeque<E>
element in interface Queue<E>
element in interface Deque<E>
Overrides:
element in interface AbstractQueue<E>
Returns:
the head of the queue represented by this deque
Throws:
NoSuchElementException - if this deque is empty

getFirst

public E getFirst()
Specified by:
getFirst in interface Deque<E>

getLast

public E getLast()
Specified by:
getLast in interface Deque<E>

iterator

public Iterator iterator()
Returns an iterator over the elements in this deque in proper sequence. The elements will be returned in order from first (head) to last (tail). The returned Iterator is a "weakly consistent" iterator that will never throw ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
Specified by:
iterator in interface BlockingDeque<E>
iterator in interface Collection<E>
iterator in interface Iterable<E>
iterator in interface Deque<E>
Overrides:
iterator in interface AbstractCollection<E>
Returns:
an iterator over the elements in this deque in proper sequence

offer

public boolean offer(E e)
Specified by:
offer in interface BlockingDeque<E>
offer in interface BlockingQueue<E>
offer in interface Queue<E>
offer in interface Deque<E>
Throws:
NullPointerException - if the specified element is null

offer

public boolean offer(E e,
                     long timeout,
                     TimeUnit unit)
            throws InterruptedException
Specified by:
offer in interface BlockingDeque<E>
offer in interface BlockingQueue<E>

offerFirst

public boolean offerFirst(E e)
Specified by:
offerFirst in interface BlockingDeque<E>
offerFirst in interface Deque<E>

offerFirst

public boolean offerFirst(E e,
                          long timeout,
                          TimeUnit unit)
            throws InterruptedException
Specified by:
offerFirst in interface BlockingDeque<E>

offerLast

public boolean offerLast(E e)
Specified by:
offerLast in interface BlockingDeque<E>
offerLast in interface Deque<E>

offerLast

public boolean offerLast(E e,
                         long timeout,
                         TimeUnit unit)
            throws InterruptedException
Specified by:
offerLast in interface BlockingDeque<E>

peek

public E peek()
Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque), or returns null if this deque is empty.

This method is equivalent to Deque.peekFirst().

Specified by:
peek in interface BlockingDeque<E>
peek in interface Queue<E>
peek in interface Deque<E>
Returns:
the head of the queue represented by this deque, or null if this deque is empty

peekFirst

public E peekFirst()
Retrieves, but does not remove, the first element of this deque, or returns null if this deque is empty.
Specified by:
peekFirst in interface Deque<E>
Returns:
the head of this deque, or null if this deque is empty

peekLast

public E peekLast()
Retrieves, but does not remove, the last element of this deque, or returns null if this deque is empty.
Specified by:
peekLast in interface Deque<E>
Returns:
the tail of this deque, or null if this deque is empty

poll

public E poll()
Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), or returns null if this deque is empty.

This method is equivalent to Deque.pollFirst().

Specified by:
poll in interface BlockingDeque<E>
poll in interface Queue<E>
poll in interface Deque<E>
Returns:
the first element of this deque, or null if this deque is empty

poll

public E poll(long timeout,
              TimeUnit unit)
            throws InterruptedException
Specified by:
poll in interface BlockingDeque<E>
poll in interface BlockingQueue<E>

pollFirst

public E pollFirst()
Retrieves and removes the first element of this deque, or returns null if this deque is empty.
Specified by:
pollFirst in interface Deque<E>
Returns:
the head of this deque, or null if this deque is empty

pollFirst

public E pollFirst(long timeout,
                   TimeUnit unit)
            throws InterruptedException
Specified by:
pollFirst in interface BlockingDeque<E>

pollLast

public E pollLast()
Retrieves and removes the last element of this deque, or returns null if this deque is empty.
Specified by:
pollLast in interface Deque<E>
Returns:
the tail of this deque, or null if this deque is empty

pollLast

public E pollLast(long timeout,
                  TimeUnit unit)
            throws InterruptedException
Specified by:
pollLast in interface BlockingDeque<E>

pop

public E pop()
Specified by:
pop in interface Deque<E>

push

public void push(E e)
Specified by:
push in interface BlockingDeque<E>
push in interface Deque<E>

put

public void put(E e)
            throws InterruptedException
Specified by:
put in interface BlockingDeque<E>
put in interface BlockingQueue<E>

putFirst

public void putFirst(E e)
            throws InterruptedException
Specified by:
putFirst in interface BlockingDeque<E>

putLast

public void putLast(E e)
            throws InterruptedException
Specified by:
putLast in interface BlockingDeque<E>

remainingCapacity

public int remainingCapacity()
Returns the number of additional elements that this deque can ideally (in the absence of memory or resource constraints) accept without blocking. This is always equal to the initial capacity of this deque less the current size of this deque.

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.

Specified by:
remainingCapacity in interface BlockingQueue<E>

remove

public E remove()
Retrieves and removes the head of the queue represented by this deque. This method differs from poll only in that it throws an exception if this deque is empty.

This method is equivalent to removeFirst.

Specified by:
remove in interface BlockingDeque<E>
remove in interface Queue<E>
remove in interface Deque<E>
Overrides:
remove in interface AbstractQueue<E>
Returns:
the head of the queue represented by this deque
Throws:
NoSuchElementException - if this deque is empty

remove

public boolean remove(Object o)
Removes the first occurrence of the specified element from this deque. If the deque does not contain the element, it is unchanged. More formally, removes the first element e such that o.equals(e) (if such an element exists). Returns true if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).

This method is equivalent to removeFirstOccurrence.

Specified by:
remove in interface BlockingDeque<E>
remove in interface BlockingQueue<E>
remove in interface Collection<E>
remove in interface Deque<E>
Overrides:
remove in interface AbstractCollection<E>
Parameters:
o - element to be removed from this deque, if present
Returns:
true if this deque changed as a result of the call

removeFirst

public E removeFirst()
Specified by:
removeFirst in interface Deque<E>

removeFirstOccurrence

public boolean removeFirstOccurrence(Object o)
Removes the first occurrence of the specified element from this deque. If the deque does not contain the element, it is unchanged. More formally, removes the first element e such that (o==null ? e==null : o.equals(e)) (if such an element exists). Returns true if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).
Specified by:
removeFirstOccurrence in interface BlockingDeque<E>
removeFirstOccurrence in interface Deque<E>
Parameters:
o - element to be removed from this deque, if present
Returns:
true if an element was removed as a result of this call
Throws:
ClassCastException - if the class of the specified element is incompatible with this deque (optional)
NullPointerException - if the specified element is null and this deque does not permit null elements (optional)

removeLast

public E removeLast()
Specified by:
removeLast in interface Deque<E>

removeLastOccurrence

public boolean removeLastOccurrence(Object o)
Removes the last occurrence of the specified element from this deque. If the deque does not contain the element, it is unchanged. More formally, removes the last element e such that (o==null ? e==null : o.equals(e)) (if such an element exists). Returns true if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).
Specified by:
removeLastOccurrence in interface BlockingDeque<E>
removeLastOccurrence in interface Deque<E>
Parameters:
o - element to be removed from this deque, if present
Returns:
true if an element was removed as a result of this call
Throws:
ClassCastException - if the class of the specified element is incompatible with this deque (optional)
NullPointerException - if the specified element is null and this deque does not permit null elements (optional)

size

public int size()
Returns the number of elements in this deque.
Specified by:
size in interface BlockingDeque<E>
size in interface Collection<E>
size in interface Deque<E>
Overrides:
size in interface AbstractCollection<E>
Returns:
the number of elements in this deque

take

public E take()
            throws InterruptedException
Specified by:
take in interface BlockingDeque<E>
take in interface BlockingQueue<E>

takeFirst

public E takeFirst()
            throws InterruptedException
Specified by:
takeFirst in interface BlockingDeque<E>

takeLast

public E takeLast()
            throws InterruptedException
Specified by:
takeLast in interface BlockingDeque<E>

toArray

public Object[] toArray()
Returns an array containing all of the elements in this deque, in proper sequence (from first to last element).

The returned array will be "safe" in that no references to it are maintained by this deque. (In other words, this method must allocate a new array). The caller is thus free to modify the returned array.

This method acts as bridge between array-based and collection-based APIs.

Specified by:
toArray in interface Collection<E>
Overrides:
toArray in interface AbstractCollection<E>
Returns:
an array containing all of the elements in this deque

toString

public String toString()
Overrides:
toString in interface AbstractCollection<E>