java.lang.Object | |||
↳ | java.util.AbstractCollection<E> | ||
↳ | java.util.AbstractQueue<E> | ||
↳ | java.util.concurrent.LinkedTransferQueue<E> |
An unbounded TransferQueue
based on linked nodes.
This queue orders elements FIFO (first-in-first-out) with respect
to any given producer. The head of the queue is that
element that has been on the queue the longest time for some
producer. The tail of the queue is that element that has
been on the queue the shortest time for some producer.
Beware that, unlike in most collections, the size
method
is NOT a constant-time operation. Because of the
asynchronous nature of these queues, determining the current number
of elements requires a traversal of the elements, and so may report
inaccurate results if this collection is modified during traversal.
Additionally, the bulk operations addAll
,
removeAll
, retainAll
, containsAll
,
equals
, and toArray
are not guaranteed
to be performed atomically. For example, an iterator operating
concurrently with an addAll
operation might view only some
of the added elements.
This class and its iterator implement all of the
optional methods of the Collection
and Iterator
interfaces.
Memory consistency effects: As with other concurrent
collections, actions in a thread prior to placing an object into a
LinkedTransferQueue
happen-before
actions subsequent to the access or removal of that element from
the LinkedTransferQueue
in another thread.
Public Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Creates an initially empty
LinkedTransferQueue .
| |||||||||||
Creates a
LinkedTransferQueue
initially containing the elements of the given collection,
added in traversal order of the collection's iterator.
|
Public Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Inserts the specified element at the tail of 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
true if this queue contains no elements.
| |||||||||||
Returns an iterator over the elements in this queue in proper sequence.
| |||||||||||
Inserts the specified element at the tail of this queue.
| |||||||||||
Inserts the specified element at the tail of this queue.
| |||||||||||
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.
| |||||||||||
Always returns
Integer.MAX_VALUE because a
LinkedTransferQueue is not capacity constrained.
| |||||||||||
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.
| |||||||||||
Transfers the element to a consumer, waiting if necessary to do so.
| |||||||||||
Transfers the element to a waiting consumer immediately, if possible.
| |||||||||||
Transfers the element to a consumer if it is possible to do so
before the timeout elapses.
|
[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
| |||||||||||
From interface
java.util.concurrent.TransferQueue
|
Creates a LinkedTransferQueue
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 |
---|
Inserts the specified element at the tail of this queue.
As the queue is unbounded, this method will never throw
IllegalStateException
or return false
.
e | the element to add |
---|
true
(as specified by add(E)
)NullPointerException | if the specified element is null |
---|
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 estimate of the number of consumers waiting to
receive elements via take()
or timed
poll
. The return value is an
approximation of a momentary state of affairs, that may be
inaccurate if consumers have completed or given up waiting.
The value may be useful for monitoring and heuristics, but
not for synchronization control. Implementations of this
method are likely to be noticeably slower than those for
hasWaitingConsumer()
.
Returns true
if this queue contains no elements.
true
if this queue contains no elements
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.
As the queue is unbounded, this method will never return false
.
e | the element to add |
---|
true
(as specified by offer(E)
)NullPointerException | if the specified element is null |
---|
Inserts the specified element at the tail of this queue.
As the queue is unbounded, this method will never block or
return false
.
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
(as specified by
BlockingQueue.offer
)NullPointerException | if the specified element is null |
---|
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.
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. As the queue is unbounded, this method will never block.
e | the element to add |
---|
NullPointerException | if the specified element is null |
---|
Always returns Integer.MAX_VALUE
because a
LinkedTransferQueue
is not capacity constrained.
Integer.MAX_VALUE
(as specified by
BlockingQueue.remainingCapacity
)
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. If this queue
contains more than Integer.MAX_VALUE
elements, returns
Integer.MAX_VALUE
.
Beware that, unlike in most collections, this method is NOT a constant-time operation. Because of the asynchronous nature of these queues, determining the current number of elements requires an O(n) traversal.
Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.
InterruptedException |
---|
Transfers the element to a consumer, waiting if necessary to do so.
More precisely, transfers the specified element immediately
if there exists a consumer already waiting to receive it (in
take()
or timed poll
),
else inserts the specified element at the tail of this queue
and waits until the element is received by a consumer.
e | the element to transfer |
---|
NullPointerException | if the specified element is null |
---|---|
InterruptedException |
Transfers the element to a waiting consumer immediately, if possible.
More precisely, transfers the specified element immediately
if there exists a consumer already waiting to receive it (in
take()
or timed poll
),
otherwise returning false
without enqueuing the element.
e | the element to transfer |
---|
true
if the element was transferred, else
false
NullPointerException | if the specified element is null |
---|
Transfers the element to a consumer if it is possible to do so before the timeout elapses.
More precisely, transfers the specified element immediately
if there exists a consumer already waiting to receive it (in
take()
or timed poll
),
else inserts the specified element at the tail of this queue
and waits until the element is received by a consumer,
returning false
if the specified wait time elapses
before the element can be transferred.
e | the element to transfer |
---|---|
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 completion,
in which case the element is not left enqueuedNullPointerException | if the specified element is null |
---|---|
InterruptedException |