OpenJDK 1.22 · java.util.concurrent.SynchronousQueue

Modifier and Type	Class and Description
pack-priv static class	SynchronousQueue.FifoWaitQueue
pack-priv static class	SynchronousQueue.LifoWaitQueue
pack-priv static class	SynchronousQueue.Transferer<E> Extension of LinkedTransferQueue to support Lifo (stack) mode.
pack-priv static class	SynchronousQueue.WaitQueue

Modifier and Type	Field and Description
private final transient boolean	fair
private ReentrantLock	qlock
private static final long	serialVersionUID
private final transient SynchronousQueue.Transferer<E>	transferer The transferer.
private SynchronousQueue.WaitQueue	waitingConsumers
private SynchronousQueue.WaitQueue	waitingProducers

Access	Constructor and Description
public	SynchronousQueue() Creates a `SynchronousQueue` with nonfair access policy.
public	SynchronousQueue(boolean if true, waiting threads contend in FIFO order for access; otherwise the order is unspecified. fair) Creates a `SynchronousQueue` with the specified fairness policy.

Method Summary

Modifier and Type	Method and Description
public void	clear() Overrides java.util.AbstractQueue.clear. Implements java.util.Collection.clear. Does nothing.
public boolean	Returns: `false` contains(Object the element o) Overrides java.util.AbstractCollection.contains. Implements java.util.concurrent.BlockingQueue.contains, java.util.Collection.contains. Always returns `false`.
public boolean	Returns: `false` unless given collection is empty containsAll(Collection<?> the collection c) Overrides java.util.AbstractCollection.containsAll. Implements java.util.Collection.containsAll. Returns `false` unless the given collection is empty.
public int	drainTo(Collection<? super E> the collection to transfer elements into c) Implements java.util.concurrent.BlockingQueue.drainTo. Removes all available elements from this queue and adds them to the given collection.
public int	drainTo(Collection<? super E> the collection to transfer elements into c, int the maximum number of elements to transfer maxElements) Implements java.util.concurrent.BlockingQueue.drainTo. Removes at most the given number of available elements from this queue and adds them to the given collection.
public boolean	Returns: `true` isEmpty() Overrides java.util.AbstractCollection.isEmpty. Implements java.util.Collection.isEmpty. Always returns `true`.
public Iterator<E>	Returns: an empty iterator iterator() Implements abstract java.util.AbstractCollection.iterator. Implements java.util.Collection.iterator. Returns an empty iterator in which `hasNext` always returns `false`.
public boolean	Returns: `true` if successful, or `false` if the specified waiting time elapses before a consumer appears offer(E the element to add e, long how long to wait before giving up, in units of `unit` timeout, TimeUnit a `TimeUnit` determining how to interpret the `timeout` parameter unit) Implements java.util.concurrent.BlockingQueue.offer. Inserts the specified element into this queue, waiting if necessary up to the specified wait time for another thread to receive it.
public boolean	Returns: `true` if the element was added to this queue, else `false` offer(E the element to add e) Implements java.util.concurrent.BlockingQueue.offer, java.util.Queue.offer. Inserts the specified element into this queue, if another thread is waiting to receive it.
public E	Returns: `null` peek() Implements java.util.Queue.peek. Always returns `null`.
public E	Returns: the head of this queue, or `null` if the specified waiting time elapses before an element is present poll(long how long to wait before giving up, in units of `unit` timeout, TimeUnit a `TimeUnit` determining how to interpret the `timeout` parameter unit) Implements java.util.concurrent.BlockingQueue.poll. Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time, for another thread to insert it.
public E	Returns: the head of this queue, or `null` if no element is available poll() Implements java.util.Queue.poll. Retrieves and removes the head of this queue, if another thread is currently making an element available.
public void	put(E the element to add e) Implements java.util.concurrent.BlockingQueue.put. Adds the specified element to this queue, waiting if necessary for another thread to receive it.
private Object	readResolve() Replaces a deserialized SynchronousQueue with a fresh one with the associated fairness
public int	Returns: zero remainingCapacity() Implements java.util.concurrent.BlockingQueue.remainingCapacity. Always returns zero.
public boolean	Returns: `false` remove(Object the element to remove o) Overrides java.util.AbstractCollection.remove. Implements java.util.concurrent.BlockingQueue.remove, java.util.Collection.remove. Always returns `false`.
public boolean	Returns: `false` removeAll(Collection<?> the collection c) Overrides java.util.AbstractCollection.removeAll. Implements java.util.Collection.removeAll. Always returns `false`.
public boolean	Returns: `false` retainAll(Collection<?> the collection c) Overrides java.util.AbstractCollection.retainAll. Implements java.util.Collection.retainAll. Always returns `false`.
public int	Returns: zero size() Implements abstract java.util.AbstractCollection.size. Implements java.util.Collection.size. Always returns zero.
public Spliterator<E>	Returns: an empty spliterator spliterator() Overrides default java.util.Collection.spliterator. Returns an empty spliterator in which calls to `trySplit` always return `null`.
public E	Returns: the head of this queue take() Implements java.util.concurrent.BlockingQueue.take. Retrieves and removes the head of this queue, waiting if necessary for another thread to insert it.
public Object[]	Returns: a zero-length array toArray() Overrides java.util.AbstractCollection.toArray. Implements java.util.Collection.toArray. Returns a zero-length array.
public <T> T[]	Returns: the specified array toArray(T[] the array a) Overrides java.util.AbstractCollection.toArray. Implements java.util.Collection.toArray. Sets the zeroth element of the specified array to `null` (if the array has non-zero length) and returns it.
public String	Returns: `"[]"` toString() Overrides java.util.AbstractCollection.toString. Always returns `"[]"`.
private void	writeObject(ObjectOutputStream the stream s) Saves this queue to a stream (that is, serializes it).
private Object	xfer(Object e, long nanos) Invokes fair or lifo transfer

Inherited from java.util.AbstractQueue:: add addAll element remove

fair	back to summary
private final transient boolean fair

qlock	back to summary
private ReentrantLock qlock

serialVersionUID	back to summary
private static final long serialVersionUID

transferer	back to summary
private final transient SynchronousQueue.Transferer<E> transferer The transferer. (See below about serialization.)

waitingConsumers	back to summary
private SynchronousQueue.WaitQueue waitingConsumers

waitingProducers	back to summary
private SynchronousQueue.WaitQueue waitingProducers

SynchronousQueue	back to summary
public SynchronousQueue() Creates a `SynchronousQueue` with nonfair access policy.

SynchronousQueue	back to summary
public SynchronousQueue(boolean fair) Creates a `SynchronousQueue` with the specified fairness policy. Parameters fair:boolean if true, waiting threads contend in FIFO order for access; otherwise the order is unspecified.

Method Detail

clear back to summary

clear	back to summary
public void clear() Overrides java.util.AbstractQueue.clear. Implements java.util.Collection.clear. Does nothing. A `SynchronousQueue` has no internal capacity.

public void clear()

Overrides java.util.AbstractQueue.clear.

Implements java.util.Collection.clear.

Does nothing. A SynchronousQueue has no internal capacity.

contains back to summary

contains	back to summary
public boolean contains(Object o) Overrides java.util.AbstractCollection.contains. Implements java.util.concurrent.BlockingQueue.contains, java.util.Collection.contains. Always returns `false`. A `SynchronousQueue` has no internal capacity. Parameters o:Object the element Returns:boolean `false`

public boolean contains(Object o)

Overrides java.util.AbstractCollection.contains.

Implements java.util.concurrent.BlockingQueue.contains, java.util.Collection.contains.

Always returns false. A SynchronousQueue has no internal capacity.

Parameters

o:Object: the element

Returns:boolean

false

containsAll back to summary

containsAll	back to summary
public boolean containsAll(Collection<?> c) Overrides java.util.AbstractCollection.containsAll. Implements java.util.Collection.containsAll. Returns `false` unless the given collection is empty. A `SynchronousQueue` has no internal capacity. Parameters c:Collection<?> the collection Returns:boolean `false` unless given collection is empty

public boolean containsAll(Collection<?> c)

Overrides java.util.AbstractCollection.containsAll.

Implements java.util.Collection.containsAll.

Returns false unless the given collection is empty. A SynchronousQueue has no internal capacity.

Parameters

c:Collection<?>: the collection

Returns:boolean

false unless given collection is empty

drainTo back to summary

drainTo	back to summary
public int drainTo(Collection<? super E> c) Implements java.util.concurrent.BlockingQueue.drainTo. Doc from java.util.concurrent.BlockingQueue.drainTo. 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. Parameters c:Collection<? super E> the collection to transfer elements into Returns:int the number of elements transferred Exceptions UnsupportedOperationException: if addition of elements is not supported by the specified collection ClassCastException: if the class of an element of this queue prevents it from being added to the specified collection NullPointerException: if the specified collection is null 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

public int drainTo(Collection<? super E> c)

Implements java.util.concurrent.BlockingQueue.drainTo.

Doc from java.util.concurrent.BlockingQueue.drainTo.

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.

Parameters

c:Collection<? super E>: the collection to transfer elements into

Returns:int

the number of elements transferred

Exceptions

UnsupportedOperationException:: if addition of elements is not supported by the specified collection
ClassCastException:: if the class of an element of this queue prevents it from being added to the specified collection
NullPointerException:: if the specified collection is null
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

drainTo back to summary

drainTo	back to summary
public int drainTo(Collection<? super E> c, int maxElements) Implements java.util.concurrent.BlockingQueue.drainTo. Doc from java.util.concurrent.BlockingQueue.drainTo. 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. Parameters c:Collection<? super E> the collection to transfer elements into maxElements:int the maximum number of elements to transfer Returns:int the number of elements transferred Exceptions UnsupportedOperationException: if addition of elements is not supported by the specified collection ClassCastException: if the class of an element of this queue prevents it from being added to the specified collection NullPointerException: if the specified collection is null 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

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

Implements java.util.concurrent.BlockingQueue.drainTo.

Doc from java.util.concurrent.BlockingQueue.drainTo.

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.

Parameters

c:Collection<? super E>: the collection to transfer elements into
maxElements:int: the maximum number of elements to transfer

Returns:int

the number of elements transferred

Exceptions

UnsupportedOperationException:: if addition of elements is not supported by the specified collection
ClassCastException:: if the class of an element of this queue prevents it from being added to the specified collection
NullPointerException:: if the specified collection is null
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

isEmpty back to summary

isEmpty	back to summary
public boolean isEmpty() Overrides java.util.AbstractCollection.isEmpty. Implements java.util.Collection.isEmpty. Always returns `true`. A `SynchronousQueue` has no internal capacity. Returns:boolean `true`

public boolean isEmpty()

Overrides java.util.AbstractCollection.isEmpty.

Implements java.util.Collection.isEmpty.

Always returns true. A SynchronousQueue has no internal capacity.

Returns:boolean: true

iterator back to summary

iterator	back to summary
public Iterator<E> iterator() Implements abstract java.util.AbstractCollection.iterator. Implements java.util.Collection.iterator. Returns an empty iterator in which `hasNext` always returns `false`. Returns:Iterator<E> an empty iterator

public Iterator<E> iterator()

Implements abstract java.util.AbstractCollection.iterator.

Implements java.util.Collection.iterator.

Returns an empty iterator in which hasNext always returns false.

Returns:Iterator<E>: an empty iterator

offer back to summary

offer	back to summary
public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException Implements java.util.concurrent.BlockingQueue.offer. Inserts the specified element into this queue, waiting if necessary up to the specified wait time for another thread to receive it. Parameters e:E Doc from java.util.concurrent.BlockingQueue.offer. the element to add timeout:long Doc from java.util.concurrent.BlockingQueue.offer. how long to wait before giving up, in units of `unit` unit:TimeUnit Doc from java.util.concurrent.BlockingQueue.offer. a `TimeUnit` determining how to interpret the `timeout` parameter Returns:boolean `true` if successful, or `false` if the specified waiting time elapses before a consumer appears Exceptions InterruptedException: if interrupted while waiting NullPointerException: if the specified element is null

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

Implements java.util.concurrent.BlockingQueue.offer.

Inserts the specified element into this queue, waiting if necessary up to the specified wait time for another thread to receive it.

Parameters

e:E

Doc from java.util.concurrent.BlockingQueue.offer.

the element to add

timeout:long

Doc from java.util.concurrent.BlockingQueue.offer.

how long to wait before giving up, in units of unit

unit:TimeUnit

Doc from java.util.concurrent.BlockingQueue.offer.

a TimeUnit determining how to interpret the timeout parameter

Returns:boolean

true if successful, or false if the specified waiting time elapses before a consumer appears

Exceptions

InterruptedException:: if interrupted while waiting
NullPointerException:: if the specified element is null

offer back to summary

offer	back to summary
public boolean offer(E e) Implements java.util.concurrent.BlockingQueue.offer, java.util.Queue.offer. Inserts the specified element into this queue, if another thread is waiting to receive it. Parameters e:E the element to add Returns:boolean `true` if the element was added to this queue, else `false` Exceptions NullPointerException: if the specified element is null

public boolean offer(E e)

Implements java.util.concurrent.BlockingQueue.offer, java.util.Queue.offer.

Inserts the specified element into this queue, if another thread is waiting to receive it.

Parameters

e:E: the element to add

Returns:boolean

true if the element was added to this queue, else false

Exceptions

NullPointerException:: if the specified element is null

peek back to summary

peek	back to summary
public E peek() Implements java.util.Queue.peek. Always returns `null`. A `SynchronousQueue` does not return elements unless actively waited on. Returns:E `null`

public E peek()

Implements java.util.Queue.peek.

Always returns null. A SynchronousQueue does not return elements unless actively waited on.

Returns:E: null

poll back to summary

poll	back to summary
public E poll(long timeout, TimeUnit unit) throws InterruptedException Implements java.util.concurrent.BlockingQueue.poll. Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time, for another thread to insert it. Parameters timeout:long Doc from java.util.concurrent.BlockingQueue.poll. how long to wait before giving up, in units of `unit` unit:TimeUnit Doc from java.util.concurrent.BlockingQueue.poll. a `TimeUnit` determining how to interpret the `timeout` parameter Returns:E the head of this queue, or `null` if the specified waiting time elapses before an element is present Annotations @SuppressWarnings:unchecked Exceptions InterruptedException: if interrupted while waiting

public E poll(long timeout, TimeUnit unit) throws InterruptedException

Implements java.util.concurrent.BlockingQueue.poll.

Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time, for another thread to insert it.

Parameters

timeout:long

Doc from java.util.concurrent.BlockingQueue.poll.

how long to wait before giving up, in units of unit

unit:TimeUnit

Doc from java.util.concurrent.BlockingQueue.poll.

a TimeUnit determining how to interpret the timeout parameter

Returns:E

the head of this queue, or null if the specified waiting time elapses before an element is present

Annotations

@SuppressWarnings:unchecked

Exceptions

InterruptedException:: if interrupted while waiting

poll back to summary

poll	back to summary
public E poll() Implements java.util.Queue.poll. Retrieves and removes the head of this queue, if another thread is currently making an element available. Returns:E the head of this queue, or `null` if no element is available Annotations @SuppressWarnings:unchecked

public E poll()

Implements java.util.Queue.poll.

Retrieves and removes the head of this queue, if another thread is currently making an element available.

Returns:E

the head of this queue, or null if no element is available

Annotations

@SuppressWarnings:unchecked

put	back to summary
public void put(E e) throws InterruptedException Implements java.util.concurrent.BlockingQueue.put. Adds the specified element to this queue, waiting if necessary for another thread to receive it. Parameters e:E Doc from java.util.concurrent.BlockingQueue.put. the element to add Exceptions InterruptedException: if interrupted while waiting NullPointerException: if the specified element is null

put

back to summary

public void put(E e) throws InterruptedException

Implements java.util.concurrent.BlockingQueue.put.

Adds the specified element to this queue, waiting if necessary for another thread to receive it.

Parameters

e:E

Doc from java.util.concurrent.BlockingQueue.put.

the element to add

Exceptions

InterruptedException:: if interrupted while waiting
NullPointerException:: if the specified element is null

readResolve	back to summary
private Object readResolve() Replaces a deserialized SynchronousQueue with a fresh one with the associated fairness

remainingCapacity back to summary

remainingCapacity	back to summary
public int remainingCapacity() Implements java.util.concurrent.BlockingQueue.remainingCapacity. Always returns zero. A `SynchronousQueue` has no internal capacity. Returns:int zero

public int remainingCapacity()

Implements java.util.concurrent.BlockingQueue.remainingCapacity.

Always returns zero. A SynchronousQueue has no internal capacity.

Returns:int: zero

remove back to summary

remove	back to summary
public boolean remove(Object o) Overrides java.util.AbstractCollection.remove. Implements java.util.concurrent.BlockingQueue.remove, java.util.Collection.remove. Always returns `false`. A `SynchronousQueue` has no internal capacity. Parameters o:Object the element to remove Returns:boolean `false`

public boolean remove(Object o)

Overrides java.util.AbstractCollection.remove.

Implements java.util.concurrent.BlockingQueue.remove, java.util.Collection.remove.

Always returns false. A SynchronousQueue has no internal capacity.

Parameters

o:Object: the element to remove

Returns:boolean

false

removeAll back to summary

removeAll	back to summary
public boolean removeAll(Collection<?> c) Overrides java.util.AbstractCollection.removeAll. Implements java.util.Collection.removeAll. Always returns `false`. A `SynchronousQueue` has no internal capacity. Parameters c:Collection<?> the collection Returns:boolean `false`

public boolean removeAll(Collection<?> c)

Overrides java.util.AbstractCollection.removeAll.

Implements java.util.Collection.removeAll.

Always returns false. A SynchronousQueue has no internal capacity.

Parameters

c:Collection<?>: the collection

Returns:boolean

false

retainAll back to summary

retainAll	back to summary
public boolean retainAll(Collection<?> c) Overrides java.util.AbstractCollection.retainAll. Implements java.util.Collection.retainAll. Always returns `false`. A `SynchronousQueue` has no internal capacity. Parameters c:Collection<?> the collection Returns:boolean `false`

public boolean retainAll(Collection<?> c)

Overrides java.util.AbstractCollection.retainAll.

Implements java.util.Collection.retainAll.

Always returns false. A SynchronousQueue has no internal capacity.

Parameters

c:Collection<?>: the collection

Returns:boolean

false

size back to summary

size	back to summary
public int size() Implements abstract java.util.AbstractCollection.size. Implements java.util.Collection.size. Always returns zero. A `SynchronousQueue` has no internal capacity. Returns:int zero

public int size()

Implements abstract java.util.AbstractCollection.size.

Implements java.util.Collection.size.

Always returns zero. A SynchronousQueue has no internal capacity.

Returns:int: zero

spliterator back to summary

spliterator	back to summary
public Spliterator<E> spliterator() Overrides default java.util.Collection.spliterator. Returns an empty spliterator in which calls to `trySplit` always return `null`. Returns:Spliterator<E> an empty spliterator Since 1.8

public Spliterator<E> spliterator()

Overrides default java.util.Collection.spliterator.

Returns an empty spliterator in which calls to trySplit always return null.

Returns:Spliterator<E>: an empty spliterator
Since: 1.8

take	back to summary
public E take() throws InterruptedException Implements java.util.concurrent.BlockingQueue.take. Retrieves and removes the head of this queue, waiting if necessary for another thread to insert it. Returns:E the head of this queue Annotations @SuppressWarnings:unchecked Exceptions InterruptedException: if interrupted while waiting

take

back to summary

public E take() throws InterruptedException

Implements java.util.concurrent.BlockingQueue.take.

Retrieves and removes the head of this queue, waiting if necessary for another thread to insert it.

Returns:E

the head of this queue

Annotations

@SuppressWarnings:unchecked

Exceptions

InterruptedException:: if interrupted while waiting

toArray	back to summary
public Object[] toArray() Overrides java.util.AbstractCollection.toArray. Implements java.util.Collection.toArray. Returns a zero-length array. Returns:Object[] a zero-length array

toArray

back to summary

public Object[] toArray()

Overrides java.util.AbstractCollection.toArray.

Implements java.util.Collection.toArray.

Returns a zero-length array.

Returns:Object[]: a zero-length array

toArray back to summary

toArray	back to summary
public <T> T[] toArray(T[] a) Overrides java.util.AbstractCollection.toArray. Implements java.util.Collection.toArray. Sets the zeroth element of the specified array to `null` (if the array has non-zero length) and returns it. Parameters <T> Doc from java.util.Collection.toArray. the component type of the array to contain the collection a:T[] the array Returns:T[] the specified array Exceptions NullPointerException: if the specified array is null

public <T> T[] toArray(T[] a)

Overrides java.util.AbstractCollection.toArray.

Implements java.util.Collection.toArray.

Sets the zeroth element of the specified array to null (if the array has non-zero length) and returns it.

Parameters

<T>: Doc from java.util.Collection.toArray. the component type of the array to contain the collection
a:T[]: the array

Returns:T[]

the specified array

Exceptions

NullPointerException:: if the specified array is null

toString back to summary

toString	back to summary
public String toString() Overrides java.util.AbstractCollection.toString. Always returns `"[]"`. Returns:String `"[]"`

public String toString()

Overrides java.util.AbstractCollection.toString.

Always returns "[]".

Returns:String: "[]"

writeObject	back to summary
private void writeObject(ObjectOutputStream s) throws IOException Saves this queue to a stream (that is, serializes it). Parameters s:ObjectOutputStream the stream Exceptions IOException: if an I/O error occurs

writeObject

back to summary

private void writeObject(ObjectOutputStream s) throws IOException

Saves this queue to a stream (that is, serializes it).

Parameters

s:ObjectOutputStream: the stream

Exceptions

IOException:: if an I/O error occurs

xfer	back to summary
private Object xfer(Object e, long nanos) Invokes fair or lifo transfer

public Class SynchronousQueue<E>

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

pack-priv Class SynchronousQueue.FifoWaitQueue

Field Summary

Constructor Summary

Field Detail

Constructor Detail

pack-priv Class SynchronousQueue.LifoWaitQueue

Field Summary

Constructor Summary

Field Detail

Constructor Detail

pack-priv final Class SynchronousQueue.Transferer<E>

Field Summary

Constructor Summary

Method Summary

Constructor Detail

Method Detail

pack-priv Class SynchronousQueue.WaitQueue

Constructor Summary

Method Summary

Constructor Detail

Modifier and Type	Method and Description
private void	unspliceLifo(LinkedTransferQueue.DualNode s) Unlinks node s.
pack-priv final Object	Returns: an item if matched, else e xferLifo(Object the item or null for take e, long timeout or 0 if immediate, Long.MAX_VALUE if untimed ns) Puts or takes an item with lifo ordering.