Modifier and Type	Class and Description
protected class	FairBlockingQueue.ExchangeCountDownLatch<T>
protected class	FairBlockingQueue.FairIterator
protected class	FairBlockingQueue.ItemFuture<T>

Modifier and Type	Field and Description
pack-priv static final boolean	isLinux This little sucker is used to reorder the way to do `java.util.concurrent.locks.Lock#lock()`, `java.util.concurrent.locks.Lock#unlock()` and `java.util.concurrent.CountDownLatch#countDown()` during the `poll(long, TimeUnit)` operation.
pack-priv final LinkedList<E>	items All the objects in the pool are stored in a simple linked list
pack-priv final ReentrantLock	lock Phase one entry lock in order to give out per-thread-locks for the waiting phase we have a phase one lock during the contention period.
pack-priv final LinkedList<FairBlockingQueue<E>.ExchangeCountDownLatch<E>>	waiters All threads waiting for an object are stored in a linked list

Access	Constructor and Description
public	FairBlockingQueue() Creates a new fair blocking queue.

Method Summary

Modifier and Type	Method and Description
public boolean	add(E the element to add e) Implements java.util.concurrent.BlockingQueue.add. Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning `true` upon success and throwing an `IllegalStateException` if no space is currently available.
public boolean	addAll(Collection<? extends E> collection containing elements to be added to this collection c) Implements java.util.Collection.addAll. Adds all of the elements in the specified collection to this collection (optional operation).
public void	clear() Implements java.util.Collection.clear. Removes all of the elements from this collection (optional operation).
public boolean	contains(Object object to be checked for containment in this queue e) Implements java.util.concurrent.BlockingQueue.contains. Returns `true` if this queue contains the specified element.
public boolean	containsAll(Collection<?> collection to be checked for containment in this collection c) Implements java.util.Collection.containsAll. Returns `true` if this collection contains all of the elements in the specified 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 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 E	element() Implements java.util.Queue.element. Retrieves, but does not remove, the head of this queue.
public boolean	isEmpty() Implements java.util.Collection.isEmpty. Returns `true` if this collection contains no elements.
public Iterator<E>	iterator() Implements java.util.Collection.iterator. Returns an iterator over the elements in this collection.
public boolean	offer(E the element to add e) Implements java.util.concurrent.BlockingQueue.offer. Will always return true, queue is unbounded.
public boolean	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. Will never timeout, as it invokes the `offer(Object)` method.
public E	peek() Implements java.util.Queue.peek. Retrieves, but does not remove, the head of this queue, or returns `null` if this queue is empty.
public E	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. Fair retrieval of an object in the queue.
public E	poll() Implements java.util.Queue.poll. Retrieves and removes the head of this queue, or returns `null` if this queue is empty.
public Future<E>	Returns: - a future pending the result from the queue poll request pollAsync() Request an item from the queue asynchronously
public void	put(E the element to add e) Implements java.util.concurrent.BlockingQueue.put. Inserts the specified element into this queue, waiting if necessary for space to become available.
public int	remainingCapacity() Implements java.util.concurrent.BlockingQueue.remainingCapacity. Returns the number of additional 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.
public boolean	remove(Object element to be removed from this queue, if present e) Implements java.util.concurrent.BlockingQueue.remove. Removes a single instance of the specified element from this queue, if it is present.
public E	remove() Implements java.util.Queue.remove. Retrieves and removes the head of this queue.
public boolean	removeAll(Collection<?> collection containing elements to be removed from this collection c) Implements java.util.Collection.removeAll. Removes all of this collection's elements that are also contained in the specified collection (optional operation).
public boolean	retainAll(Collection<?> collection containing elements to be retained in this collection c) Implements java.util.Collection.retainAll. Retains only the elements in this collection that are contained in the specified collection (optional operation).
public int	size() Implements java.util.Collection.size. Returns the number of elements in this collection.
public E	take() Implements java.util.concurrent.BlockingQueue.take. Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.
public Object[]	toArray() Implements java.util.Collection.toArray. Returns an array containing all of the elements in this collection.
public <T> T[]	toArray(T[] the array into which the elements of this collection are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose. a) Implements java.util.Collection.toArray. Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

isLinux back to summary

isLinux	back to summary
pack-priv static final boolean isLinux This little sucker is used to reorder the way to do `java.util.concurrent.locks.Lock#lock()`, `java.util.concurrent.locks.Lock#unlock()` and `java.util.concurrent.CountDownLatch#countDown()` during the `poll(long, TimeUnit)` operation. On Linux, it performs much better if we count down while we hold the global lock, on Solaris its the other way around. Until we have tested other platforms we only check for Linux.

pack-priv static final boolean isLinux

This little sucker is used to reorder the way to do java.util.concurrent.locks.Lock#lock(), java.util.concurrent.locks.Lock#unlock() and java.util.concurrent.CountDownLatch#countDown() during the poll(long, TimeUnit) operation. On Linux, it performs much better if we count down while we hold the global lock, on Solaris its the other way around. Until we have tested other platforms we only check for Linux.

items	back to summary
pack-priv final LinkedList<E> items All the objects in the pool are stored in a simple linked list

lock	back to summary
pack-priv final ReentrantLock lock Phase one entry lock in order to give out per-thread-locks for the waiting phase we have a phase one lock during the contention period.

waiters	back to summary
pack-priv final LinkedList<FairBlockingQueue<E>.ExchangeCountDownLatch<E>> waiters All threads waiting for an object are stored in a linked list

Constructor Detail

FairBlockingQueue	back to summary
public FairBlockingQueue() Creates a new fair blocking queue.

Method Detail

add back to summary

add	back to summary
public boolean add(E e) Implements java.util.concurrent.BlockingQueue.add. Doc from java.util.concurrent.BlockingQueue.add. Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning `true` upon success and throwing an `IllegalStateException` if no space is currently available. When using a capacity-restricted queue, it is generally preferable to use `offer`. Parameters e:E the element to add Returns:boolean `true` (as specified by `Collection#add`) Annotations @Override

public boolean add(E e)

Implements java.util.concurrent.BlockingQueue.add.

Doc from java.util.concurrent.BlockingQueue.add.

Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available. When using a capacity-restricted queue, it is generally preferable to use offer.

Parameters

e:E: the element to add

Returns:boolean

true (as specified by Collection#add)

Annotations

@Override

addAll back to summary

addAll	back to summary
public boolean addAll(Collection<? extends E> c) Implements java.util.Collection.addAll. Doc from java.util.Collection.addAll. Adds all of the elements in the specified collection to this collection (optional operation). The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified collection is this collection, and this collection is nonempty.) If the specified collection has a defined encounter order, processing of its elements generally occurs in that order. Parameters c:Collection<? extends E> collection containing elements to be added to this collection Returns:boolean `true` if this collection changed as a result of the call Annotations @Override

public boolean addAll(Collection<? extends E> c)

Implements java.util.Collection.addAll.

Doc from java.util.Collection.addAll.

Adds all of the elements in the specified collection to this collection (optional operation). The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified collection is this collection, and this collection is nonempty.) If the specified collection has a defined encounter order, processing of its elements generally occurs in that order.

Parameters

c:Collection<? extends E>: collection containing elements to be added to this collection

Returns:boolean

true if this collection changed as a result of the call

Annotations

@Override

clear	back to summary
public void clear() Implements java.util.Collection.clear. Doc from java.util.Collection.clear. Removes all of the elements from this collection (optional operation). The collection will be empty after this method returns. Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

clear

back to summary

public void clear()

Implements java.util.Collection.clear.

Doc from java.util.Collection.clear.

Removes all of the elements from this collection (optional operation). The collection will be empty after this method returns.

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

contains back to summary

contains	back to summary
public boolean contains(Object e) Implements java.util.concurrent.BlockingQueue.contains. Doc from java.util.concurrent.BlockingQueue.contains. 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)`. Parameters e:Object object to be checked for containment in this queue Returns:boolean `true` if this queue contains the specified element Annotations @Override

public boolean contains(Object e)

Implements java.util.concurrent.BlockingQueue.contains.

Doc from java.util.concurrent.BlockingQueue.contains.

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).

Parameters

e:Object: object to be checked for containment in this queue

Returns:boolean

true if this queue contains the specified element

Annotations

@Override

containsAll back to summary

containsAll	back to summary
public boolean containsAll(Collection<?> c) Implements java.util.Collection.containsAll. Doc from java.util.Collection.containsAll. Returns `true` if this collection contains all of the elements in the specified collection. Parameters c:Collection<?> collection to be checked for containment in this collection Returns:boolean `true` if this collection contains all of the elements in the specified collection Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

public boolean containsAll(Collection<?> c)

Implements java.util.Collection.containsAll.

Doc from java.util.Collection.containsAll.

Returns true if this collection contains all of the elements in the specified collection.

Parameters

c:Collection<?>: collection to be checked for containment in this collection

Returns:boolean

true if this collection contains all of the elements in the specified collection

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

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 Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

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

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

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 Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

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

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

element back to summary

element	back to summary
public E element() Implements java.util.Queue.element. Doc from java.util.Queue.element. Retrieves, but does not remove, the head of this queue. This method differs from `peek` only in that it throws an exception if this queue is empty. Returns:E the head of this queue Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

public E element()

Implements java.util.Queue.element.

Doc from java.util.Queue.element.

Retrieves, but does not remove, the head of this queue. This method differs from peek only in that it throws an exception if this queue is empty.

Returns:E

the head of this queue

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

isEmpty back to summary

isEmpty	back to summary
public boolean isEmpty() Implements java.util.Collection.isEmpty. Doc from java.util.Collection.isEmpty. Returns `true` if this collection contains no elements. Returns:boolean `true` if this collection contains no elements Annotations @Override

public boolean isEmpty()

Implements java.util.Collection.isEmpty.

Doc from java.util.Collection.isEmpty.

Returns true if this collection contains no elements.

Returns:boolean

true if this collection contains no elements

Annotations

@Override

iterator back to summary

iterator	back to summary
public Iterator<E> iterator() Implements java.util.Collection.iterator. Doc from java.util.Collection.iterator. Returns an iterator over the elements in this collection. There are no guarantees concerning the order in which the elements are returned (unless this collection is an instance of some class that provides a guarantee). Returns:Iterator<E> an `Iterator` over the elements in this collection Annotations @Override

public Iterator<E> iterator()

Implements java.util.Collection.iterator.

Doc from java.util.Collection.iterator.

Returns an iterator over the elements in this collection. There are no guarantees concerning the order in which the elements are returned (unless this collection is an instance of some class that provides a guarantee).

Returns:Iterator<E>

an Iterator over the elements in this collection

Annotations

@Override

offer back to summary

offer	back to summary
public boolean offer(E e) Implements java.util.concurrent.BlockingQueue.offer. Doc from java.util.concurrent.BlockingQueue.offer. Will always return true, queue is unbounded. Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning `true` upon success and `false` if no space is currently available. When using a capacity-restricted queue, this method is generally preferable to `add`, which can fail to insert an element only by throwing an exception. Parameters e:E the element to add Returns:boolean `true` if the element was added to this queue, else `false` Annotations @Override

public boolean offer(E e)

Implements java.util.concurrent.BlockingQueue.offer.

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

Will always return true, queue is unbounded. Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and false if no space is currently available. When using a capacity-restricted queue, this method is generally preferable to add, which can fail to insert an element only by throwing an exception.

Parameters

e:E: the element to add

Returns:boolean

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

Annotations

@Override

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. Doc from java.util.concurrent.BlockingQueue.offer. Will never timeout, as it invokes the `offer(Object)` method. Once a lock has been acquired, the Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available. Parameters e:E the element to add timeout:long how long to wait before giving up, in units of `unit` unit:TimeUnit a `TimeUnit` determining how to interpret the `timeout` parameter Returns:boolean `true` if successful, or `false` if the specified waiting time elapses before space is available Annotations @Override Exceptions InterruptedException: if interrupted while waiting

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

Implements java.util.concurrent.BlockingQueue.offer.

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

Will never timeout, as it invokes the offer(Object) method. Once a lock has been acquired, the Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available.

Parameters

e:E: the element to add
timeout:long: how long to wait before giving up, in units of unit
unit:TimeUnit: a TimeUnit determining how to interpret the timeout parameter

Returns:boolean

true if successful, or false if the specified waiting time elapses before space is available

Annotations

@Override

Exceptions

InterruptedException:: if interrupted while waiting

peek back to summary

peek	back to summary
public E peek() Implements java.util.Queue.peek. Doc from java.util.Queue.peek. Retrieves, but does not remove, the head of this queue, or returns `null` if this queue is empty. Returns:E the head of this queue, or `null` if this queue is empty Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

public E peek()

Implements java.util.Queue.peek.

Doc from java.util.Queue.peek.

Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.

Returns:E

the head of this queue, or null if this queue is empty

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

poll back to summary

poll	back to summary
public E poll(long timeout, TimeUnit unit) throws InterruptedException Implements java.util.concurrent.BlockingQueue.poll. Doc from java.util.concurrent.BlockingQueue.poll. Fair retrieval of an object in the queue. Objects are returned in the order the threads requested them. Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an element to become available. Parameters timeout:long how long to wait before giving up, in units of `unit` unit:TimeUnit 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 available Annotations @Override Exceptions InterruptedException: if interrupted while waiting

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

Implements java.util.concurrent.BlockingQueue.poll.

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

Fair retrieval of an object in the queue. Objects are returned in the order the threads requested them. Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an element to become available.

Parameters

timeout:long: how long to wait before giving up, in units of unit
unit:TimeUnit: 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 available

Annotations

@Override

Exceptions

InterruptedException:: if interrupted while waiting

poll back to summary

poll	back to summary
public E poll() Implements java.util.Queue.poll. Doc from java.util.Queue.poll. Retrieves and removes the head of this queue, or returns `null` if this queue is empty. Returns:E the head of this queue, or `null` if this queue is empty Annotations @Override

public E poll()

Implements java.util.Queue.poll.

Doc from java.util.Queue.poll.

Retrieves and removes the head of this queue, or returns null if this queue is empty.

Returns:E

the head of this queue, or null if this queue is empty

Annotations

@Override

pollAsync	back to summary
public Future<E> pollAsync() Request an item from the queue asynchronously Returns:Future<E> - a future pending the result from the queue poll request

pollAsync

back to summary

public Future<E> pollAsync()

Request an item from the queue asynchronously

Returns:Future<E>: - a future pending the result from the queue poll request

put	back to summary
public void put(E e) throws InterruptedException Implements java.util.concurrent.BlockingQueue.put. Doc from java.util.concurrent.BlockingQueue.put. Inserts the specified element into this queue, waiting if necessary for space to become available. Parameters e:E the element to add Annotations @Override Exceptions InterruptedException: if interrupted while waiting

put

back to summary

public void put(E e) throws InterruptedException

Implements java.util.concurrent.BlockingQueue.put.

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

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

Parameters

e:E: the element to add

Annotations

@Override

Exceptions

InterruptedException:: if interrupted while waiting

remainingCapacity back to summary

remainingCapacity	back to summary
public int remainingCapacity() Implements java.util.concurrent.BlockingQueue.remainingCapacity. Doc from java.util.concurrent.BlockingQueue.remainingCapacity. Returns the number of additional 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 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. Returns:int the remaining capacity Annotations @Override

public int remainingCapacity()

Implements java.util.concurrent.BlockingQueue.remainingCapacity.

Doc from java.util.concurrent.BlockingQueue.remainingCapacity.

Returns the number of additional 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 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.

Returns:int

the remaining capacity

Annotations

@Override

remove back to summary

remove	back to summary
public boolean remove(Object e) Implements java.util.concurrent.BlockingQueue.remove. Doc from java.util.concurrent.BlockingQueue.remove. 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). Parameters e:Object element to be removed from this queue, if present Returns:boolean `true` if this queue changed as a result of the call Annotations @Override

public boolean remove(Object e)

Implements java.util.concurrent.BlockingQueue.remove.

Doc from java.util.concurrent.BlockingQueue.remove.

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).

Parameters

e:Object: element to be removed from this queue, if present

Returns:boolean

true if this queue changed as a result of the call

Annotations

@Override

remove back to summary

remove	back to summary
public E remove() Implements java.util.Queue.remove. Doc from java.util.Queue.remove. Retrieves and removes the head of this queue. This method differs from `poll()` only in that it throws an exception if this queue is empty. Returns:E the head of this queue Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

public E remove()

Implements java.util.Queue.remove.

Doc from java.util.Queue.remove.

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

Returns:E

the head of this queue

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

removeAll back to summary

removeAll	back to summary
public boolean removeAll(Collection<?> c) Implements java.util.Collection.removeAll. Doc from java.util.Collection.removeAll. Removes all of this collection's elements that are also contained in the specified collection (optional operation). After this call returns, this collection will contain no elements in common with the specified collection. Parameters c:Collection<?> collection containing elements to be removed from this collection Returns:boolean `true` if this collection changed as a result of the call Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

public boolean removeAll(Collection<?> c)

Implements java.util.Collection.removeAll.

Doc from java.util.Collection.removeAll.

Removes all of this collection's elements that are also contained in the specified collection (optional operation). After this call returns, this collection will contain no elements in common with the specified collection.

Parameters

c:Collection<?>: collection containing elements to be removed from this collection

Returns:boolean

true if this collection changed as a result of the call

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

retainAll back to summary

retainAll	back to summary
public boolean retainAll(Collection<?> c) Implements java.util.Collection.retainAll. Doc from java.util.Collection.retainAll. Retains only the elements in this collection that are contained in the specified collection (optional operation). In other words, removes from this collection all of its elements that are not contained in the specified collection. Parameters c:Collection<?> collection containing elements to be retained in this collection Returns:boolean `true` if this collection changed as a result of the call Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

public boolean retainAll(Collection<?> c)

Implements java.util.Collection.retainAll.

Doc from java.util.Collection.retainAll.

Retains only the elements in this collection that are contained in the specified collection (optional operation). In other words, removes from this collection all of its elements that are not contained in the specified collection.

Parameters

c:Collection<?>: collection containing elements to be retained in this collection

Returns:boolean

true if this collection changed as a result of the call

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

size back to summary

size	back to summary
public int size() Implements java.util.Collection.size. Doc from java.util.Collection.size. Returns the number of elements in this collection. If this collection contains more than `Integer.MAX_VALUE` elements, returns `Integer.MAX_VALUE`. Returns:int the number of elements in this collection Annotations @Override

public int size()

Implements java.util.Collection.size.

Doc from java.util.Collection.size.

Returns the number of elements in this collection. If this collection contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.

Returns:int

the number of elements in this collection

Annotations

@Override

take	back to summary
public E take() throws InterruptedException Implements java.util.concurrent.BlockingQueue.take. Doc from java.util.concurrent.BlockingQueue.take. Retrieves and removes the head of this queue, waiting if necessary until an element becomes available. Returns:E the head of this queue Annotations @Override Exceptions InterruptedException: if interrupted while waiting

take

back to summary

public E take() throws InterruptedException

Implements java.util.concurrent.BlockingQueue.take.

Doc from java.util.concurrent.BlockingQueue.take.

Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.

Returns:E

the head of this queue

Annotations

@Override

Exceptions

InterruptedException:: if interrupted while waiting

toArray back to summary

toArray	back to summary
public Object[] toArray() Implements java.util.Collection.toArray. Doc from java.util.Collection.toArray. Returns an array containing all of the elements in this collection. If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order. The returned array's runtime component type is `Object`. The returned array will be "safe" in that no references to it are maintained by this collection. (In other words, this method must allocate a new array even if this collection is backed by an array). The caller is thus free to modify the returned array. Returns:Object[] an array, whose runtime component type is `Object`, containing all of the elements in this collection Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

public Object[] toArray()

Implements java.util.Collection.toArray.

Doc from java.util.Collection.toArray.

Returns an array containing all of the elements in this collection. If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order. The returned array's runtime component type is Object.

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

Returns:Object[]

an array, whose runtime component type is Object, containing all of the elements in this collection

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

toArray back to summary

toArray	back to summary
public <T> T[] toArray(T[] a) Implements java.util.Collection.toArray. Doc from java.util.Collection.toArray. Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. If the collection 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 collection. If this collection fits in the specified array with room to spare (i.e., the array has more elements than this collection), the element in the array immediately following the end of the collection is set to `null`. (This is useful in determining the length of this collection only if the caller knows that this collection does not contain any `null` elements.) If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order. Parameters <T> the component type of the array to contain the collection a:T[] the array into which the elements of this collection are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose. Returns:T[] an array containing all of the elements in this collection Annotations @Override Exceptions UnsupportedOperationException: - this operation is not supported

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

Implements java.util.Collection.toArray.

Doc from java.util.Collection.toArray.

Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. If the collection 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 collection.

If this collection fits in the specified array with room to spare (i.e., the array has more elements than this collection), the element in the array immediately following the end of the collection is set to null. (This is useful in determining the length of this collection only if the caller knows that this collection does not contain any null elements.)

If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.

Parameters

<T>: the component type of the array to contain the collection
a:T[]: the array into which the elements of this collection are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.

Returns:T[]

an array containing all of the elements in this collection

Annotations

@Override

Exceptions

UnsupportedOperationException:: - this operation is not supported

Modifier and Type	Field and Description
protected volatile T	item

Access	Constructor and Description
public	ExchangeCountDownLatch(int i)

Modifier and Type	Method and Description
public T	getItem()
public void	setItem(T item)

item	back to summary
protected volatile T item

ExchangeCountDownLatch	back to summary
public ExchangeCountDownLatch(int i)

getItem	back to summary
public T getItem()

setItem	back to summary
public void setItem(T item)

Modifier and Type	Field and Description
pack-priv E	element
pack-priv E[]	elements
pack-priv int	index

Access	Constructor and Description
public	FairIterator()

Modifier and Type	Method and Description
public boolean	hasNext() Implements java.util.Iterator.hasNext. Returns `true` if the iteration has more elements.
public E	next() Implements java.util.Iterator.next. Returns the next element in the iteration.
public void	remove() Overrides default java.util.Iterator.remove. Removes from the underlying collection the last element returned by this iterator (optional operation).

element	back to summary
pack-priv E element

elements	back to summary
pack-priv E[] elements

index	back to summary
pack-priv int index

FairIterator	back to summary
public FairIterator() Annotations @SuppressWarnings:unchecked

hasNext	back to summary
public boolean hasNext() Implements java.util.Iterator.hasNext. Doc from java.util.Iterator.hasNext. Returns `true` if the iteration has more elements. (In other words, returns `true` if `next` would return an element rather than throwing an exception.) Returns:boolean `true` if the iteration has more elements Annotations @Override

org.apache.tomcat.jdbc.pool back to summary

protected Class FairBlockingQueue.ItemFuture<T>

Class Inheritance

extends Object
implements Future<T>

java.lang.Object
org.apache.tomcat.jdbc.pool.FairBlockingQueue.ItemFuture

All Implemented Interfaces

java.util.concurrent.Future

Field Summary

Modifier and Type	Field and Description
protected volatile boolean	canceled
protected volatile T	item
protected volatile FairBlockingQueue<E>.ExchangeCountDownLatch<T>	latch

Constructor Summary

Access	Constructor and Description
public	ItemFuture(T item)
public	ItemFuture(FairBlockingQueue<E>.ExchangeCountDownLatch<T> latch)

Method Summary

Modifier and Type	Method and Description
public boolean	cancel(boolean `true` if the thread executing this task should be interrupted (if the thread is known to the implementation); otherwise, in-progress tasks are allowed to complete mayInterruptIfRunning) Implements java.util.concurrent.Future.cancel. Attempts to cancel execution of this task.
public T	get() Implements java.util.concurrent.Future.get. Waits if necessary for the computation to complete, and then retrieves its result.
public T	get(long the maximum time to wait timeout, TimeUnit the time unit of the timeout argument unit) Implements java.util.concurrent.Future.get. Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
public boolean	isCancelled() Implements java.util.concurrent.Future.isCancelled. Returns `true` if this task was cancelled before it completed normally.
public boolean	isDone() Implements java.util.concurrent.Future.isDone. Returns `true` if this task completed.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

canceled	back to summary
protected volatile boolean canceled

item	back to summary
protected volatile T item

latch	back to summary
protected volatile FairBlockingQueue<E>.ExchangeCountDownLatch<T> latch

Constructor Detail

ItemFuture	back to summary
public ItemFuture(T item)

ItemFuture	back to summary
public ItemFuture(FairBlockingQueue<E>.ExchangeCountDownLatch<T> latch)

Method Detail

cancel back to summary

public boolean cancel(boolean mayInterruptIfRunning)

Implements java.util.concurrent.Future.cancel.

Doc from java.util.concurrent.Future.cancel.

Attempts to cancel execution of this task. This method has no effect if the task is already completed or cancelled, or could not be cancelled for some other reason. Otherwise, if this task has not started when cancel is called, this task should never run. If the task has already started, then the mayInterruptIfRunning parameter determines whether the thread executing this task (when known by the implementation) is interrupted in an attempt to stop the task.

The return value from this method does not necessarily indicate whether the task is now cancelled; use isCancelled.

Parameters

mayInterruptIfRunning:boolean: true if the thread executing this task should be interrupted (if the thread is known to the implementation); otherwise, in-progress tasks are allowed to complete

Returns:boolean

false if the task could not be cancelled, typically because it has already completed; true otherwise. If two or more threads cause a task to be cancelled, then at least one of them returns true. Implementations may provide stronger guarantees.

Annotations

@Override

get

back to summary

public T get() throws InterruptedException, ExecutionException

Implements java.util.concurrent.Future.get.

Doc from java.util.concurrent.Future.get.

Waits if necessary for the computation to complete, and then retrieves its result.

Returns:T

the computed result

Annotations

@Override

Exceptions

InterruptedException:: if the current thread was interrupted while waiting
ExecutionException:: if the computation threw an exception

get

back to summary

public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException

Implements java.util.concurrent.Future.get.

Doc from java.util.concurrent.Future.get.

Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.

Parameters

timeout:long: the maximum time to wait
unit:TimeUnit: the time unit of the timeout argument

Returns:T

the computed result

Annotations

@Override

Exceptions

InterruptedException:: if the current thread was interrupted while waiting
ExecutionException:: if the computation threw an exception
TimeoutException:: if the wait timed out

isCancelled back to summary

public boolean isCancelled()

Implements java.util.concurrent.Future.isCancelled.

Doc from java.util.concurrent.Future.isCancelled.

Returns true if this task was cancelled before it completed normally.

Returns:boolean

true if this task was cancelled before it completed

Annotations

@Override

isDone back to summary

public boolean isDone()

Implements java.util.concurrent.Future.isDone.

Doc from java.util.concurrent.Future.isDone.

Returns true if this task completed. Completion may be due to normal termination, an exception, or cancellation -- in all of these cases, this method will return true.

Returns:boolean

true if this task completed

Annotations

@Override

public Class FairBlockingQueue<E>

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

protected Class FairBlockingQueue.ExchangeCountDownLatch<T>

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

protected Class FairBlockingQueue.FairIterator

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

protected Class FairBlockingQueue.ItemFuture<T>

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail