A B C D E F G H I K L M N O P Q R S T U V W

A

AbstractExecutorService - class edu.emory.mathcs.util.concurrent.AbstractExecutorService.
Provides default implementation of ExecutorService execution methods.
AbstractExecutorService() - Constructor for class edu.emory.mathcs.util.concurrent.AbstractExecutorService
 
AbstractQueue - class edu.emory.mathcs.util.AbstractQueue.
This class provides skeletal implementations of some Queue operations.
AbstractQueue() - Constructor for class edu.emory.mathcs.util.AbstractQueue
Constructor for use by subclasses.
acquire() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Acquires a permit from this semaphore, blocking until one is available, or the thread is interrupted.
acquireUninterruptibly() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Acquires a permit from this semaphore, blocking until one is available.
add(int, Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Inserts the specified element at the specified position in this list.
add(Object) - Method in class edu.emory.mathcs.util.PriorityQueue
Adds the specified element to this queue.
add(Object) - Method in class edu.emory.mathcs.util.AbstractQueue
Adds the specified element to this queue.
add(Object) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Adds the specified element to this queue.
add(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Appends the specified element to the end of this list.
add(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
add(Object) - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Adds the specified element to this queue.
add(Object) - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Adds the specified element to this queue if it is possible to do so immediately, returning true upon success, else throwing an IllegalStateException.
addAll(Collection) - Method in class edu.emory.mathcs.util.AbstractQueue
Adds all of the elements in the specified collection to this queue.
addAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Appends all of the elements in the specified Collection to the end of this list, in the order that they are returned by the specified Collection's Iterator.
addAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
addAll(int, Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Inserts all of the elements in the specified Collection into this list, starting at the specified position.
addAllAbsent(Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Appends all of the elements in the specified Collection that are not already contained in this list, to the end of this list, in the order that they are returned by the specified Collection's Iterator.
addAndGet(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Atomically add the given value to current value.
addAndGet(int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Atomically add the given value to element at index i.
addAndGet(int, long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Atomically add the given value to element at index i.
addAndGet(long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Atomically add the given value to current value.
addIfAbsent(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Append the element if not present.
afterExecute(Runnable, Throwable) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Method invoked upon completion of execution of the given Runnable.
allowTake() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Notify a waiting take if needed
ArrayBlockingQueue - class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue.
A bounded blocking queue backed by an array.
ArrayBlockingQueue(int) - Constructor for class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Creates an ArrayBlockingQueue with the given (fixed) capacity and default access policy.
ArrayBlockingQueue(int, boolean) - Constructor for class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Creates an ArrayBlockingQueue with the given (fixed) capacity and the specified access policy.
ArrayBlockingQueue(int, boolean, Collection) - Constructor for class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
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.
AtomicBoolean - class edu.emory.mathcs.util.concurrent.atomic.AtomicBoolean.
A boolean value that may be updated atomically.
AtomicBoolean() - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicBoolean
Creates a new AtomicBoolean with initial value false.
AtomicBoolean(boolean) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicBoolean
Creates a new AtomicBoolean with the given initial value.
AtomicInteger - class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger.
An int value that may be updated atomically.
AtomicInteger() - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Create a new AtomicInteger with initial value 0.
AtomicInteger(int) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Create a new AtomicInteger with the given initial value.
AtomicIntegerArray - class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray.
An int array in which elements may be updated atomically.
AtomicIntegerArray(int) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Create a new AtomicIntegerArray of given length.
AtomicIntegerArray(int[]) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Create a new AtomicIntegerArray with the same length as, and all elements copied from, the given array.
AtomicLong - class edu.emory.mathcs.util.concurrent.atomic.AtomicLong.
A long value that may be updated atomically.
AtomicLong() - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Create a new AtomicLong with initial value 0.
AtomicLong(long) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Create a new AtomicLong with the given initial value.
AtomicLongArray - class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray.
A long array in which elements may be updated atomically.
AtomicLongArray(int) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Create a new AtomicLongArray of given length.
AtomicLongArray(long[]) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Create a new AtomicLongArray with the same length as, and all elements copied from, the given array.
AtomicMarkableReference - class edu.emory.mathcs.util.concurrent.atomic.AtomicMarkableReference.
An AtomicMarkableReference maintains an object reference along with a mark bit, that can be updated atomically.
AtomicMarkableReference(Object, boolean) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicMarkableReference
Creates a new AtomicMarkableReference with the given initial values.
AtomicReference - class edu.emory.mathcs.util.concurrent.atomic.AtomicReference.
An object reference that may be updated atomically.
AtomicReference() - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicReference
Create a new AtomicReference with null initial value.
AtomicReference(Object) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicReference
Create a new AtomicReference with the given initial value.
AtomicReferenceArray - class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray.
An array of object references in which elements may be updated atomically.
AtomicReferenceArray(int) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray
Create a new AtomicReferenceArray of given length.
AtomicReferenceArray(Object[]) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray
Create a new AtomicReferenceArray with the same length as, and all elements copied from, the given array.
AtomicStampedReference - class edu.emory.mathcs.util.concurrent.atomic.AtomicStampedReference.
An AtomicStampedReference maintains an object reference along with an integer "stamp", that can be updated atomically.
AtomicStampedReference(Object, int) - Constructor for class edu.emory.mathcs.util.concurrent.atomic.AtomicStampedReference
Creates a new AtomicStampedReference with the given initial values.
attemptMark(Object, boolean) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicMarkableReference
Atomically sets the value of the mark to the given update value if the current reference is == to the expected reference.
attemptStamp(Object, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicStampedReference
Atomically sets the value of the stamp to the given update value if the current reference is == to the expected reference.
availablePermits() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Returns the current number of permits available in this semaphore.
await() - Method in class edu.emory.mathcs.util.concurrent.CountDownLatch
Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted.
await() - Method in class edu.emory.mathcs.util.concurrent.CyclicBarrier
Waits until all parties have invoked await on this barrier.
await() - Method in interface edu.emory.mathcs.util.concurrent.locks.Condition
Causes the current thread to wait until it is signalled or interrupted.
await(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.CountDownLatch
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.
await(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.CyclicBarrier
Waits until all parties have invoked await on this barrier.
await(long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.locks.Condition
Causes the current thread to wait until it is signalled or interrupted, or the specified waiting time elapses.
awaitNanos(Condition, long) - Static method in class edu.emory.mathcs.util.concurrent.helpers.Utils
Warning; this method is rather inefficient and prone to inaccuracies and truncation errors.
awaitTermination(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
 
awaitTermination(long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.
awaitUninterruptibly() - Method in interface edu.emory.mathcs.util.concurrent.locks.Condition
Causes the current thread to wait until it is signalled.
awaitUntil(Date) - Method in interface edu.emory.mathcs.util.concurrent.locks.Condition
Causes the current thread to wait until it is signalled or interrupted, or the specified deadline elapses.

B

beforeExecute(Thread, Runnable) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Method invoked prior to executing the given Runnable in the given thread.
BlockingQueue - interface edu.emory.mathcs.util.concurrent.BlockingQueue.
A java.util.Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.
BrokenBarrierException - exception edu.emory.mathcs.util.concurrent.BrokenBarrierException.
Exception thrown when a thread tries to wait upon a barrier that is in a broken state, or which enters the broken state while the thread is waiting.
BrokenBarrierException() - Constructor for class edu.emory.mathcs.util.concurrent.BrokenBarrierException
Constructs a BrokenBarrierException with no specified detail message.
BrokenBarrierException(String) - Constructor for class edu.emory.mathcs.util.concurrent.BrokenBarrierException
Constructs a BrokenBarrierException with the specified detail message.

C

call() - Method in interface edu.emory.mathcs.util.concurrent.Callable
Computes a result, or throws an exception if unable to do so.
Callable - interface edu.emory.mathcs.util.concurrent.Callable.
A task that returns a result and may throw an exception.
callable(PrivilegedAction) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Returns a Callable object that, when called, runs the given privileged action and returns its result.
callable(PrivilegedExceptionAction) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Returns a Callable object that, when called, runs the given privileged exception action and returns its result.
callable(Runnable) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Returns a Callable object that, when called, runs the given task and returns null.
callable(Runnable, Object) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Returns a Callable object that, when called, runs the given task and returns the given result.
cancel(boolean) - Method in class edu.emory.mathcs.util.concurrent.FutureTask
 
cancel(boolean) - Method in interface edu.emory.mathcs.util.concurrent.Future
Attempts to cancel execution of this task.
CancellationException - exception edu.emory.mathcs.util.concurrent.CancellationException.
Exception indicating that the result of a value-producing task, such as a FutureTask, cannot be retrieved because the task was cancelled.
CancellationException() - Constructor for class edu.emory.mathcs.util.concurrent.CancellationException
Constructs a CancellationException with no detail message.
CancellationException(String) - Constructor for class edu.emory.mathcs.util.concurrent.CancellationException
Constructs a CancellationException with the specified detail message.
capacity_ - Variable in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Number of elements allowed
clear() - Method in class edu.emory.mathcs.util.PriorityQueue
Removes all elements from the priority queue.
clear() - Method in class edu.emory.mathcs.util.AbstractQueue
Removes all of the elements from this collection.
clear() - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Removes all mappings from this map.
clear() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Atomically removes all of the elements from this queue.
clear() - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Atomically removes all of the elements from this queue.
clear() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Removes all of the elements from this list.
clear() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
clear() - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Atomically removes all of the elements from this delay queue.
clear() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Does nothing.
clear() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Atomically removes all of the elements from this queue.
clone() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns a shallow copy of this list.
comparator() - Method in class edu.emory.mathcs.util.PriorityQueue
Returns the comparator used to order this collection, or null if this collection is sorted according to its elements natural ordering (using Comparable).
comparator() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Returns the comparator used to order this collection, or null if this collection is sorted according to its elements natural ordering (using Comparable).
compareAndSet(boolean, boolean) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicBoolean
Atomically set the value to the given updated value if the current value == the expected value.
compareAndSet(int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Atomically set the value to the given updated value if the current value == the expected value.
compareAndSet(int, int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Atomically set the value to the given updated value if the current value == the expected value.
compareAndSet(int, long, long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Atomically set the value to the given updated value if the current value == the expected value.
compareAndSet(int, Object, Object) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray
Atomically set the value to the given updated value if the current value == the expected value.
compareAndSet(long, long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Atomically set the value to the given updated value if the current value == the expected value.
compareAndSet(Object, Object) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReference
Atomically set the value to the given updated value if the current value == the expected value.
compareAndSet(Object, Object, boolean, boolean) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicMarkableReference
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.
compareAndSet(Object, Object, int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicStampedReference
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.
CompletionService - interface edu.emory.mathcs.util.concurrent.CompletionService.
A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.
ConcurrentHashMap - class edu.emory.mathcs.util.concurrent.ConcurrentHashMap.
A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates.
ConcurrentHashMap() - Constructor for class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Creates a new, empty map with a default initial capacity, load factor, and concurrencyLevel.
ConcurrentHashMap(int) - Constructor for class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Creates a new, empty map with the specified initial capacity, and with default load factor and concurrencyLevel.
ConcurrentHashMap(int, float, int) - Constructor for class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Creates a new, empty map with the specified initial capacity and the specified load factor.
ConcurrentHashMap(Map) - Constructor for class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Creates a new map with the same mappings as the given map.
ConcurrentMap - interface edu.emory.mathcs.util.concurrent.ConcurrentMap.
A Map providing additional atomic putIfAbsent, remove, and replace methods.
Condition - interface edu.emory.mathcs.util.concurrent.locks.Condition.
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.
contains(Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Legacy method testing if some key maps into the specified value in this table.
contains(Object) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
contains(Object) - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
contains(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns true if this list contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
contains(Object) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Always returns false.
containsAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns true if this Collection contains all of the elements in the specified Collection.
containsAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
containsAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Returns false unless given collection is empty.
containsKey(Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Tests if the specified object is a key in this table.
containsValue(Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Returns true if this map maps one or more keys to the specified value.
convert(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Convert the given time duration in the given unit to this unit.
CopyOnWriteArrayList - class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList.
A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.
CopyOnWriteArrayList() - Constructor for class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Creates an empty list.
CopyOnWriteArrayList(Collection) - Constructor for class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Creates a list containing the elements of the specified Collection, in the order they are returned by the Collection's iterator.
CopyOnWriteArrayList(Object[]) - Constructor for class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Create a new CopyOnWriteArrayList holding a copy of given array.
CopyOnWriteArraySet - class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet.
A Set that uses java.util.concurrent.CopyOnWriteArrayList for all of its operations.
CopyOnWriteArraySet() - Constructor for class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
Creates an empty set.
CopyOnWriteArraySet(Collection) - Constructor for class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
Creates a set containing all of the elements of the specified Collection.
countDown() - Method in class edu.emory.mathcs.util.concurrent.CountDownLatch
Decrements the count of the latch, releasing all waiting threads if the count reaches zero.
CountDownLatch - class edu.emory.mathcs.util.concurrent.CountDownLatch.
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
CountDownLatch(int) - Constructor for class edu.emory.mathcs.util.concurrent.CountDownLatch
Constructs a CountDownLatch initialized with the given count.
CyclicBarrier - class edu.emory.mathcs.util.concurrent.CyclicBarrier.
A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
CyclicBarrier(int) - Constructor for class edu.emory.mathcs.util.concurrent.CyclicBarrier
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 upon each barrier.
CyclicBarrier(int, Runnable) - Constructor for class edu.emory.mathcs.util.concurrent.CyclicBarrier
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.

D

decrementAndGet() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Atomically decrement by one the current value.
decrementAndGet() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Atomically decrement by one the current value.
decrementAndGet(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Atomically decrement the element at index i.
decrementAndGet(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Atomically decrement by one the element at index i.
defaultThreadFactory() - Static method in class edu.emory.mathcs.util.concurrent.Executors
Returns a default thread factory used to create new threads.
Delayed - interface edu.emory.mathcs.util.concurrent.Delayed.
A mix-in style interface for marking objects that should be acted upon after a given delay.
DelayQueue - class edu.emory.mathcs.util.concurrent.DelayQueue.
An unbounded blocking queue of Delayed elements, in which an element can only be taken when its delay has expired.
DelayQueue() - Constructor for class edu.emory.mathcs.util.concurrent.DelayQueue
Creates a new DelayQueue that is initially empty.
DelayQueue(Collection) - Constructor for class edu.emory.mathcs.util.concurrent.DelayQueue
Creates a DelayQueue initially containing the elements of the given collection of Delayed instances.
done() - Method in class edu.emory.mathcs.util.concurrent.FutureTask
Protected method invoked when this task transitions to state isDone (whether normally or via cancellation).
doTimedWait(WaitQueue.QueuedSync, long) - Method in class edu.emory.mathcs.util.concurrent.helpers.WaitQueue.WaitNode
 
doubleValue() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
 
doubleValue() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
 
doWait(WaitQueue.QueuedSync) - Method in class edu.emory.mathcs.util.concurrent.helpers.WaitQueue.WaitNode
 
drainPermits() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Acquire and return all permits that are immediately available.
drainTo(Collection) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
drainTo(Collection) - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
drainTo(Collection) - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
 
drainTo(Collection) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
drainTo(Collection) - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
 
drainTo(Collection) - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Removes all available elements from this queue and adds them into the given collection.
drainTo(Collection, int) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
drainTo(Collection, int) - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
drainTo(Collection, int) - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
 
drainTo(Collection, int) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
drainTo(Collection, int) - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
 
drainTo(Collection, int) - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Removes at most the given number of available elements from this queue and adds them into the given collection.

E

edu.emory.mathcs.util - package edu.emory.mathcs.util
 
edu.emory.mathcs.util.concurrent - package edu.emory.mathcs.util.concurrent
 
edu.emory.mathcs.util.concurrent.atomic - package edu.emory.mathcs.util.concurrent.atomic
 
edu.emory.mathcs.util.concurrent.helpers - package edu.emory.mathcs.util.concurrent.helpers
 
edu.emory.mathcs.util.concurrent.locks - package edu.emory.mathcs.util.concurrent.locks
 
element() - Method in interface edu.emory.mathcs.util.Queue
Retrieves, but does not remove, the head of this queue.
element() - Method in class edu.emory.mathcs.util.AbstractQueue
Retrieves, but does not remove, the head of this queue.
elements() - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Returns an enumeration of the values in this table.
entrySet() - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Returns a collection view of the mappings contained in this map.
equals(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Compares the specified Object with this List for equality.
exchange(Object) - Method in class edu.emory.mathcs.util.concurrent.Exchanger
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.
exchange(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.Exchanger
Waits for another thread to arrive at this exchange point (unless it is interrupted, or the specified waiting time elapses), and then transfers the given object to it, receiving its object in return.
Exchanger - class edu.emory.mathcs.util.concurrent.Exchanger.
A synchronization point at which two threads can exchange objects.
Exchanger() - Constructor for class edu.emory.mathcs.util.concurrent.Exchanger
Create a new Exchanger.
execute(Runnable) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Execute command with zero required delay.
execute(Runnable) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Executes the given task sometime in the future.
execute(Runnable) - Method in interface edu.emory.mathcs.util.concurrent.Executor
Executes the given command at some time in the future.
ExecutionException - exception edu.emory.mathcs.util.concurrent.ExecutionException.
Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
ExecutionException() - Constructor for class edu.emory.mathcs.util.concurrent.ExecutionException
Constructs a ExecutionException with no detail message.
ExecutionException(String) - Constructor for class edu.emory.mathcs.util.concurrent.ExecutionException
Constructs a ExecutionException with the specified detail message.
ExecutionException(String, Throwable) - Constructor for class edu.emory.mathcs.util.concurrent.ExecutionException
Constructs a ExecutionException with the specified detail message and cause.
ExecutionException(Throwable) - Constructor for class edu.emory.mathcs.util.concurrent.ExecutionException
Constructs a ExecutionException with the specified cause.
Executor - interface edu.emory.mathcs.util.concurrent.Executor.
An object that executes submitted Runnable tasks.
ExecutorCompletionService - class edu.emory.mathcs.util.concurrent.ExecutorCompletionService.
A CompletionService that uses a supplied Executor to execute tasks.
ExecutorCompletionService(Executor) - Constructor for class edu.emory.mathcs.util.concurrent.ExecutorCompletionService
Creates an ExecutorCompletionService using the supplied executor for base task execution and a LinkedBlockingQueue as a completion queue.
ExecutorCompletionService(Executor, BlockingQueue) - Constructor for class edu.emory.mathcs.util.concurrent.ExecutorCompletionService
Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.
Executors - class edu.emory.mathcs.util.concurrent.Executors.
Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package.
ExecutorService - interface edu.emory.mathcs.util.concurrent.ExecutorService.
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.util.concurrent.LinkedBlockingQueue
Main mechanics for take/poll
extract() - Method in class edu.emory.mathcs.util.concurrent.helpers.WaitQueue
 
extract() - Method in class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue
 

F

FIFOWaitQueue - class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue.
Simple linked list queue used in FIFOSemaphore.
FIFOWaitQueue() - Constructor for class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue
 
finalize() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Invokes shutdown when this executor is no longer referenced.
floatValue() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
 
floatValue() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
 
Future - interface edu.emory.mathcs.util.concurrent.Future.
A Future represents the result of an asynchronous computation.
FutureTask - class edu.emory.mathcs.util.concurrent.FutureTask.
A cancellable asynchronous computation.
FutureTask(Callable) - Constructor for class edu.emory.mathcs.util.concurrent.FutureTask
Creates a FutureTask that will upon running, execute the given Callable.
FutureTask(Runnable, Object) - Constructor for class edu.emory.mathcs.util.concurrent.FutureTask
Creates a FutureTask that will upon running, execute the given Runnable, and arrange that get will return the given result on successful completion.

G

get() - Method in class edu.emory.mathcs.util.concurrent.FutureTask
 
get() - Method in interface edu.emory.mathcs.util.concurrent.Future
Waits if necessary for the computation to complete, and then retrieves its result.
get() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicBoolean
Returns the current value.
get() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReference
Get the current value.
get() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Get the current value.
get() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Get the current value.
get(boolean[]) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicMarkableReference
Returns the current values of both the reference and the mark.
get(int) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns the element at the specified position in this list.
get(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Get the current value at position i.
get(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray
Get the current value at position i.
get(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Get the current value at position i.
get(int[]) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicStampedReference
Returns the current values of both the reference and the stamp.
get(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.FutureTask
 
get(long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.Future
Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
get(Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Returns the value to which the specified key is mapped in this table.
getActiveCount() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the approximate number of threads that are actively executing tasks.
getAndAdd(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Atomically add the given value to current value.
getAndAdd(int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Atomically add the given value to element at index i.
getAndAdd(int, long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Atomically add the given value to element at index i.
getAndAdd(long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Atomically add the given value to current value.
getAndDecrement() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Atomically decrement by one the current value.
getAndDecrement() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Atomically decrement by one the current value.
getAndDecrement(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Atomically decrement by one the element at index i.
getAndDecrement(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Atomically decrement by one the element at index i.
getAndIncrement() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Atomically increment by one the current value.
getAndIncrement() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Atomically increment by one the current value.
getAndIncrement(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Atomically increment by one the element at index i.
getAndIncrement(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Atomically increment by one the element at index i.
getAndSet(boolean) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicBoolean
Sets to the given value and returns the previous value.
getAndSet(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Set to the give value and return the old value.
getAndSet(int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Set the element at position i to the given value and return the old value.
getAndSet(int, long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Set the element at position i to the given value and return the old value.
getAndSet(int, Object) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray
Set the element at position i to the given value and return the old value.
getAndSet(long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Set to the give value and return the old value.
getAndSet(Object) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReference
Set to the given value and return the old value.
getCompletedTaskCount() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the approximate total number of tasks that have completed execution.
getContinueExistingPeriodicTasksAfterShutdownPolicy() - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Get the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown.
getCorePoolSize() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the core number of threads.
getCount() - Method in class edu.emory.mathcs.util.concurrent.CountDownLatch
Returns the current count.
getDelay(TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.Delayed
Returns the remaining delay associated with this object, in the given time unit.
getExecuteExistingDelayedTasksAfterShutdownPolicy() - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Get policy on whether to execute existing delayed tasks even when this executor has been shutdown.
getHoldCount() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Queries the number of holds on this lock by the current thread.
getKeepAliveTime(TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
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.
getLargestPoolSize() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the largest number of threads that have ever simultaneously been in the pool.
getLength() - Method in class edu.emory.mathcs.util.concurrent.helpers.WaitQueue
 
getLength() - Method in class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue
 
getMaximumPoolSize() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the maximum allowed number of threads.
getNumberWaiting() - Method in class edu.emory.mathcs.util.concurrent.CyclicBarrier
Returns the number of parties currently waiting at the barrier.
getOwner() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
Returns the thread that currently owns the write lock, or null if not owned.
getOwner() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Returns the thread that currently owns this lock, or null if not owned.
getParties() - Method in class edu.emory.mathcs.util.concurrent.CyclicBarrier
Returns the number of parties required to trip this barrier.
getPoolSize() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the current number of threads in the pool.
getQueue() - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Returns the task queue used by this executor.
getQueue() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the task queue used by this executor.
getQueuedThreads() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Returns a collection containing threads that may be waiting to acquire.
getQueuedThreads() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Returns a collection containing threads that may be waiting to acquire this lock.
getQueueLength() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Returns an estimate of the number of threads waiting to acquire.
getQueueLength() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
Returns an estimate of the number of threads waiting to acquire either the read or write lock.
getQueueLength() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Returns an estimate of the number of threads waiting to acquire this lock.
getReadLockCount() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
Queries the number of read locks held for this lock.
getReference() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicStampedReference
Returns the current value of the reference.
getReference() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicMarkableReference
Returns the current value of the reference.
getRejectedExecutionHandler() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the current handler for unexecutable tasks.
getStamp() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicStampedReference
Returns the current value of the stamp.
getTaskCount() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the approximate total number of tasks that have been scheduled for execution.
getThreadFactory() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns the thread factory used to create new threads.
getWaitingThreads() - Method in class edu.emory.mathcs.util.concurrent.helpers.WaitQueue
 
getWaitingThreads() - Method in class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue
 
getWriteHoldCount() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
Queries the number of reentrant write holds on this lock by the current thread.

H

hashCode() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns the hash code value for this List.
hasNodes() - Method in class edu.emory.mathcs.util.concurrent.helpers.WaitQueue
 
hasNodes() - Method in class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue
 
hasQueuedThread(Thread) - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Queries whether the given thread is waiting to acquire this lock.
hasQueuedThreads() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Queries whether any threads are waiting to acquire.
hasQueuedThreads() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Queries whether any threads are waiting to acquire this lock.
head_ - Variable in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Dummy header node of list.
head_ - Variable in class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue
 

I

incrementAndGet() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Atomically increment by one the current value.
incrementAndGet() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Atomically increment by one the current value.
incrementAndGet(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Atomically increment the element at index i.
incrementAndGet(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Atomically increment by one the element at index i.
indexOf(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Searches for the first occurrence of the given argument, testing for equality using the equals method.
indexOf(Object, int) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Searches for the first occurrence of the given argument, beginning the search at index, and testing for equality using the equals method.
insert(Object) - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Create and insert a node.
insert(WaitQueue.WaitNode) - Method in class edu.emory.mathcs.util.concurrent.helpers.WaitQueue
 
insert(WaitQueue.WaitNode) - Method in class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue
 
intValue() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
 
intValue() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
 
invokeAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.AbstractExecutorService
 
invokeAll(Collection) - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Executes the given tasks, returning a list of Futures holding their status and results when all complete.
invokeAll(Collection, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.AbstractExecutorService
 
invokeAll(Collection, long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Executes the given tasks, returning a list of Futures holding their status and results when all complete or the timeout expires, whichever happens first.
invokeAny(Collection) - Method in class edu.emory.mathcs.util.concurrent.AbstractExecutorService
 
invokeAny(Collection) - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do.
invokeAny(Collection, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.AbstractExecutorService
 
invokeAny(Collection, long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
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.
isBroken() - Method in class edu.emory.mathcs.util.concurrent.CyclicBarrier
Queries if this barrier is in a broken state.
isCancelled() - Method in class edu.emory.mathcs.util.concurrent.FutureTask
 
isCancelled() - Method in interface edu.emory.mathcs.util.concurrent.Future
Returns true if this task was cancelled before it completed normally.
isDone() - Method in class edu.emory.mathcs.util.concurrent.FutureTask
 
isDone() - Method in interface edu.emory.mathcs.util.concurrent.Future
Returns true if this task completed.
isEmpty() - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
 
isEmpty() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Tests if this list has no elements.
isEmpty() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
isEmpty() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Always returns true.
isFair() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Returns true if this semaphore has fairness set true.
isFair() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
Returns true if this lock has fairness set true.
isFair() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Returns true if this lock has fairness set true.
isHeldByCurrentThread() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Queries if this lock is held by the current thread.
isLocked() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Queries if this lock is held by any thread.
isMarked() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicMarkableReference
Returns the current value of the mark.
isShutdown() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
 
isShutdown() - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Returns true if this executor has been shut down.
isTerminated() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
 
isTerminated() - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Returns true if all tasks have completed following shut down.
isTerminating() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Returns true if this executor is in the process of terminating after shutdown or shutdownNow but has not completely terminated.
isWaiting(Thread) - Method in class edu.emory.mathcs.util.concurrent.helpers.WaitQueue
 
isWaiting(Thread) - Method in class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue
 
isWriteLocked() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
Queries if the write lock is held by any thread.
isWriteLockedByCurrentThread() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
Queries if the write lock is held by the current thread.
iterator() - Method in class edu.emory.mathcs.util.PriorityQueue
Returns an iterator over the elements in this queue.
iterator() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Returns an iterator over the elements in this queue.
iterator() - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Returns an iterator over the elements in this queue in proper sequence.
iterator() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns an Iterator over the elements contained in this collection.
iterator() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
iterator() - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Returns an iterator over the elements in this queue.
iterator() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Returns an empty iterator in which hasNext always returns false.
iterator() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Returns an iterator over the elements in this queue in proper sequence.

K

keys() - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Returns an enumeration of the keys in this table.
keySet() - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Returns a set view of the keys contained in this map.

L

last_ - Variable in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
The last node of list.
lastIndexOf(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns the index of the last occurrence of the specified object in this list.
lastIndexOf(Object, int) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Searches backwards for the specified object, starting from the specified index, and returns an index to it.
length() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Returns the length of the array.
length() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray
Returns the length of the array.
length() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Returns the length of the array.
LinkedBlockingQueue - class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue.
An optionally-bounded blocking queue based on linked nodes.
LinkedBlockingQueue() - Constructor for class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Creates a LinkedBlockingQueue with a capacity of Integer.MAX_VALUE.
LinkedBlockingQueue(Collection) - Constructor for class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
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.
LinkedBlockingQueue(int) - Constructor for class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Creates a LinkedBlockingQueue with the given (fixed) capacity.
listIterator() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns an Iterator of the elements in this List (in proper sequence).
listIterator(int) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns a ListIterator of the elements in this List (in proper sequence), starting at the specified position in the List.
Lock - interface edu.emory.mathcs.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.util.concurrent.locks.ReentrantLock
Acquires the lock.
lock() - Method in interface edu.emory.mathcs.util.concurrent.locks.Lock
Acquires the lock.
lockInterruptibly() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Acquires the lock unless the current thread is interrupted.
lockInterruptibly() - Method in interface edu.emory.mathcs.util.concurrent.locks.Lock
Acquires the lock unless the current thread is interrupted.
longValue() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
 
longValue() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
 

M

MICROSECONDS - Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit
 
MILLISECONDS - Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit
 

N

NANOSECONDS - Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit
 
nanoTime() - Static method in class edu.emory.mathcs.util.concurrent.helpers.Utils
Emulation.
newCachedThreadPool() - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.
newCachedThreadPool(ThreadFactory) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available, and uses the provided ThreadFactory to create new threads when needed.
newCondition() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Returns a Condition instance for use with this Lock instance.
newCondition() - Method in interface edu.emory.mathcs.util.concurrent.locks.Lock
Returns a new Condition instance that is bound to this Lock instance.
newFixedThreadPool(int) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates a thread pool that reuses a fixed set of threads operating off a shared unbounded queue.
newFixedThreadPool(int, ThreadFactory) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates a thread pool that reuses a fixed set of threads operating off a shared unbounded queue, using the provided ThreadFactory to create new threads when needed.
newScheduledThreadPool(int) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.
newScheduledThreadPool(int, ThreadFactory) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.
newSingleThreadExecutor() - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates an Executor that uses a single worker thread operating off an unbounded queue.
newSingleThreadExecutor(ThreadFactory) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates an Executor that uses a single worker thread operating off an unbounded queue, and uses the provided ThreadFactory to create a new thread when needed.
newSingleThreadScheduledExecutor() - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates a single-threaded executor that can schedule commands to run after a given delay, or to execute periodically.
newSingleThreadScheduledExecutor(ThreadFactory) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Creates a single-threaded executor that can schedule commands to run after a given delay, or to execute periodically.
newThread(Runnable) - Method in interface edu.emory.mathcs.util.concurrent.ThreadFactory
Constructs a new Thread.

O

offer(Object) - Method in class edu.emory.mathcs.util.PriorityQueue
Inserts the specified element into this priority queue.
offer(Object) - Method in interface edu.emory.mathcs.util.Queue
Inserts the specified element into this queue, if possible.
offer(Object) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Inserts the specified element into this priority queue.
offer(Object) - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Inserts the specified element at the tail of this queue if possible, returning immediately if this queue is full.
offer(Object) - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Inserts the specified element into this delay queue.
offer(Object) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Inserts the specified element into this queue, if another thread is waiting to receive it.
offer(Object) - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Inserts the specified element at the tail of this queue if possible, returning immediately if this queue is full.
offer(Object) - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Inserts the specified element into this queue, if possible.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Inserts the specified element into this priority queue.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Inserts the specified element at the tail of this queue, waiting if necessary up to the specified wait time for space to become available.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Inserts the specified element into this delay queue.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Inserts the specified element into this queue, waiting if necessary up to the specified wait time for another thread to receive it.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Inserts the specified element at the tail of this queue, waiting if necessary up to the specified wait time for space to become available.
offer(Object, long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Inserts the specified element into this queue, waiting if necessary up to the specified wait time for space to become available.

P

peek() - Method in class edu.emory.mathcs.util.PriorityQueue
 
peek() - Method in interface edu.emory.mathcs.util.Queue
Retrieves, but does not remove, the head of this queue, returning null if this queue is empty.
peek() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
peek() - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
peek() - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Retrieves, but does not remove, the head of this queue, returning null if this queue has no elements with an unexpired delay.
peek() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Always returns null.
peek() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
 
poll() - Method in class edu.emory.mathcs.util.PriorityQueue
 
poll() - Method in interface edu.emory.mathcs.util.Queue
Retrieves and removes the head of this queue, or null if this queue is empty.
poll() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
poll() - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
poll() - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Retrieves and removes the head of this queue, or null if this queue has no elements with an unexpired delay.
poll() - Method in class edu.emory.mathcs.util.concurrent.ExecutorCompletionService
 
poll() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Retrieves and removes the head of this queue, if another thread is currently making an element available.
poll() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
 
poll() - Method in interface edu.emory.mathcs.util.concurrent.CompletionService
Retrieves and removes the Future representing the next completed task or null if none are present.
poll(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
poll(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
poll(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time if no elements with an unexpired delay are present on this queue.
poll(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ExecutorCompletionService
 
poll(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time, for another thread to insert it.
poll(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
 
poll(long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.CompletionService
Retrieves and removes the Future representing the next completed task, waiting if necessary up to the specified wait time if none are yet present.
poll(long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time if no elements are present on this queue.
prestartAllCoreThreads() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Starts all core threads, causing them to idly wait for work.
prestartCoreThread() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Starts a core thread, causing it to idly wait for work.
PriorityBlockingQueue - class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue.
An unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies blocking retrieval operations.
PriorityBlockingQueue() - Constructor for class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Creates a PriorityBlockingQueue with the default initial capacity (11) that orders its elements according to their natural ordering (using Comparable).
PriorityBlockingQueue(Collection) - Constructor for class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Creates a PriorityBlockingQueue containing the elements in the specified collection.
PriorityBlockingQueue(int) - Constructor for class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Creates a PriorityBlockingQueue with the specified initial capacity that orders its elements according to their natural ordering (using Comparable).
PriorityBlockingQueue(int, Comparator) - Constructor for class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Creates a PriorityBlockingQueue with the specified initial capacity that orders its elements according to the specified comparator.
PriorityQueue - class edu.emory.mathcs.util.PriorityQueue.
An unbounded priority queue based on a priority heap.
PriorityQueue() - Constructor for class edu.emory.mathcs.util.PriorityQueue
Creates a PriorityQueue with the default initial capacity (11) that orders its elements according to their natural ordering (using Comparable).
PriorityQueue(Collection) - Constructor for class edu.emory.mathcs.util.PriorityQueue
Creates a PriorityQueue containing the elements in the specified collection.
PriorityQueue(int) - Constructor for class edu.emory.mathcs.util.PriorityQueue
Creates a PriorityQueue with the specified initial capacity that orders its elements according to their natural ordering (using Comparable).
PriorityQueue(int, Comparator) - Constructor for class edu.emory.mathcs.util.PriorityQueue
Creates a PriorityQueue with the specified initial capacity that orders its elements according to the specified comparator.
PriorityQueue(PriorityQueue) - Constructor for class edu.emory.mathcs.util.PriorityQueue
Creates a PriorityQueue containing the elements in the specified collection.
PriorityQueue(SortedSet) - Constructor for class edu.emory.mathcs.util.PriorityQueue
Creates a PriorityQueue containing the elements in the specified collection.
privilegedCallable(Callable) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Returns a Callable object that will, when called, execute the given callable under the current access control context.
privilegedCallableUsingCurrentClassLoader(Callable) - Static method in class edu.emory.mathcs.util.concurrent.Executors
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.
privilegedThreadFactory() - Static method in class edu.emory.mathcs.util.concurrent.Executors
Returns a thread factory used to create new threads that have the same permissions as the current thread.
purge() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Tries to remove from the work queue all Future tasks that have been cancelled.
put(Object) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Adds the specified element to this priority queue.
put(Object) - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Adds the specified element to the tail of this queue, waiting if necessary for space to become available.
put(Object) - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Adds the specified element to this delay queue.
put(Object) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Adds the specified element to this queue, waiting if necessary for another thread to receive it.
put(Object) - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Adds the specified element to the tail of this queue, waiting if necessary for space to become available.
put(Object) - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Adds the specified element to this queue, waiting if necessary for space to become available.
put(Object, Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Maps the specified key to the specified value in this table.
putAll(Map) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Copies all of the mappings from the specified map to this one.
putGuard_ - Variable in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Helper monitor.
putIfAbsent(Object, Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
If the specified key is not already associated with a value, associate it with the given value.
putIfAbsent(Object, Object) - Method in interface edu.emory.mathcs.util.concurrent.ConcurrentMap
If the specified key is not already associated with a value, associate it with the given value.
putSidePutPermits_ - Variable in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
One side of a split permit count.

Q

Queue - interface edu.emory.mathcs.util.Queue.
A collection designed for holding elements prior to processing.

R

readLock() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
 
readLock() - Method in interface edu.emory.mathcs.util.concurrent.locks.ReadWriteLock
Returns the lock used for reading.
ReadWriteLock - interface edu.emory.mathcs.util.concurrent.locks.ReadWriteLock.
A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing.
recheck(WaitQueue.WaitNode) - Method in interface edu.emory.mathcs.util.concurrent.helpers.WaitQueue.QueuedSync
 
reconcilePutPermits() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Move put permits from take side to put side; return the number of put side permits that are available.
reducePermits(int) - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Shrinks the number of available permits by the indicated reduction.
ReentrantLock - class edu.emory.mathcs.util.concurrent.locks.ReentrantLock.
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.
ReentrantLock() - Constructor for class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Creates an instance of ReentrantLock.
ReentrantLock(boolean) - Constructor for class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Creates an instance of ReentrantLock with the given fairness policy.
ReentrantReadWriteLock - class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock.
An implementation of ReadWriteLock supporting similar semantics to ReentrantLock.
ReentrantReadWriteLock() - Constructor for class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
Creates a new ReentrantReadWriteLock with default ordering properties.
rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy
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.
rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.DiscardPolicy
Does nothing, which has the effect of discarding task r.
rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.AbortPolicy
Always throws RejectedExecutionException.
rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
Executes task r in the caller's thread, unless the executor has been shut down, in which case the task is discarded.
rejectedExecution(Runnable, ThreadPoolExecutor) - Method in interface edu.emory.mathcs.util.concurrent.RejectedExecutionHandler
Method that may be invoked by a ThreadPoolExecutor when execute cannot accept a task.
RejectedExecutionException - exception edu.emory.mathcs.util.concurrent.RejectedExecutionException.
Exception thrown by an Executor when a task cannot be accepted for execution.
RejectedExecutionException() - Constructor for class edu.emory.mathcs.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with no detail message.
RejectedExecutionException(String) - Constructor for class edu.emory.mathcs.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with the specified detail message.
RejectedExecutionException(String, Throwable) - Constructor for class edu.emory.mathcs.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with the specified detail message and cause.
RejectedExecutionException(Throwable) - Constructor for class edu.emory.mathcs.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with the specified cause.
RejectedExecutionHandler - interface edu.emory.mathcs.util.concurrent.RejectedExecutionHandler.
A handler for tasks that cannot be executed by a ThreadPoolExecutor.
release() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Releases a permit, returning it to the semaphore.
release(int) - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Releases the given number of permits, returning them to the semaphore.
remainingCapacity() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Always returns Integer.MAX_VALUE because a PriorityBlockingQueue is not capacity constrained.
remainingCapacity() - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Returns the number of elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking.
remainingCapacity() - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Always returns Integer.MAX_VALUE because a DelayQueue is not capacity constrained.
remainingCapacity() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Always returns zero.
remainingCapacity() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Returns the number of elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking.
remainingCapacity() - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Returns the number of 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.
remove() - Method in interface edu.emory.mathcs.util.Queue
Retrieves and removes the head of this queue.
remove() - Method in class edu.emory.mathcs.util.AbstractQueue
Retrieves and removes the head of this queue.
remove(int) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Removes the element at the specified position in this list.
remove(Object) - Method in class edu.emory.mathcs.util.PriorityQueue
Removes a single instance of the specified element from this queue, if it is present.
remove(Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Removes the key (and its corresponding value) from this table.
remove(Object) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
Removes a single instance of the specified element from this queue, if it is present.
remove(Object) - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Removes a single instance of the specified element from this queue, if it is present.
remove(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Removes a single instance of the specified element from this list, if it is present (optional operation).
remove(Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
remove(Object) - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Removes a single instance of the specified element from this queue, if it is present.
remove(Object) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Always returns false.
remove(Object) - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Removes a single instance of the specified element from this queue, if it is present.
remove(Object, Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Remove entry for key only if currently mapped to given value.
remove(Object, Object) - Method in interface edu.emory.mathcs.util.concurrent.ConcurrentMap
Remove entry for key only if currently mapped to given value.
remove(Runnable) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
 
remove(Runnable) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
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.
removeAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Removes from this Collection all of its elements that are contained in the specified Collection.
removeAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
removeAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Always returns false.
replace(Object, Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Replace entry for key only if currently mapped to some value.
replace(Object, Object) - Method in interface edu.emory.mathcs.util.concurrent.ConcurrentMap
Replace entry for key only if currently mapped to some value.
replace(Object, Object, Object) - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Replace entry for key only if currently mapped to given value.
replace(Object, Object, Object) - Method in interface edu.emory.mathcs.util.concurrent.ConcurrentMap
Replace entry for key only if currently mapped to given value.
reset() - Method in class edu.emory.mathcs.util.concurrent.CyclicBarrier
Resets the barrier to its initial state.
retainAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Retains only the elements in this Collection that are contained in the specified Collection (optional operation).
retainAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
retainAll(Collection) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Always returns false.
run() - Method in class edu.emory.mathcs.util.concurrent.FutureTask
Sets this Future to the result of computation unless it has been cancelled.
runAndReset() - Method in class edu.emory.mathcs.util.concurrent.FutureTask
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.

S

schedule(Callable, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
 
schedule(Callable, long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.ScheduledExecutorService
Creates and executes a ScheduledFuture that becomes enabled after the given delay.
schedule(Runnable, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
 
schedule(Runnable, long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.ScheduledExecutorService
Creates and executes a one-shot action that becomes enabled after the given delay.
scheduleAtFixedRate(Runnable, long, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
 
scheduleAtFixedRate(Runnable, long, long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.ScheduledExecutorService
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.
ScheduledExecutorService - interface edu.emory.mathcs.util.concurrent.ScheduledExecutorService.
An ExecutorService that can schedule commands to run after a given delay, or to execute periodically.
ScheduledFuture - interface edu.emory.mathcs.util.concurrent.ScheduledFuture.
A delayed result-bearing action that can be cancelled.
ScheduledThreadPoolExecutor - class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor.
A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically.
ScheduledThreadPoolExecutor(int) - Constructor for class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Creates a new ScheduledThreadPoolExecutor with the given core pool size.
ScheduledThreadPoolExecutor(int, RejectedExecutionHandler) - Constructor for class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
ScheduledThreadPoolExecutor(int, ThreadFactory) - Constructor for class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
ScheduledThreadPoolExecutor(int, ThreadFactory, RejectedExecutionHandler) - Constructor for class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
scheduleWithFixedDelay(Runnable, long, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
 
scheduleWithFixedDelay(Runnable, long, long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.ScheduledExecutorService
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 variable in class edu.emory.mathcs.util.concurrent.TimeUnit
 
Semaphore - class edu.emory.mathcs.util.concurrent.Semaphore.
A counting semaphore.
Semaphore(int) - Constructor for class edu.emory.mathcs.util.concurrent.Semaphore
Creates a Semaphore with the given number of permits and nonfair fairness setting.
Semaphore(int, boolean) - Constructor for class edu.emory.mathcs.util.concurrent.Semaphore
Creates a Semaphore with the given number of permits and the given fairness setting.
set(boolean) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicBoolean
Unconditionally sets to the given value.
set(int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Set to the given value.
set(int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Set the element at position i to the given value.
set(int, long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Set the element at position i to the given value.
set(int, Object) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Replaces the element at the specified position in this list with the specified element.
set(int, Object) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray
Set the element at position i to the given value.
set(long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Set to the given value.
set(Object) - Method in class edu.emory.mathcs.util.concurrent.FutureTask
Sets the result of this Future to the given value unless this future has already been set or has been cancelled.
set(Object) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReference
Set to the given value.
set(Object, boolean) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicMarkableReference
Unconditionally sets the value of both the reference and mark.
set(Object, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicStampedReference
Unconditionally sets the value of both the reference and stamp.
setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Set policy on whether to continue executing existing periodic tasks even when this executor has been shutdown.
setCorePoolSize(int) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Sets the core number of threads.
setException(Throwable) - Method in class edu.emory.mathcs.util.concurrent.FutureTask
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.
setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Set policy on whether to execute existing delayed tasks even when this executor has been shutdown.
setKeepAliveTime(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Sets the time limit for which threads may remain idle before being terminated.
setMaximumPoolSize(int) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Sets the maximum allowed number of threads.
setRejectedExecutionHandler(RejectedExecutionHandler) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Sets a new handler for unexecutable tasks.
setThreadFactory(ThreadFactory) - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Sets the thread factory used to create new threads.
shutdown() - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
shutdown() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
shutdown() - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
shutdownNow() - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.
shutdownNow() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.
shutdownNow() - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
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 interface edu.emory.mathcs.util.concurrent.locks.Condition
Wakes up one waiting thread.
signal() - Method in class edu.emory.mathcs.util.concurrent.helpers.WaitQueue.WaitNode
 
signalAll() - Method in interface edu.emory.mathcs.util.concurrent.locks.Condition
Wakes up all waiting threads.
size() - Method in class edu.emory.mathcs.util.PriorityQueue
 
size() - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
 
size() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
size() - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
Returns the number of elements in this queue.
size() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns the number of elements in this list.
size() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
size() - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
 
size() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Always returns zero.
size() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Returns the number of elements in this queue.
sleep(long) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Perform a Thread.sleep using this unit.
subList(int, int) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns a view of the portion of this List between fromIndex, inclusive, and toIndex, exclusive.
submit(Callable) - Method in class edu.emory.mathcs.util.concurrent.ExecutorCompletionService
 
submit(Callable) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
 
submit(Callable) - Method in class edu.emory.mathcs.util.concurrent.AbstractExecutorService
 
submit(Callable) - Method in interface edu.emory.mathcs.util.concurrent.CompletionService
Submits a value-returning task for execution and returns a Future representing the pending results of the task.
submit(Callable) - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Submits a value-returning task for execution and returns a Future representing the pending results of the task.
submit(Runnable) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
 
submit(Runnable) - Method in class edu.emory.mathcs.util.concurrent.AbstractExecutorService
 
submit(Runnable) - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Submits a Runnable task for execution and returns a Future representing that task.
submit(Runnable, Object) - Method in class edu.emory.mathcs.util.concurrent.ExecutorCompletionService
 
submit(Runnable, Object) - Method in class edu.emory.mathcs.util.concurrent.ScheduledThreadPoolExecutor
 
submit(Runnable, Object) - Method in class edu.emory.mathcs.util.concurrent.AbstractExecutorService
 
submit(Runnable, Object) - Method in interface edu.emory.mathcs.util.concurrent.CompletionService
Submits a Runnable task for execution and returns a Future representing that task.Upon completion, this task may be taken or polled.
submit(Runnable, Object) - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Submits a Runnable task for execution and returns a Future representing that task that will upon completion return the given result
SynchronousQueue - class edu.emory.mathcs.util.concurrent.SynchronousQueue.
A blocking queue in which each put must wait for a take, and vice versa.
SynchronousQueue() - Constructor for class edu.emory.mathcs.util.concurrent.SynchronousQueue
Creates a SynchronousQueue with nonfair access policy.
SynchronousQueue(boolean) - Constructor for class edu.emory.mathcs.util.concurrent.SynchronousQueue
Creates a SynchronousQueue with specified fairness policy.

T

tail_ - Variable in class edu.emory.mathcs.util.concurrent.helpers.FIFOWaitQueue
 
take() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
take() - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
take() - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
Retrieves and removes the head of this queue, waiting if no elements with an unexpired delay are present on this queue.
take() - Method in class edu.emory.mathcs.util.concurrent.ExecutorCompletionService
 
take() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Retrieves and removes the head of this queue, waiting if necessary for another thread to insert it.
take() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
 
take() - Method in interface edu.emory.mathcs.util.concurrent.CompletionService
Retrieves and removes the Future representing the next completed task, waiting if none are yet present.
take() - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Retrieves and removes the head of this queue, waiting if no elements are present on this queue.
takeGuard_ - Variable in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Helper monitor.
takeSidePutPermits_ - Variable in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
Number of takes since last reconcile
terminated() - Method in class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Method invoked when the Executor has terminated.
ThreadFactory - interface edu.emory.mathcs.util.concurrent.ThreadFactory.
An object that creates new threads on demand.
ThreadPoolExecutor - class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.
An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured using Executors factory methods.
ThreadPoolExecutor.AbortPolicy - class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.AbortPolicy.
A handler for rejected tasks that throws a RejectedExecutionException.
ThreadPoolExecutor.AbortPolicy() - Constructor for class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.AbortPolicy
Creates an AbortPolicy.
ThreadPoolExecutor.CallerRunsPolicy - class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy.
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.
ThreadPoolExecutor.CallerRunsPolicy() - Constructor for class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
Creates a CallerRunsPolicy.
ThreadPoolExecutor.DiscardOldestPolicy - class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy.
A handler for rejected tasks that discards the oldest unhandled request and then retries execute, unless the executor is shut down, in which case the task is discarded.
ThreadPoolExecutor.DiscardOldestPolicy() - Constructor for class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy
Creates a DiscardOldestPolicy for the given executor.
ThreadPoolExecutor.DiscardPolicy - class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.DiscardPolicy.
A handler for rejected tasks that silently discards the rejected task.
ThreadPoolExecutor.DiscardPolicy() - Constructor for class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor.DiscardPolicy
Creates a DiscardPolicy.
ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue) - Constructor for class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Creates a new ThreadPoolExecutor with the given initial parameters and default thread factory and handler.
ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, RejectedExecutionHandler) - Constructor for class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Creates a new ThreadPoolExecutor with the given initial parameters.
ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory) - Constructor for class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Creates a new ThreadPoolExecutor with the given initial parameters.
ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory, RejectedExecutionHandler) - Constructor for class edu.emory.mathcs.util.concurrent.ThreadPoolExecutor
Creates a new ThreadPoolExecutor with the given initial parameters.
timedJoin(Thread, long) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Perform a timed Thread.join using this time unit.
timedWait(Object, long) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Perform a timed Object.wait using this time unit.
TimeoutException - exception edu.emory.mathcs.util.concurrent.TimeoutException.
Exception thrown when a blocking operation times out.
TimeoutException() - Constructor for class edu.emory.mathcs.util.concurrent.TimeoutException
Constructs a TimeoutException with no specified detail message.
TimeoutException(String) - Constructor for class edu.emory.mathcs.util.concurrent.TimeoutException
Constructs a TimeoutException with the specified detail message.
TimeUnit - class edu.emory.mathcs.util.concurrent.TimeUnit.
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.
toArray() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
toArray() - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
toArray() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns an array containing all of the elements in this list in the correct order.
toArray() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
toArray() - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
 
toArray() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Returns a zero-length array.
toArray() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
 
toArray(Object[]) - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
toArray(Object[]) - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
toArray(Object[]) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns an array containing all of the elements in this list in the correct order.
toArray(Object[]) - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArraySet
 
toArray(Object[]) - Method in class edu.emory.mathcs.util.concurrent.DelayQueue
 
toArray(Object[]) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
Sets the zeroeth element of the specified array to null (if the array has non-zero length) and returns it.
toArray(Object[]) - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
 
toMicros(long) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Equivalent to MICROSECONDS.convert(duration, this).
toMillis(long) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Equivalent to MILLISECONDS.convert(duration, this).
toNanos(long) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Equivalent to NANOSECONDS.convert(duration, this).
toSeconds(long) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Equivalent to SECONDS.convert(duration, this).
toString() - Method in class edu.emory.mathcs.util.concurrent.CountDownLatch
Returns a string identifying this latch, as well as its state.
toString() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Returns a string identifying this semaphore, as well as its state.
toString() - Method in class edu.emory.mathcs.util.concurrent.PriorityBlockingQueue
 
toString() - Method in class edu.emory.mathcs.util.concurrent.ArrayBlockingQueue
 
toString() - Method in class edu.emory.mathcs.util.concurrent.CopyOnWriteArrayList
Returns a string representation of this Collection, containing the String representation of each element.
toString() - Method in class edu.emory.mathcs.util.concurrent.LinkedBlockingQueue
 
toString() - Method in class edu.emory.mathcs.util.concurrent.TimeUnit
 
toString() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
Returns a string identifying this lock, as well as its lock state.
toString() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Returns a string identifying this lock, as well as its lock state.
toString() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Returns the String representation of the current values of array.
toString() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicBoolean
Returns the String representation of the current value.
toString() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray
Returns the String representation of the current values of array.
toString() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Returns the String representation of the current values of array.
toString() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReference
Returns the String representation of the current value.
toString() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Returns the String representation of the current value.
toString() - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Returns the String representation of the current value.
tryAcquire() - Method in class edu.emory.mathcs.util.concurrent.Semaphore
Acquires a permit from this semaphore, only if one is available at the time of invocation.
tryAcquire(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.Semaphore
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.util.concurrent.locks.ReentrantLock
Acquires the lock only if it is not held by another thread at the time of invocation.
tryLock() - Method in interface edu.emory.mathcs.util.concurrent.locks.Lock
Acquires the lock only if it is free at the time of invocation.
tryLock(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Acquires the lock if it is not held by another thread within the given waiting time and the current thread has not been interrupted.
tryLock(long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.locks.Lock
Acquires the lock if it is free within the given waiting time and the current thread has not been interrupted.

U

unconfigurableExecutorService(ExecutorService) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Returns an object that delegates all defined ExecutorService methods to the given executor, but not any other methods that might otherwise be accessible using casts.
unconfigurableScheduledExecutorService(ScheduledExecutorService) - Static method in class edu.emory.mathcs.util.concurrent.Executors
Returns an object that delegates all defined ScheduledExecutorService methods to the given executor, but not any other methods that might otherwise be accessible using casts.
unlock() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantLock
Attempts to release this lock.
unlock() - Method in interface edu.emory.mathcs.util.concurrent.locks.Lock
Releases the lock.
Utils - class edu.emory.mathcs.util.concurrent.helpers.Utils.
 

V

values() - Method in class edu.emory.mathcs.util.concurrent.ConcurrentHashMap
Returns a collection view of the values contained in this map.

W

WaitQueue - class edu.emory.mathcs.util.concurrent.helpers.WaitQueue.
Base class for internal queue classes for semaphores, etc.
WaitQueue.QueuedSync - interface edu.emory.mathcs.util.concurrent.helpers.WaitQueue.QueuedSync.
 
WaitQueue.WaitNode - class edu.emory.mathcs.util.concurrent.helpers.WaitQueue.WaitNode.
 
WaitQueue.WaitNode() - Constructor for class edu.emory.mathcs.util.concurrent.helpers.WaitQueue.WaitNode
 
WaitQueue() - Constructor for class edu.emory.mathcs.util.concurrent.helpers.WaitQueue
 
weakCompareAndSet(boolean, boolean) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicBoolean
Atomically set the value to the given updated value if the current value == the expected value.
weakCompareAndSet(int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicInteger
Atomically set the value to the given updated value if the current value == the expected value.
weakCompareAndSet(int, int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicIntegerArray
Atomically set the value to the given updated value if the current value == the expected value.
weakCompareAndSet(int, long, long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLongArray
Atomically set the value to the given updated value if the current value == the expected value.
weakCompareAndSet(int, Object, Object) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReferenceArray
Atomically set the value to the given updated value if the current value == the expected value.
weakCompareAndSet(long, long) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicLong
Atomically set the value to the given updated value if the current value == the expected value.
weakCompareAndSet(Object, Object) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicReference
Atomically set the value to the given updated value if the current value == the expected value.
weakCompareAndSet(Object, Object, boolean, boolean) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicMarkableReference
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.
weakCompareAndSet(Object, Object, int, int) - Method in class edu.emory.mathcs.util.concurrent.atomic.AtomicStampedReference
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.
writeLock() - Method in class edu.emory.mathcs.util.concurrent.locks.ReentrantReadWriteLock
 
writeLock() - Method in interface edu.emory.mathcs.util.concurrent.locks.ReadWriteLock
Returns the lock used for writing.

A B C D E F G H I K L M N O P Q R S T U V W