A handler for rejected tasks that throws a
RejectedExecutionException.
Overrides toArray() and toArray(Object[]) in AbstractCollection to provide
implementations valid for concurrent collections.
Overrides toArray() and toArray(Object[]) in AbstractCollection to provide
implementations valid for concurrent lists.
Convenience base class for map implementations that provides helper classes
representing simple map entries, both mutable and immutable.
This class provides skeletal implementations of some
Queue
operations.
Constructor for use by subclasses.
Overrides toArray() and toArray(Object[]) in AbstractCollection to provide
implementations valid for concurrent lists.
Overrides toArray() and toArray(Object[]) in AbstractCollection to provide
implementations valid for concurrent sets.
Acquires a permit from this semaphore, blocking until one is
available, or the thread is interrupted.
Acquires the given number of permits from this semaphore,
blocking until all are available,
or the thread is interrupted.
Acquires a permit from this semaphore, blocking until one is
available.
Acquires the given number of permits from this semaphore,
blocking until all are available.
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.
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 throwing an
IllegalStateException if this queue is full.
Inserts the specified element at the end of this deque.
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque) 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.
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.
Inserts the specified element at the tail of this queue.
Adds the specified element to this set if it is not already present.
Adds the specified element to this set if it is not already present.
Inserts the specified element into this delay queue.
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque) 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.
Inserts the specified element at the end of this deque unless it would
violate capacity restrictions.
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque) 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.
Inserts the specified element into this priority queue.
Inserts the specified element into this priority queue.
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.
Adds all of the elements in the specified collection to this
queue.
Adds all of the elements in the specified collection to this set if
they're not already present.
Atomically adds the given value to the current value.
Atomically adds the given value to the element at index i.
Atomically adds the given value to the element at index i.
Atomically adds the given value to the current value.
Inserts the specified element at the front of this deque.
Inserts the specified element at the front of this deque if it is
possible to do so immediately without violating capacity restrictions,
throwing an IllegalStateException if no space is currently
available.
Inserts the specified element at the front of this deque if it is
possible to do so immediately without violating capacity restrictions.
Inserts the specified element at the front of this deque if it is
possible to do so immediately without violating capacity restrictions.
Inserts the specified element at the end of this deque.
Inserts the specified element at the end of this deque if it is
possible to do so immediately without violating capacity restrictions,
throwing an IllegalStateException if no space is currently
available.
Inserts the specified element at the end of this deque if it is
possible to do so immediately without violating capacity restrictions.
Inserts the specified element at the end of this deque if it is
possible to do so immediately without violating capacity restrictions.
Method invoked upon completion of execution of the given Runnable.
Sets the policy governing whether core threads may time out and
terminate if no tasks arrive within the keep-alive time, being
replaced if needed when new tasks arrive.
Returns true if this pool allows core threads to time out and
terminate if no tasks arrive within the keepAlive time, being
replaced if needed when new tasks arrive.
Creates an ArrayBlockingQueue with the given (fixed)
capacity and default access policy.
Creates an ArrayBlockingQueue with the given (fixed)
capacity and the specified access policy.
Creates an ArrayBlockingQueue with the given (fixed)
capacity, the specified access policy and initially containing the
elements of the given collection,
added in traversal order of the collection's iterator.
Resizable-array implementation of the
Deque
interface.
Constructs an empty array deque with an initial capacity
sufficient to hold 16 elements.
Constructs a deque containing the elements of the specified
collection, in the order they are returned by the collection's
iterator.
Constructs an empty array deque with an initial capacity
sufficient to hold the specified number of elements.
Returns wrapped runnable that ensures that if an exception occurs
during the execution, the specified exception handler is invoked.
A boolean value that may be updated atomically.
Creates a new AtomicBoolean with initial value false.
Creates a new AtomicBoolean with the given initial value.
An int value that may be updated atomically.
Creates a new AtomicInteger with initial value 0.
Creates a new AtomicInteger with the given initial value.
An int array in which elements may be updated atomically.
Creates a new AtomicIntegerArray of given length.
Creates a new AtomicIntegerArray with the same length as, and
all elements copied from, the given array.
A long value that may be updated atomically.
Creates a new AtomicLong with initial value 0.
Creates a new AtomicLong with the given initial value.
A long array in which elements may be updated atomically.
Creates a new AtomicLongArray of given length.
Creates a new AtomicLongArray with the same length as, and
all elements copied from, the given array.
An AtomicMarkableReference maintains an object reference
along with a mark bit, that can be updated atomically.
Creates a new AtomicMarkableReference with the given
initial values.
An object reference that may be updated atomically.
Creates a new AtomicReference with null initial value.
Creates a new AtomicReference with the given initial value.
An array of object references in which elements may be updated
atomically.
Creates a new AtomicReferenceArray of given length.
Creates a new AtomicReferenceArray with the same length as, and
all elements copied from, the given array.
An AtomicStampedReference maintains an object reference
along with an integer "stamp", that can be updated atomically.
Creates a new AtomicStampedReference with the given
initial values.
Atomically sets the value of the mark to the given update value
if the current reference is == to the expected
reference.
Atomically sets the value of the stamp to the given update value
if the current reference is == to the expected
reference.
Returns the current number of permits available in this semaphore.
await() - method in class edu.emory.mathcs.backport.java.util.concurrent.locks.
Condition Causes the current thread to wait until it is signalled or
interrupted.
Causes the current thread to wait until the latch has counted down to
zero, unless the thread is interrupted.
Waits until all
parties have invoked
await on this barrier.
Causes the current thread to wait until it is signalled or interrupted,
or the specified waiting time elapses.
Causes the current thread to wait until the latch has counted down to
zero, unless the thread is interrupted,
or the specified waiting time elapses.
Waits until all
parties have invoked
await on this barrier, or the specified waiting time elapses.
Causes the current thread to wait until it is signalled or interrupted,
or the specified waiting time elapses.
Blocks until all tasks have completed execution after a shutdown
request, or the timeout occurs, or the current thread is
interrupted, whichever happens first.
Blocks until all tasks have completed execution after a shutdown
request, or the timeout occurs, or the current thread is
interrupted, whichever happens first.
Causes the current thread to wait until it is signalled.
Causes the current thread to wait until it is signalled or interrupted,
or the specified deadline elapses.
call() - method in class edu.emory.mathcs.backport.java.util.concurrent.
Callable Computes a result, or throws an exception if unable to do so.
A task that returns a result and may throw an exception.
Returns a
Callable
object that, when
called, runs the given privileged action and returns its result.
Returns a
Callable
object that, when
called, runs the given privileged exception action and returns
its result.
Returns a
Callable
object that, when
called, runs the given task and returns
null.
Returns a
Callable
object that, when
called, runs the given task and returns the given result.
A handler for rejected tasks that runs the rejected task
directly in the calling thread of the execute method,
unless the executor has been shut down, in which case the task
is discarded.
Creates a CallerRunsPolicy.
Attempts to cancel execution of this task.
Exception indicating that the result of a value-producing task,
such as a
FutureTask
, cannot be retrieved because the task
was cancelled.
Constructs a CancellationException with no detail message.
Constructs a CancellationException with the specified detail
message.
Returns the least element in this set greater than or equal to
the given element, or null
if there is no such element.
Returns a key-value mapping associated with the least key
greater than or equal to the given key, or null if
there is no such entry.
Returns a key-value mapping associated with the least key
greater than or equal to the given key, or null
if
there is no such key.
Returns the least key greater than or equal to the given key,
or null
if there is no such key.
Removes all of the elements from this queue.
Atomically removes all of the elements from this queue.
Removes all of the elements from this deque.
Removes all of the mappings from this map.
Removes all of the mappings from this map.
Removes all of the elements from this set.
Removes all of the elements from this set.
Atomically removes all of the elements from this delay queue.
Atomically removes all of the elements from this deque.
Atomically removes all of the elements from this queue.
Atomically removes all of the elements from this queue.
Removes all of the elements from this queue.
Returns a copy of this deque.
Returns a shallow copy of this ConcurrentSkipListMap
instance.
Returns a shallow copy of this ConcurrentSkipListSet
instance.
Return a new Entry with same element and color as self,
but with null links.
Augments java.util.Collections
with methods added in Java 5.0
and higher.
Returns the comparator used to order the elements in this queue,
or null if this queue uses the natural ordering of its elements.
Returns the comparator used to order the elements in this queue,
or null if this queue uses the natural ordering of its elements.
Atomically sets the value to the given updated value
if the current value == the expected value.
Atomically sets the value to the given updated value
if the current value == the expected value.
Atomically sets the element at position i to the given
updated value if the current value == the expected value.
Atomically sets the value to the given updated value
if the current value == the expected value.
Atomically sets the element at position i to the given
updated value if the current value == the expected value.
Atomically sets the value to the given updated value
if the current value == the expected value.
Atomically sets the value to the given updated value
if the current value == the expected value.
Atomically sets the value of both the reference and mark
to the given update values if the
current reference is == to the expected reference
and the current mark is equal to the expected mark.
Atomically sets the value of both the reference and stamp
to the given update values if the
current reference is == to the expected reference
and the current stamp is equal to the expected stamp.
A service that decouples the production of new asynchronous tasks
from the consumption of the results of completed tasks.
A hash table supporting full concurrency of retrievals and
adjustable expected concurrency for updates.
Creates a new, empty map with a default initial capacity (16),
load factor (0.75) and concurrencyLevel (16).
Creates a new, empty map with the specified initial capacity,
and with default load factor (0.75) and concurrencyLevel (16).
Creates a new, empty map with the specified initial capacity
and load factor and with the default concurrencyLevel (16).
Creates a new, empty map with the specified initial
capacity, load factor and concurrency level.
Creates a new map with the same mappings as the given map.
An unbounded thread-safe
queue based on linked nodes.
Creates a ConcurrentLinkedQueue that is initially empty.
Creates a ConcurrentLinkedQueue
initially containing the elements of the given collection,
added in traversal order of the collection's iterator.
A java.util.Map
providing additional atomic
putIfAbsent, remove, and replace methods.
Constructs a new, empty map, sorted according to the
natural ordering of the keys.
Constructs a new, empty map, sorted according to the specified
comparator.
Constructs a new map containing the same mappings as the given map,
sorted according to the natural ordering of
the keys.
Constructs a new map containing the same mappings and using the
same ordering as the specified sorted map.
Constructs a new, empty set that orders its elements according to
their natural ordering.
Constructs a new set containing the elements in the specified
collection, that orders its elements according to their
natural ordering.
Constructs a new, empty set that orders its elements according to
the specified comparator.
Constructs a new set containing the same elements and using the
same ordering as the specified sorted set.
Condition
factors out the
Object
monitor
methods (
wait
,
notify
and
notifyAll
) into distinct objects to
give the effect of having multiple wait-sets per object, by
combining them with the use of arbitrary
Lock
implementations.
Returns true if this queue contains the specified element.
Returns true if this deque contains the specified element.
Returns true if this deque contains the specified element.
Returns true if this queue contains the specified element.
Legacy method testing if some key maps into the specified value
in this table.
Returns true if this queue contains the specified element.
Returns true if this set contains the specified element.
Returns true if this set contains the specified element.
Returns true if this deque contains the specified element.
Returns true if this deque contains the specified element.
Returns true if this deque contains the specified element.
Returns true
if this queue contains the specified element.
Returns true if this queue contains the specified element.
Returns true if this set contains all of the elements of the
specified collection.
Returns false unless the given collection is empty.
Tests if the specified object is a key in this table.
Returns true if this map contains a mapping for the specified
key.
Returns true if this map maps one or more keys to the
specified value.
Returns true if this map maps one or more keys to the
specified value.
Convert the given time duration in the given unit to this
unit.
Creates a set containing all of the elements of the specified
collection.
Decrements the count of the latch, releasing all waiting threads if
the count reaches zero.
A synchronization aid that allows one or more threads to wait until
a set of operations being performed in other threads completes.
Constructs a CountDownLatch
initialized with the given count.
A synchronization aid that allows a set of threads to all wait for
each other to reach a common barrier point.
Creates a new CyclicBarrier that will trip when the
given number of parties (threads) are waiting upon it, and
does not perform a predefined action when the barrier is tripped.
Creates a new CyclicBarrier that will trip when the
given number of parties (threads) are waiting upon it, and which
will execute the given barrier action when the barrier is tripped,
performed by the last thread entering the barrier.
Utility classes commonly useful in concurrent programming.
A small toolkit of classes that support lock-free thread-safe
programming on single variables.
Auxiliary and helper classes for backport.util.concurrent, NOT present in
java.util.concurrent.
Interfaces and classes providing a framework for locking and waiting
for conditions that is distinct from built-in synchronization and
monitors.
Retrieves, but does not remove, the head of this queue.
Retrieves, but does not remove, the head of the queue represented by
this deque.
Retrieves, but does not remove, the head of the queue represented by
this deque (in other words, the first element of this deque).
Retrieves, but does not remove, the head of the queue represented by
this deque (in other words, the first element of this deque).
Retrieves, but does not remove, the head of the queue represented by
this deque.
Retrieves, but does not remove, the head of the queue represented by
this deque (in other words, the first element of this deque).
Retrieves, but does not remove, the head of this queue.
Retrieves, but does not remove, the head of this queue.
Returns an enumeration of the values in this table.
Make a new node with given element, null links, and BLACK color.
Returns a Set
view of the mappings contained in this map.
Returns a Set
view of the mappings contained in this map.
Compares the specified object with this map for equality.
Compares the specified object with this set for equality.
Compares the specified object with this set for equality.
Waits for another thread to arrive at this exchange point (unless
it is interrupted
),
and then transfers the given object to it, receiving its object
in return.
Waits for another thread to arrive at this exchange point (unless
the current thread is interrupted
or
the specified waiting time elapses), and then transfers the given
object to it, receiving its object in return.
A synchronization point at which threads can pair and swap elements
within pairs.
Executes the given command at some time in the future.
Executes command with zero required delay.
Executes the given task sometime in the future.
Exception thrown when attempting to retrieve the result of a task
that aborted by throwing an exception.
Constructs an ExecutionException with no detail message.
Constructs an ExecutionException with the specified detail
message.
Constructs an ExecutionException with the specified detail
message and cause.
Constructs an ExecutionException with the specified cause.
An object that executes submitted Runnable
tasks.
Creates an ExecutorCompletionService using the supplied
executor for base task execution and a
LinkedBlockingQueue
as a completion queue.
Creates an ExecutorCompletionService using the supplied
executor for base task execution and the supplied queue as its
completion queue.
An
Executor
that provides methods to manage termination and
methods that can produce a
Future
for tracking progress of
one or more asynchronous tasks.
extract() - method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.
WaitQueue get() - method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.
AtomicBoolean Returns the current value.
get() - method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.
AtomicInteger Gets the current value.
get() - method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.
AtomicLong Gets the current value.
get() - method in class edu.emory.mathcs.backport.java.util.concurrent.
Future Waits if necessary for the computation to complete, and then
retrieves its result.
get() - method in class edu.emory.mathcs.backport.java.util.concurrent.
FutureTask Returns the current values of both the reference and the mark.
Gets the current value at position i.
Gets the current value at position i.
Gets the current value at position i.
Returns the current values of both the reference and the stamp.
Waits if necessary for at most the given time for the computation
to complete, and then retrieves its result, if available.
Returns the value to which the specified key is mapped,
or null
if this map contains no mapping for the key.
Returns the value to which the specified key is mapped,
or null
if this map contains no mapping for the key.
Returns the approximate number of threads that are actively
executing tasks.
Atomically adds the given value to the current value.
Atomically adds the given value to the element at index i.
Atomically adds the given value to the element at index i.
Atomically adds the given value to the current value.
Atomically decrements by one the current value.
Atomically decrements by one the current value.
Atomically decrements by one the element at index i.
Atomically decrements by one the element at index i.
Atomically increments by one the current value.
Atomically increments by one the current value.
Atomically increments by one the element at index i.
Atomically increments by one the element at index i.
Atomically sets to the given value and returns the previous value.
Atomically sets to the given value and returns the old value.
Atomically sets the element at position i to the given
value and returns the old value.
Atomically sets the element at position i to the given value
and returns the old value.
Atomically sets the element at position i to the given
value and returns the old value.
Atomically sets to the given value and returns the old value.
Atomically sets to the given value and returns the old value.
Returns the approximate total number of tasks that have
completed execution.
Gets the policy on whether to continue executing existing
periodic tasks even when this executor has been
shutdown.
Returns the core number of threads.
Returns the current count.
Returns the remaining delay associated with this object, in the
given time unit.
Gets the policy on whether to execute existing delayed
tasks even when this executor has been shutdown.
Retrieves, but does not remove, the first element of this deque.
Retrieves, but does not remove, the first element of this deque.
Queries the number of holds on this lock by the current thread.
Queries the number of holds on this write lock by the current
thread.
Returns the thread keep-alive time, which is the amount of time
which threads in excess of the core pool size may remain
idle before being terminated.
Returns the key corresponding to this entry.
Returns the key corresponding to this entry.
Returns the largest number of threads that have ever
simultaneously been in the pool.
Retrieves, but does not remove, the last element of this deque.
Retrieves, but does not remove, the last element of this deque.
Returns the maximum allowed number of threads.
Returns the number of parties currently waiting at the barrier.
Returns the thread that currently owns this lock, or
null
if not owned.
Returns the thread that currently owns the write lock, or
null
if not owned.
Returns the number of parties required to trip this barrier.
Returns the current number of threads in the pool.
Returns the task queue used by this executor.
Returns the task queue used by this executor.
Returns a collection containing threads that may be waiting to
acquire this lock.
Returns a collection containing threads that may be waiting to acquire.
Returns an estimate of the number of threads waiting to
acquire this lock.
Returns an estimate of the number of threads waiting to acquire
either the read or write lock.
Returns an estimate of the number of threads waiting to acquire.
Queries the number of reentrant read holds on this lock by the
current thread.
Queries the number of read locks held for this lock.
Returns the current value of the reference.
Returns the current value of the reference.
Returns the current handler for unexecutable tasks.
Returns the current value of the stamp.
Returns the approximate total number of tasks that have been
scheduled for execution.
Returns the thread factory used to create new threads.
Returns the value corresponding to this entry.
Returns the value corresponding to this entry.
Returns a collection containing those threads that may be
waiting on the given condition associated with this lock.
Returns an estimate of the number of threads waiting on the
given condition associated with this lock.
Queries the number of reentrant write holds on this lock by the
current thread.
Atomically increments by one the current value.
Atomically increments by one the current value.
Atomically increments by one the element at index i.
Atomically increments by one the element at index i.
Executes the given tasks, returning a list of Futures holding
their status and results when all complete.
Executes the given tasks, returning a list of Futures holding
their status and results
when all complete or the timeout expires, whichever happens first.
Executes the given tasks, returning the result
of one that has completed successfully (i.e., without throwing
an exception), if any do.
Executes the given tasks, returning the result
of one that has completed successfully (i.e., without throwing
an exception), if any do before the given timeout elapses.
Queries if this barrier is in a broken state.
Returns true if this task was cancelled before it completed
normally.
isDone() - method in class edu.emory.mathcs.backport.java.util.concurrent.
Future Returns true if this task completed.
Returns true if this deque contains no elements.
Returns true if this map contains no key-value mappings.
Returns true if this queue contains no elements.
Returns true if this map contains no key-value mappings.
Returns true if this set contains no elements.
Returns true if this set contains no elements.
Returns true if this queue contains no elements.
Returns true
if this lock has fairness set true.
Returns true
if this lock has fairness set true.
Returns true
if this semaphore has fairness set true.
Queries if this lock is held by the current thread.
Queries if this write lock is held by the current thread.
Queries if this lock is held by any thread.
Returns the current value of the mark.
Returns true if this is a periodic task.
Returns true if this executor has been shut down.
Returns true if this executor has been shut down.
Returns true if all tasks have completed following shut down.
Returns true if all tasks have completed following shut down.
Returns true if this executor is in the process of terminating
after shutdown or shutdownNow but has not
completely terminated.
Queries if the write lock is held by any thread.
Queries if the write lock is held by the current thread.
Returns an iterator over the elements in this queue in proper sequence.
Returns an iterator over the elements in this deque.
Returns an iterator over the elements in this deque in proper sequence.
Returns an iterator over the elements in this queue in proper sequence.
Returns an iterator over the elements in this set in ascending order.
Returns an iterator over the elements contained in this set
in the order in which these elements were added.
Returns an iterator over all the elements (both expired and
unexpired) in this queue.
Returns an iterator over the elements in this deque in proper sequence.
Returns an iterator over the elements in this deque in proper sequence.
Returns an iterator over the elements in this queue in proper sequence.
Returns an iterator over the elements in this set, in ascending order.
Returns an iterator over the elements in this queue.
Returns an iterator over the elements in this queue.
Returns an empty iterator in which hasNext always returns
false.
last() - method in class edu.emory.mathcs.backport.java.util.
TreeSet Returns a key-value mapping associated with the greatest
key in this map, or null if the map is empty.
Returns a key-value mapping associated with the greatest
key in this map, or null
if the map is empty.
Eventually sets to the given value.
Eventually sets to the given value.
Eventually sets the element at position i to the given value.
Eventually sets the element at position i to the given value.
Eventually sets the element at position i to the given value.
Eventually sets to the given value.
Eventually sets to the given value.
Returns the length of the array.
Returns the length of the array.
Returns the length of the array.
Creates a LinkedBlockingDeque with a capacity of
Integer.MAX_VALUE
.
Creates a LinkedBlockingDeque with a capacity of
Integer.MAX_VALUE
, initially containing the elements of
the given collection, added in traversal order of the
collection's iterator.
Creates a LinkedBlockingDeque with the given (fixed) capacity.
Creates a LinkedBlockingQueue with a capacity of
Integer.MAX_VALUE
.
Creates a LinkedBlockingQueue with a capacity of
Integer.MAX_VALUE
, initially containing the elements of the
given collection,
added in traversal order of the collection's iterator.
Creates a LinkedBlockingQueue with the given (fixed) capacity.
Lock - interface edu.emory.mathcs.backport.java.util.concurrent.locks.
Lock Lock
implementations provide more extensive locking
operations than can be obtained using synchronized
methods
and statements.
lock() - method in class edu.emory.mathcs.backport.java.util.concurrent.locks.
Lock Acquires the lock.
Acquires the lock unless the current thread is
interrupted.
Acquires the lock unless the current thread is
interrupted.
Acquires the read lock unless the current thread is
interrupted.
Acquires the write lock unless the current thread is
interrupted.
Returns the greatest element in this set strictly less than the
given element, or null
if there is no such element.
Returns a key-value mapping associated with the greatest key
strictly less than the given key, or null if there is
no such key.
Returns a key-value mapping associated with the greatest key
strictly less than the given key, or null
if there is
no such key.
Returns the greatest key strictly less than the given key, or
null
if there is no such key.
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 end of this deque.
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque) if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and false if no space is currently
available.
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.
Inserts the specified element at the tail of this queue.
Inserts the specified element into this delay queue.
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque) if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and false if no space is currently
available.
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 into the queue represented by this deque
(in other words, at the tail of this deque) if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and false if no space is currently
available.
Inserts the specified element into this priority queue.
Inserts the specified element into this priority queue.
Inserts the specified element into this queue if it is possible to do
so immediately without violating capacity restrictions.
Inserts the specified element into this queue, if another thread is
waiting to receive it.
Inserts the specified element at the tail of this queue, waiting
up to the specified wait time for space to become available if
the queue is full.
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque), waiting up to the
specified wait time if necessary for space to become available.
Inserts the specified element into this queue, waiting up to the
specified wait time if necessary for space to become available.
Inserts the specified element into this delay queue.
Inserts the specified element at the tail of this queue, waiting if
necessary up to the specified wait time for space to become available.
Inserts the specified element into this priority queue.
Inserts the specified element into this queue, waiting if necessary
up to the specified wait time for another thread to receive it.
Inserts the specified element at the front of this deque.
Inserts the specified element at the front of this deque if it is
possible to do so immediately without violating capacity restrictions,
returning true upon success and false if no space is
currently available.
Inserts the specified element at the front of this deque unless it would
violate capacity restrictions.
Inserts the specified element at the front of this deque unless it would
violate capacity restrictions.
Inserts the specified element at the front of this deque,
waiting up to the specified wait time if necessary for space to
become available.
Inserts the specified element at the end of this deque.
Inserts the specified element at the end of this deque if it is
possible to do so immediately without violating capacity restrictions,
returning true upon success and false if no space is
currently available.
Inserts the specified element at the end of this deque unless it would
violate capacity restrictions.
Inserts the specified element at the end of this deque unless it would
violate capacity restrictions.
Inserts the specified element at the end of this deque,
waiting up to the specified wait time if necessary for space to
become available.
Retrieves, but does not remove, the head of the queue represented by
this deque, or returns null if this deque is empty.
Retrieves, but does not remove, the head of the queue represented by
this deque (in other words, the first element of this deque), or
returns null if this deque is empty.
Retrieves, but does not remove, the head of this queue,
or returns null if this queue is empty.
peek() - method in class edu.emory.mathcs.backport.java.util.concurrent.
DelayQueue Retrieves, but does not remove, the head of this queue, or
returns null if this queue is empty.
peek() - method in class edu.emory.mathcs.backport.java.util.
Deque Retrieves, but does not remove, the head of the queue represented by
this deque (in other words, the first element of this deque), or
returns null if this deque is empty.
Retrieves, but does not remove, the head of the queue represented by
this deque (in other words, the first element of this deque), or
returns null if this deque is empty.
Retrieves, but does not remove, the head of this queue,
or returns null if this queue is empty.
Retrieves, but does not remove, the head of the queue represented by
this deque (in other words, the first element of this deque), or
returns null if this deque is empty.
Retrieves, but does not remove, the head of this queue,
or returns null if this queue is empty.
Retrieves, but does not remove, the head of this queue, or returns
null if this queue is empty.
peek() - method in class edu.emory.mathcs.backport.java.util.
Queue Retrieves, but does not remove, the head of this queue,
or returns null if this queue is empty.
Retrieves, but does not remove, the first element of this deque,
or returns null if this deque is empty.
Retrieves, but does not remove, the first element of this deque,
or returns null if this deque is empty.
Retrieves, but does not remove, the first element of this deque,
or returns null if this deque is empty.
Retrieves, but does not remove, the first element of this deque,
or returns null if this deque is empty.
Retrieves, but does not remove, the last element of this deque,
or returns null if this deque is empty.
Retrieves, but does not remove, the last element of this deque,
or returns null if this deque is empty.
Retrieves, but does not remove, the last element of this deque,
or returns null if this deque is empty.
Retrieves, but does not remove, the last element of this deque,
or returns null if this deque is empty.
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), or returns
null if this deque is empty.
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), or returns
null if this deque is empty.
Retrieves and removes the Future representing the next
completed task or null if none are present.
Retrieves and removes the head of this queue,
or returns null if this queue is empty.
poll() - method in class edu.emory.mathcs.backport.java.util.concurrent.
DelayQueue Retrieves and removes the head of this queue, or returns null
if this queue has no elements with an expired delay.
poll() - method in class edu.emory.mathcs.backport.java.util.
Deque Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), or returns
null if this deque is empty.
Retrieves and removes the Future representing the next
completed task or null if none are present.
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), or returns
null if this deque is empty.
Retrieves and removes the head of this queue,
or returns null if this queue is empty.
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), or returns
null if this deque is empty.
Retrieves and removes 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.
poll() - method in class edu.emory.mathcs.backport.java.util.
Queue Retrieves and removes the head of this queue,
or returns null if this queue is empty.
Retrieves and removes the head of this queue, if another thread
is currently making an element available.
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), waiting up to the
specified wait time if necessary for an element to become available.
Retrieves and removes the head of this queue, waiting up to the
specified wait time if necessary for an element to become available.
Retrieves and removes the Future representing the next
completed task, waiting if necessary up to the specified wait
time if none are yet present.
Retrieves and removes the head of this queue, waiting if necessary
until an element with an expired delay is available on this queue,
or the specified wait time expires.
Retrieves and removes the Future representing the next
completed task, waiting if necessary up to the specified wait
time if none are yet present.
Retrieves and removes the head of this queue, waiting up to the
specified wait time if necessary for an element to become available.
Retrieves and removes the head of this queue, waiting
if necessary up to the specified wait time, for another thread
to insert it.
Retrieves and removes the first element of this deque,
or returns null if this deque is empty.
Retrieves and removes the first element of this deque,
or returns null if this deque is empty.
Retrieves and removes the first element of this deque,
or returns null if this deque is empty.
Retrieves and removes the first element of this deque,
or returns null if this deque is empty.
Retrieves and removes the first (lowest) element,
or returns null
if this set is empty.
Retrieves and removes the first element of this deque, waiting
up to the specified wait time if necessary for an element to
become available.
Removes and returns a key-value mapping associated with
the least key in this map, or null if the map is empty.
Removes and returns a key-value mapping associated with
the least key in this map, or null
if the map is empty.
Retrieves and removes the last element of this deque,
or returns null if this deque is empty.
Retrieves and removes the last element of this deque,
or returns null if this deque is empty.
Retrieves and removes the last element of this deque,
or returns null if this deque is empty.
Retrieves and removes the last element of this deque,
or returns null if this deque is empty.
Retrieves and removes the last (highest) element,
or returns null
if this set is empty.
Retrieves and removes the last element of this deque, waiting
up to the specified wait time if necessary for an element to
become available.
Removes and returns a key-value mapping associated with
the greatest key in this map, or null if the map is empty.
Removes and returns a key-value mapping associated with
the greatest key in this map, or null
if the map is empty.
Pops an element from the stack represented by this deque.
pop() - method in class edu.emory.mathcs.backport.java.util.
Deque Pops an element from the stack represented by this deque.
Pops an element from the stack represented by this deque.
Starts all core threads, causing them to idly wait for work.
Starts a core thread, causing it to idly wait for work.
Creates a PriorityBlockingQueue with the default
initial capacity (11) that orders its elements according to
their natural ordering.
Creates a PriorityBlockingQueue containing the elements
in the specified collection.
Creates a PriorityBlockingQueue with the specified
initial capacity that orders its elements according to their
natural ordering.
Creates a PriorityBlockingQueue with the specified initial
capacity that orders its elements according to the specified
comparator.
An unbounded
queue that supports element retrieval
in the order of relative priority.
Creates a PriorityQueue with the default
initial capacity (11) that orders its elements according to
their natural ordering.
Creates a PriorityQueue containing the elements
in the specified collection.
Creates a PriorityQueue with the specified initial
capacity that orders its elements according to the specified
comparator.
Creates a PriorityQueue containing the elements from
the specified priority queue.
Creates a PriorityQueue with the specified
initial capacity that orders its elements according to their
natural ordering.
Creates a PriorityQueue containing the elements
from the specified sorted set.
Returns a
Callable
object that will, when
called, execute the given
callable under the current
access control context.
Returns a
Callable
object that will, when
called, execute the given
callable under the current
access control context, with the current context class loader
as the context class loader.
Returns a thread factory used to create new threads that
have the same permissions as the current thread.
Tries to remove from the work queue all
Future
tasks that have been cancelled.
Pushes an element onto the stack represented by this deque.
Pushes an element onto the stack represented by this deque.
Pushes an element onto the stack represented by this deque (in other
words, at the head of this deque) 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.
Pushes an element onto the stack represented by this deque (in other
words, at the head of this deque) 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.
Inserts the specified element at the tail of this queue, waiting
for space to become available if the queue is full.
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque), waiting if necessary for
space to become available.
Inserts the specified element into this queue, waiting if necessary
for space to become available.
Inserts the specified element into this delay queue.
Inserts the specified element at the tail of this queue, waiting if
necessary for space to become available.
Inserts the specified element into this priority queue.
Adds the specified element to this queue, waiting if necessary for
another thread to receive it.
Maps the specified key to the specified value in this table.
Associates the specified value with the specified key in this map.
Copies all of the mappings from the specified map to this one.
Inserts the specified element at the front of this deque,
waiting if necessary for space to become available.
If the specified key is not already associated
with a value, associate it with the given value.
Inserts the specified element at the end of this deque,
waiting if necessary for space to become available.
Returns the lock used for reading.
Constructor for use by subclasses
A
ReadWriteLock maintains a pair of associated
locks
, one for read-only operations and one for writing.
Shrinks the number of available permits by the indicated
reduction.
A reentrant mutual exclusion
Lock
with the same basic
behavior and semantics as the implicit monitor lock accessed using
synchronized
methods and statements, but with extended
capabilities.
Creates an instance of ReentrantLock
.
Creates an instance of ReentrantLock
with the
given fairness policy.
Creates a new ReentrantReadWriteLock
with
default (nonfair) ordering properties.
Always throws RejectedExecutionException.
Executes task r in the caller's thread, unless the executor
has been shut down, in which case the task is discarded.
Obtains and ignores the next task that the executor
would otherwise execute, if one is immediately available,
and then retries execution of task r, unless the executor
is shut down, in which case task r is instead discarded.
Does nothing, which has the effect of discarding task r.
Exception thrown by an
Executor
when a task cannot be
accepted for execution.
Constructs a RejectedExecutionException with no detail message.
Constructs a RejectedExecutionException with the
specified detail message.
Constructs a RejectedExecutionException with the
specified detail message and cause.
Constructs a RejectedExecutionException with the
specified cause.
Releases a permit, returning it to the semaphore.
Releases the given number of permits, returning them to the semaphore.
Returns the number of additional elements that this queue can ideally
(in the absence of memory or resource constraints) accept without
blocking.
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.
Always returns Integer.MAX_VALUE because
a DelayQueue is not capacity constrained.
Returns the number of additional elements that this deque can ideally
(in the absence of memory or resource constraints) accept without
blocking.
Returns the number of additional elements that this queue can ideally
(in the absence of memory or resource constraints) accept without
blocking.
Always returns Integer.MAX_VALUE because
a PriorityBlockingQueue is not capacity constrained.
Retrieves and removes the head of this queue.
Retrieves and removes the head of the queue represented by this deque.
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque).
remove() - method in class edu.emory.mathcs.backport.java.util.
Deque Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque).
Retrieves and removes the head of the queue represented by this deque.
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque).
Retrieves and removes the head of this queue.
remove() - method in class edu.emory.mathcs.backport.java.util.
Queue Retrieves and removes the head of this queue.
Removes a single instance of the specified element from this queue,
if it is present.
Removes a single instance of the specified element from this deque.
Removes the first occurrence of the specified element from this deque.
Removes a single instance of the specified element from this queue,
if it is present.
Removes the key (and its corresponding value) from this map.
Removes a single instance of the specified element from this queue,
if it is present.
Removes the mapping for the specified key from this map if present.
Removes the specified element from this set if it is present.
Removes the specified element from this set if it is present.
Removes a single instance of the specified element from this
queue, if it is present, whether or not it has expired.
Removes the first occurrence of the specified element from this deque.
Removes the first occurrence of the specified element from this deque.
Removes a single instance of the specified element from this queue,
if it is present.
Removes the first occurrence of the specified element from this deque.
Removes a single instance of the specified element from this queue,
if it is present.
Removes a single instance of the specified element from this queue,
if it is present.
Removes the entry for a key only if currently mapped to a given value.
Removes this task from the executor's internal queue if it is
present, thus causing it not to be run if it has not already
started.
Removes from this set all of its elements that are contained in
the specified collection.
Removes from this set all of its elements that are contained in the
specified collection.
Retrieves and removes the first element of this deque.
Retrieves and removes the first element of this deque.
Removes the first occurrence of the specified element in this
deque (when traversing the deque from head to tail).
Removes the first occurrence of the specified element from this deque.
Removes the first occurrence of the specified element from this deque.
Removes the first occurrence of the specified element from this deque.
Removes the first occurrence of the specified element from this deque.
Retrieves and removes the last element of this deque.
Retrieves and removes the last element of this deque.
Removes the last occurrence of the specified element in this
deque (when traversing the deque from head to tail).
Removes the last occurrence of the specified element from this deque.
Removes the last occurrence of the specified element from this deque.
Removes the last occurrence of the specified element from this deque.
Removes the last occurrence of the specified element from this deque.
Replaces the entry for a key only if currently mapped to some value.
Replaces the entry for a key only if currently mapped to a given value.
Resets the barrier to its initial state.
Retains only the elements in this set that are contained in the
specified collection.
run() - method in class edu.emory.mathcs.backport.java.util.concurrent.
FutureTask Sets this Future to the result of its computation
unless it has been cancelled.
Sets this Future to the result of its computation
unless it has been cancelled.
Executes the computation without setting its result, and then
resets this Future to initial state, failing to do so if the
computation encounters an exception or is cancelled.
Creates and executes a ScheduledFuture that becomes enabled after the
given delay.
Creates and executes a one-shot action that becomes enabled
after the given delay.
Creates and executes a periodic action that becomes enabled first
after the given initial delay, and subsequently with the given
period; that is executions will commence after
initialDelay then initialDelay+period, then
initialDelay + 2 * period, and so on.
An
ExecutorService
that can schedule commands to run after a given
delay, or to execute periodically.
A delayed result-bearing action that can be cancelled.
A
ThreadPoolExecutor
that can additionally schedule
commands to run after a given delay, or to execute
periodically.
Creates a new ScheduledThreadPoolExecutor with the given core
pool size.
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
Creates and executes a periodic action that becomes enabled first
after the given initial delay, and subsequently with the
given delay between the termination of one execution and the
commencement of the next.
SECONDS - static field in class edu.emory.mathcs.backport.java.util.concurrent.
TimeUnit Creates a Semaphore
with the given number of
permits and nonfair fairness setting.
Creates a Semaphore
with the given number of
permits and the given fairness setting.
Unconditionally sets to the given value.
Sets the element at position i to the given value.
Sets the element at position i to the given value.
Sets the element at position i to the given value.
Sets the result of this Future to the given value unless
this future has already been set or has been cancelled.
Unconditionally sets the value of both the reference and mark.
Unconditionally sets the value of both the reference and stamp.
Sets the policy on whether to continue executing existing periodic
tasks even when this executor has been shutdown.
Sets the core number of threads.
Causes this future to report an ExecutionException
with the given throwable as its cause, unless this Future has
already been set or has been cancelled.
Sets the policy on whether to execute existing delayed
tasks even when this executor has been shutdown.
Sets the time limit for which threads may remain idle before
being terminated.
Sets the maximum allowed number of threads.
Sets a new handler for unexecutable tasks.
Sets the thread factory used to create new threads.
Replaces the value corresponding to this entry with the specified
value.
Replaces the value corresponding to this entry with the specified
value (optional operation).
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be accepted.
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be accepted.
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be
accepted.
Attempts to stop all actively executing tasks, halts the
processing of waiting tasks, and returns a list of the tasks that were
awaiting execution.
Attempts to stop all actively executing tasks, halts the
processing of waiting tasks, and returns a list of the tasks
that were awaiting execution.
Attempts to stop all actively executing tasks, halts the
processing of waiting tasks, and returns a list of the tasks
that were awaiting execution.
signal() - method in class edu.emory.mathcs.backport.java.util.concurrent.locks.
Condition Wakes up one waiting thread.
Wakes up all waiting threads.
An Entry maintaining a key and a value.
Creates an entry representing the same mapping as the
specified entry.
Creates an entry representing a mapping from the specified
key to the specified value.
An Entry maintaining an immutable key and value, This class
does not support method setValue.
Creates an entry representing the same mapping as the
specified entry.
Creates an entry representing a mapping from the specified
key to the specified value.
Returns the number of elements in this queue.
Returns the number of elements in this deque.
Returns the number of elements in this deque.
Returns the number of key-value mappings in this map.
Returns the number of elements in this queue.
Returns the number of key-value mappings in this map.
Returns the number of elements in this set.
Returns the number of elements in this set.
size() - method in class edu.emory.mathcs.backport.java.util.concurrent.
DelayQueue size() - method in class edu.emory.mathcs.backport.java.util.
Deque Returns the number of elements in this deque.
Returns the number of elements in this deque.
Returns the number of elements in this queue.
Returns the number of elements in this deque.
Returns the number of elements in this priority queue.
size() - method in class edu.emory.mathcs.backport.java.util.
TreeMap size() - method in class edu.emory.mathcs.backport.java.util.
TreeSet Performs a Thread.sleep using this unit.
Returns a view of the portion of this map whose keys range from
fromKey
to toKey
.
Returns a view of the portion of this map whose keys range from
fromKey
to toKey
.
Equivalent to subMap(fromKey, true, toKey, false)
.
Equivalent to subMap(fromKey, true, toKey, false)
.
Submits a value-returning task for execution and returns a Future
representing the pending results of the task.
Submits a value-returning task for execution and returns a Future
representing the pending results of the task.
Submits a value-returning task for execution and returns a
Future representing the pending results of the task.
Submits a Runnable task for execution and returns a Future
representing that task.
Submits a Runnable task for execution and returns a Future
representing that task.
Submits a Runnable task for execution and returns a Future
representing that task.
Submits a Runnable task for execution and returns a Future
representing that task.
Returns a view of the portion of this set whose elements range from
fromElement
to toElement
.
Equivalent to subSet(fromElement, true, toElement, false)
.
A
blocking queue in which each insert
operation must wait for a corresponding remove operation by another
thread, and vice versa.
Creates a SynchronousQueue with nonfair access policy.
Creates a SynchronousQueue with specified fairness policy.
tail_ - field in class edu.emory.mathcs.backport.java.util.concurrent.helpers.
FIFOWaitQueue
Equivalent to tailMap(fromKey, true)
.
Equivalent to tailMap(fromKey, true)
.
Returns a view of the portion of this map whose keys are greater than (or
equal to, if inclusive
is true) fromKey
.
Returns a view of the portion of this map whose keys are greater than (or
equal to, if inclusive
is true) fromKey
.
Equivalent to tailSet(fromElement, true)
.
Returns a view of the portion of this set whose elements are greater
than (or equal to, if inclusive
is true) fromElement
.
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), waiting if
necessary until an element becomes available.
Retrieves and removes the head of this queue, waiting if necessary
until an element becomes available.
Retrieves and removes the Future representing the next
completed task, waiting if none are yet present.
take() - method in class edu.emory.mathcs.backport.java.util.concurrent.
DelayQueue Retrieves and removes the head of this queue, waiting if necessary
until an element with an expired delay is available on this queue.
Retrieves and removes the Future representing the next
completed task, waiting if none are yet present.
Retrieves and removes the head of this queue, waiting if necessary
until an element becomes available.
Retrieves and removes the head of this queue, waiting if necessary
for another thread to insert it.
Retrieves and removes the first element of this deque, waiting
if necessary until an element becomes available.
Retrieves and removes the last element of this deque, waiting
if necessary until an element becomes available.
Method invoked when the Executor has terminated.
An object that creates new threads on demand.
Emulation of some new functionality present in java.lang.Thread in J2SE 5.0.
An
ExecutorService
that executes each submitted task using
one of possibly several pooled threads, normally configured
using
Executors
factory methods.
Creates a new ThreadPoolExecutor with the given initial
parameters and default thread factory and rejected execution handler.
Creates a new ThreadPoolExecutor with the given initial
parameters and default thread factory.
Creates a new ThreadPoolExecutor with the given initial
parameters and default rejected execution handler.
Creates a new ThreadPoolExecutor with the given initial
parameters.
Performs a timed Thread.join using this time unit.
Performs a timed Object.wait using this time unit.
Exception thrown when a blocking operation times out.
Constructs a TimeoutException with no specified detail
message.
Constructs a TimeoutException with the specified detail
message.
A TimeUnit represents time durations at a given unit of
granularity and provides utility methods to convert across units,
and to perform timing and delay operations in these units.
Returns an array containing all of the elements in this queue, in
proper sequence.
Returns an array containing all of the elements in this deque
in proper sequence (from first to last element).
Returns an array containing all of the elements in this set.
Returns an array containing all of the elements in this queue.
Returns an array containing all of the elements in this deque, in
proper sequence (from first to last element).
Returns an array containing all of the elements in this queue, in
proper sequence.
Returns an array containing all of the elements in this queue.
Returns an array containing all of the elements in this queue.
Returns a zero-length array.
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 deque in
proper sequence (from first to last element); the runtime type of the
returned array is that of the specified array.
Returns an array containing all of the elements in this set; the
runtime type of the returned array is that of the specified array.
Returns an array containing all of the elements in this queue; the
runtime type of the returned array is that of the specified array.
Returns an array containing all of the elements in this deque, in
proper sequence; the runtime type of the returned array is that of
the specified array.
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; the
runtime type of the returned array is that of the specified array.
Returns an array containing all of the elements in this queue; the
runtime type of the returned array is that of the specified array.
Sets the zeroeth element of the specified array to null
(if the array has non-zero length) and returns it.
Equivalent to DAYS.convert(duration, this).
Equivalent to HOURS.convert(duration, this).
Equivalent to MICROSECONDS.convert(duration, this).
Equivalent to MILLISECONDS.convert(duration, this).
Equivalent to MINUTES.convert(duration, this).
Equivalent to NANOSECONDS.convert(duration, this).
Equivalent to SECONDS.convert(duration, this).
Returns a String representation of this map entry.
Returns a String representation of this map entry.
Returns the String representation of the current value.
Returns the String representation of the current value.
Returns the String representation of the current values of array.
Returns the String representation of the current value.
Returns the String representation of the current values of array.
Returns the String representation of the current value.
Returns the String representation of the current values of array.
Returns a string identifying this latch, as well as its state.
Returns a string identifying this lock, as well as its lock state.
Returns a string identifying this lock, as well as its lock state.
Returns a string identifying this lock, as well as its lock state.
Returns a string identifying this lock, as well as its lock
state.
Returns a string identifying this semaphore, as well as its state.
Sorted map implementation based on a red-black tree and implementing
all the methods from the NavigableMap interface.
Acquires a permit from this semaphore, only if one is available at the
time of invocation.
Acquires the given number of permits from this semaphore, only
if all are available at the time of invocation.
Acquires the given number of permits from this semaphore, if all
become available within the given waiting time and the current
thread has not been interrupted.
Acquires a permit from this semaphore, if one becomes available
within the given waiting time and the current thread has not
been interrupted.
tryLock() - method in class edu.emory.mathcs.backport.java.util.concurrent.locks.
Lock Acquires the lock only if it is free at the time of invocation.
Acquires the lock only if it is not held by another thread at the time
of invocation.
Acquires the read lock only if the write lock is not held by
another thread at the time of invocation.
Acquires the write lock only if it is not held by another thread
at the time of invocation.
Acquires the lock if it is free within the given waiting time and the
current thread has not been interrupted.
Acquires the lock if it is not held by another thread within the given
waiting time and the current thread has not been
interrupted.
Acquires the read lock if the write lock is not held by
another thread within the given waiting time and the
current thread has not been interrupted.
Acquires the write lock if it is not held by another thread
within the given waiting time and the current thread has
not been interrupted.