java.lang.Object | |||
↳ | java.util.AbstractCollection<E> | ||
↳ | java.util.AbstractQueue<E> | ||
↳ | java.util.concurrent.LinkedBlockingQueue<E> |
An optionally-bounded blocking queue
based on
linked nodes.
This queue orders elements FIFO (first-in-first-out).
The head of the queue is that element that has been on the
queue the longest time.
The tail of the queue is that element that has been on the
queue the shortest time. New elements
are inserted at the tail of the queue, and the queue retrieval
operations obtain elements at the head of the queue.
Linked queues typically have higher throughput than array-based queues but
less predictable performance in most concurrent applications.
The optional capacity bound constructor argument serves as a
way to prevent excessive queue expansion. The capacity, if unspecified,
is equal to MAX_VALUE
. Linked nodes are
dynamically created upon each insertion unless this would bring the
queue above capacity.
This class and its iterator implement all of the
optional methods of the Collection
and Iterator
interfaces.
Public Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Creates a
LinkedBlockingQueue with a capacity of
MAX_VALUE . | |||||||||||
Creates a
LinkedBlockingQueue with the given (fixed) capacity. | |||||||||||
Creates a
LinkedBlockingQueue with a capacity of
MAX_VALUE , initially containing the elements of the
given collection,
added in traversal order of the collection's iterator. |
Public Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Atomically removes all of the elements from this queue.
| |||||||||||
Returns
true if this queue contains the specified element. | |||||||||||
Removes at most the given number of available elements from
this queue and adds them to the given collection.
| |||||||||||
Removes all available elements from this queue and adds them
to the given collection.
| |||||||||||
Returns an iterator over the elements in this queue in proper sequence.
| |||||||||||
Inserts the specified element at the tail of this queue if it is
possible to do so immediately without exceeding the queue's capacity,
returning
true upon success and false if this queue
is full. | |||||||||||
Inserts the specified element at the tail of this queue, waiting if
necessary up to the specified wait time for space to become available.
| |||||||||||
Retrieves, but does not remove, the head of this queue,
or returns null if this queue is empty.
| |||||||||||
Retrieves and removes the head of this queue,
or returns null if this queue is empty.
| |||||||||||
Retrieves and removes the head of this queue, waiting up to the
specified wait time if necessary for an element to become available.
| |||||||||||
Inserts the specified element at the tail of this queue, waiting if
necessary for space to become available.
| |||||||||||
Returns the number of additional elements that this queue can ideally
(in the absence of memory or resource constraints) accept without
blocking.
| |||||||||||
Removes a single instance of the specified element from this queue,
if it is present.
| |||||||||||
Returns the number of elements in this queue.
| |||||||||||
Retrieves and removes the head of this queue, waiting if necessary
until an element becomes available.
| |||||||||||
Returns an array containing all of the elements in this queue, in
proper sequence; the runtime type of the returned array is that of
the specified array.
| |||||||||||
Returns an array containing all of the elements in this queue, in
proper sequence.
| |||||||||||
Returns the string representation of this
Collection . |
[Expand]
Inherited Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
java.util.AbstractQueue
| |||||||||||
From class
java.util.AbstractCollection
| |||||||||||
From class
java.lang.Object
| |||||||||||
From interface
java.lang.Iterable
| |||||||||||
From interface
java.util.Collection
| |||||||||||
From interface
java.util.Queue
| |||||||||||
From interface
java.util.concurrent.BlockingQueue
|
Creates a LinkedBlockingQueue
with a capacity of
MAX_VALUE
.
Creates a LinkedBlockingQueue
with the given (fixed) capacity.
capacity | the capacity of this queue |
---|
IllegalArgumentException | if capacity is not greater
than zero
|
---|
Creates a LinkedBlockingQueue
with a capacity of
MAX_VALUE
, initially containing the elements of the
given collection,
added in traversal order of the collection's iterator.
c | the collection of elements to initially contain |
---|
NullPointerException | if the specified collection or any of its elements are null |
---|
Atomically removes all of the elements from this queue. The queue will be empty after this call returns.
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)
.
o | object to be checked for containment in this queue |
---|
true
if this queue contains the specified element
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.
c | the collection to transfer elements into |
---|---|
maxElements | the maximum number of elements to transfer |
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.
c | the collection to transfer elements into |
---|
Returns an iterator over the elements in this queue 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.
Inserts the specified element at the tail of this queue if it is
possible to do so immediately without exceeding the queue's capacity,
returning true
upon success and false
if this queue
is full.
When using a capacity-restricted queue, this method is generally
preferable to method add
, which can fail to
insert an element only by throwing an exception.
e | the element to add |
---|
true
if the element was added to this queue, else
false
NullPointerException | if the specified element is null |
---|
Inserts the specified element at the tail of this queue, waiting if necessary up to the specified wait time for space to become available.
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 |
true
if successful, or false
if
the specified waiting time elapses before space is availableRetrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
Retrieves and removes the head of this queue, or returns null if this queue is empty.
Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an element to become available.
timeout | how long to wait before giving up, in units of
unit |
---|---|
unit | a TimeUnit determining how to interpret the
timeout parameter |
null
if the
specified waiting time elapses before an element is availableInterruptedException |
---|
Inserts the specified element at the tail of this queue, waiting if necessary for space to become available.
e | the element to add |
---|
Returns the number of additional elements that this queue can ideally
(in the absence of memory or resource constraints) accept without
blocking. This is always equal to the initial capacity of this queue
less the current size
of this queue.
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.
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).
o | element to be removed from this queue, if present |
---|
true
if this queue changed as a result of the call
Returns the number of elements in this queue.
Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.
InterruptedException |
---|
Returns an array containing all of the elements in this queue, in proper sequence; the runtime type of the returned array is that of the specified array. If the queue 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 queue.
If this queue fits in the specified array with room to spare
(i.e., the array has more elements than this queue), the element in
the array immediately following the end of the queue 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 queue known to contain only strings.
The following code can be used to dump the queue 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()
.a | the array into which the elements of the queue are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose |
---|
ArrayStoreException | if the runtime type of the specified array is not a supertype of the runtime type of every element in this queue |
---|---|
NullPointerException | if the specified array is null |
Returns an array containing all of the elements in this queue, in proper sequence.
The returned array will be "safe" in that no references to it are maintained by this queue. (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.
Returns the string representation of this Collection
. The presentation
has a specific format. It is enclosed by square brackets ("[]"). Elements
are separated by ', ' (comma and space).
Collection
.