Index

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

A

AbstractCollection - Class in edu.emory.mathcs.backport.java.util: Overrides toArray() and toArray(Object[]) in AbstractCollection to provide implementations valid for concurrent collections.
AbstractCollection() - Constructor for class edu.emory.mathcs.backport.java.util.AbstractCollection: Sole constructor.
AbstractExecutorService - Class in edu.emory.mathcs.backport.java.util.concurrent: Provides default implementations of ExecutorService execution methods.
AbstractExecutorService() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService
AbstractList - Class in edu.emory.mathcs.backport.java.util: Overrides toArray() and toArray(Object[]) in AbstractCollection to provide implementations valid for concurrent lists.
AbstractList() - Constructor for class edu.emory.mathcs.backport.java.util.AbstractList: Sole constructor.
AbstractMap - Class in edu.emory.mathcs.backport.java.util: Convenience base class for map implementations that provides helper classes representing simple map entries, both mutable and immutable.
AbstractMap() - Constructor for class edu.emory.mathcs.backport.java.util.AbstractMap: Sole constructor.
AbstractMap.SimpleEntry - Class in edu.emory.mathcs.backport.java.util: An Entry maintaining a key and a value.
AbstractMap.SimpleEntry(Object, Object) - Constructor for class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleEntry: Creates an entry representing a mapping from the specified key to the specified value.
AbstractMap.SimpleEntry(Map.Entry) - Constructor for class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleEntry: Creates an entry representing the same mapping as the specified entry.
AbstractMap.SimpleImmutableEntry - Class in edu.emory.mathcs.backport.java.util: An Entry maintaining an immutable key and value, This class does not support method setValue.
AbstractMap.SimpleImmutableEntry(Object, Object) - Constructor for class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleImmutableEntry: Creates an entry representing a mapping from the specified key to the specified value.
AbstractMap.SimpleImmutableEntry(Map.Entry) - Constructor for class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleImmutableEntry: Creates an entry representing the same mapping as the specified entry.
AbstractQueue - Class in edu.emory.mathcs.backport.java.util: This class provides skeletal implementations of some Queue operations.
AbstractQueue() - Constructor for class edu.emory.mathcs.backport.java.util.AbstractQueue: Constructor for use by subclasses.
AbstractSequentialList - Class in edu.emory.mathcs.backport.java.util: Overrides toArray() and toArray(Object[]) in AbstractCollection to provide implementations valid for concurrent lists.
AbstractSequentialList() - Constructor for class edu.emory.mathcs.backport.java.util.AbstractSequentialList: Sole constructor.
AbstractSet - Class in edu.emory.mathcs.backport.java.util: Overrides toArray() and toArray(Object[]) in AbstractCollection to provide implementations valid for concurrent sets.
AbstractSet() - Constructor for class edu.emory.mathcs.backport.java.util.AbstractSet: Sole constructor.
acquire() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Acquires a permit from this semaphore, blocking until one is available, or the thread is interrupted.
acquire(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Acquires the given number of permits from this semaphore, blocking until all are available, or the thread is interrupted.
acquireUninterruptibly() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Acquires a permit from this semaphore, blocking until one is available.
acquireUninterruptibly(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Acquires the given number of permits from this semaphore, blocking until all are available.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.AbstractQueue: Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Inserts the specified element at the end of this deque.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Inserts the specified element at the tail of this queue if it is possible to do so immediately without exceeding the queue's capacity, returning true upon success and throwing an IllegalStateException if this queue is full.
add(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
add(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue: Inserts the specified element at the tail of this queue.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Adds the specified element to this set if it is not already present.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
add(int, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
add(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Adds the specified element to this set if it is not already present.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Inserts the specified element into this delay queue.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Inserts the specified element at the end of this deque unless it would violate capacity restrictions.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Inserts the specified element into this priority queue.
add(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
add(int, Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
add(Object) - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Inserts the specified element into this priority queue.
add(Object) - Method in interface edu.emory.mathcs.backport.java.util.Queue: Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
add(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
addAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.AbstractQueue: Adds all of the elements in the specified collection to this queue.
addAll(Collection, Object[]) - Static method in class edu.emory.mathcs.backport.java.util.Collections
addAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
addAll(int, Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
addAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Adds all of the elements in the specified collection to this set if they're not already present.
addAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
addAll(int, Collection) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
addAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
addAllAbsent(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
addAndGet(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Atomically adds the given value to the current value.
addAndGet(int, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Atomically adds the given value to the element at index i.
addAndGet(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Atomically adds the given value to the current value.
addAndGet(int, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Atomically adds the given value to the element at index i.
addFirst(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Inserts the specified element at the front of this deque.
addFirst(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element at the front of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an IllegalStateException if no space is currently available.
addFirst(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
addFirst(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Inserts the specified element at the front of this deque if it is possible to do so immediately without violating capacity restrictions.
addFirst(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
addIfAbsent(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
addLast(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Inserts the specified element at the end of this deque.
addLast(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element at the end of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an IllegalStateException if no space is currently available.
addLast(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
addLast(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Inserts the specified element at the end of this deque if it is possible to do so immediately without violating capacity restrictions.
addLast(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
afterExecute(Runnable, Throwable) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Method invoked upon completion of execution of the given Runnable.
allowCoreThreadTimeOut(boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Sets the policy governing whether core threads may time out and terminate if no tasks arrive within the keep-alive time, being replaced if needed when new tasks arrive.
allowsCoreThreadTimeOut() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns true if this pool allows core threads to time out and terminate if no tasks arrive within the keepAlive time, being replaced if needed when new tasks arrive.
ArrayBlockingQueue - Class in edu.emory.mathcs.backport.java.util.concurrent: A bounded blocking queue backed by an array.
ArrayBlockingQueue(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Creates an ArrayBlockingQueue with the given (fixed) capacity and default access policy.
ArrayBlockingQueue(int, boolean) - Constructor for class edu.emory.mathcs.backport.java.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.backport.java.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.
ArrayDeque - Class in edu.emory.mathcs.backport.java.util: Resizable-array implementation of the Deque interface.
ArrayDeque() - Constructor for class edu.emory.mathcs.backport.java.util.ArrayDeque: Constructs an empty array deque with an initial capacity sufficient to hold 16 elements.
ArrayDeque(int) - Constructor for class edu.emory.mathcs.backport.java.util.ArrayDeque: Constructs an empty array deque with an initial capacity sufficient to hold the specified number of elements.
ArrayDeque(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.ArrayDeque: Constructs a deque containing the elements of the specified collection, in the order they are returned by the collection's iterator.
Arrays - Class in edu.emory.mathcs.backport.java.util
asLifoQueue(Deque) - Static method in class edu.emory.mathcs.backport.java.util.Collections
asList(Object[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
assignExceptionHandler(Runnable, ThreadHelpers.UncaughtExceptionHandler) - Static method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.ThreadHelpers: Returns wrapped runnable that ensures that if an exception occurs during the execution, the specified exception handler is invoked.
AtomicBoolean - Class in edu.emory.mathcs.backport.java.util.concurrent.atomic: A boolean value that may be updated atomically.
AtomicBoolean(boolean) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean: Creates a new AtomicBoolean with the given initial value.
AtomicBoolean() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean: Creates a new AtomicBoolean with initial value false.
AtomicInteger - Class in edu.emory.mathcs.backport.java.util.concurrent.atomic: An int value that may be updated atomically.
AtomicInteger(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Creates a new AtomicInteger with the given initial value.
AtomicInteger() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Creates a new AtomicInteger with initial value 0.
AtomicIntegerArray - Class in edu.emory.mathcs.backport.java.util.concurrent.atomic: An int array in which elements may be updated atomically.
AtomicIntegerArray(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Creates a new AtomicIntegerArray of given length.
AtomicIntegerArray(int[]) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Creates a new AtomicIntegerArray with the same length as, and all elements copied from, the given array.
AtomicLong - Class in edu.emory.mathcs.backport.java.util.concurrent.atomic: A long value that may be updated atomically.
AtomicLong(long) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Creates a new AtomicLong with the given initial value.
AtomicLong() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Creates a new AtomicLong with initial value 0.
AtomicLongArray - Class in edu.emory.mathcs.backport.java.util.concurrent.atomic: A long array in which elements may be updated atomically.
AtomicLongArray(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Creates a new AtomicLongArray of given length.
AtomicLongArray(long[]) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Creates a new AtomicLongArray with the same length as, and all elements copied from, the given array.
AtomicMarkableReference - Class in edu.emory.mathcs.backport.java.util.concurrent.atomic: 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.backport.java.util.concurrent.atomic.AtomicMarkableReference: Creates a new AtomicMarkableReference with the given initial values.
AtomicReference - Class in edu.emory.mathcs.backport.java.util.concurrent.atomic: An object reference that may be updated atomically.
AtomicReference(Object) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference: Creates a new AtomicReference with the given initial value.
AtomicReference() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference: Creates a new AtomicReference with null initial value.
AtomicReferenceArray - Class in edu.emory.mathcs.backport.java.util.concurrent.atomic: An array of object references in which elements may be updated atomically.
AtomicReferenceArray(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray: Creates a new AtomicReferenceArray of given length.
AtomicReferenceArray(Object[]) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray: Creates a new AtomicReferenceArray with the same length as, and all elements copied from, the given array.
AtomicStampedReference - Class in edu.emory.mathcs.backport.java.util.concurrent.atomic: 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.backport.java.util.concurrent.atomic.AtomicStampedReference: Creates a new AtomicStampedReference with the given initial values.
attemptMark(Object, boolean) - Method in class edu.emory.mathcs.backport.java.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.backport.java.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.backport.java.util.concurrent.Semaphore: Returns the current number of permits available in this semaphore.
await() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch: Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted.
await(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.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() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CyclicBarrier: Waits until all parties have invoked await on this barrier.
await(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CyclicBarrier: Waits until all parties have invoked await on this barrier, or the specified waiting time elapses.
await() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.locks.Condition: Causes the current thread to wait until it is signalled or interrupted.
await(long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.helpers.Utils: Causes the current thread to wait until it is signalled or interrupted, or the specified waiting time elapses.
awaitTermination(long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.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.
awaitTermination(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor
awaitUninterruptibly() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.locks.Condition: Causes the current thread to wait until it is signalled.
awaitUntil(Date) - Method in interface edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.ThreadPoolExecutor: Method invoked prior to executing the given Runnable in the given thread.
binarySearch(long[], long) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
binarySearch(int[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
binarySearch(short[], short) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
binarySearch(char[], char) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
binarySearch(byte[], byte) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
binarySearch(double[], double) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
binarySearch(float[], float) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
binarySearch(Object[], Object) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
binarySearch(Object[], Object, Comparator) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
binarySearch(List, Object) - Static method in class edu.emory.mathcs.backport.java.util.Collections
binarySearch(List, Object, Comparator) - Static method in class edu.emory.mathcs.backport.java.util.Collections
BlockingDeque - Interface in edu.emory.mathcs.backport.java.util.concurrent: A Deque that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for space to become available in the deque when storing an element.
BlockingQueue - Interface in edu.emory.mathcs.backport.java.util.concurrent: A 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 in edu.emory.mathcs.backport.java.util.concurrent: 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 exception edu.emory.mathcs.backport.java.util.concurrent.BrokenBarrierException: Constructs a BrokenBarrierException with no specified detail message.
BrokenBarrierException(String) - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.BrokenBarrierException: Constructs a BrokenBarrierException with the specified detail message.

C

call() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.Callable: Computes a result, or throws an exception if unable to do so.
Callable - Interface in edu.emory.mathcs.backport.java.util.concurrent: A task that returns a result and may throw an exception.
callable(Runnable, Object) - Static method in class edu.emory.mathcs.backport.java.util.concurrent.Executors: Returns a Callable object that, when called, runs the given task and returns the given result.
callable(Runnable) - Static method in class edu.emory.mathcs.backport.java.util.concurrent.Executors: Returns a Callable object that, when called, runs the given task and returns null.
callable(PrivilegedAction) - Static method in class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.Executors: Returns a Callable object that, when called, runs the given privileged exception action and returns its result.
cancel(boolean) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.Future: Attempts to cancel execution of this task.
cancel(boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.FutureTask
CancellationException - Exception in edu.emory.mathcs.backport.java.util.concurrent: 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 exception edu.emory.mathcs.backport.java.util.concurrent.CancellationException: Constructs a CancellationException with no detail message.
CancellationException(String) - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.CancellationException: Constructs a CancellationException with the specified detail message.
ceiling(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
ceiling(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns the least element in this set greater than or equal to the given element, or null if there is no such element.
ceiling(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
ceilingEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a key-value mapping associated with the least key greater than or equal to the given key, or null if there is no such entry.
ceilingEntry(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a key-value mapping associated with the least key greater than or equal to the given key, or null if there is no such key.
ceilingEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
ceilingKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
ceilingKey(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns the least key greater than or equal to the given key, or null if there is no such key.
ceilingKey(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
checkedCollection(Collection, Class) - Static method in class edu.emory.mathcs.backport.java.util.Collections
checkedList(List, Class) - Static method in class edu.emory.mathcs.backport.java.util.Collections
checkedMap(Map, Class, Class) - Static method in class edu.emory.mathcs.backport.java.util.Collections
checkedSet(Set, Class) - Static method in class edu.emory.mathcs.backport.java.util.Collections
checkedSortedMap(SortedMap, Class, Class) - Static method in class edu.emory.mathcs.backport.java.util.Collections
checkedSortedSet(SortedSet, Class) - Static method in class edu.emory.mathcs.backport.java.util.Collections
clear() - Method in class edu.emory.mathcs.backport.java.util.AbstractQueue: Removes all of the elements from this queue.
clear() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Removes all of the elements from this deque.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Atomically removes all of the elements from this queue.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Removes all of the mappings from this map.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Removes all of the mappings from this map.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Removes all of the elements from this set.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Removes all of the elements from this set.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Atomically removes all of the elements from this delay queue.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Atomically removes all of the elements from this deque.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Atomically removes all of the elements from this queue.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Atomically removes all of the elements from this queue.
clear() - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Does nothing.
clear() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
clear() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Removes all of the elements from this queue.
clear() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
clear() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
clone() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Returns a copy of this deque.
clone() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a shallow copy of this ConcurrentSkipListMap instance.
clone() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Returns a shallow copy of this ConcurrentSkipListSet instance.
clone() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
clone() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
clone() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
clone() - Method in class edu.emory.mathcs.backport.java.util.TreeMap.Entry: Return a new Entry with same element and color as self, but with null links.
clone() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
Collections - Class in edu.emory.mathcs.backport.java.util: Augments Collections with methods added in Java 5.0 and higher.
collectionToArray(Collection) - Static method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.Utils
collectionToArray(Collection, Object[]) - Static method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.Utils
comparator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
comparator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
comparator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Returns the comparator used to order the elements in this queue, or null if this queue uses the natural ordering of its elements.
comparator() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Returns the comparator used to order the elements in this queue, or null if this queue uses the natural ordering of its elements.
comparator() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
comparator() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
compareAndSet(boolean, boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean: Atomically sets the value to the given updated value if the current value == the expected value.
compareAndSet(int, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Atomically sets the value to the given updated value if the current value == the expected value.
compareAndSet(int, int, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Atomically sets the element at position i to the given updated value if the current value == the expected value.
compareAndSet(long, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Atomically sets the value to the given updated value if the current value == the expected value.
compareAndSet(int, long, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Atomically sets 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.backport.java.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) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference: Atomically sets the value to the given updated value if the current value == the expected value.
compareAndSet(int, Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray: Atomically sets the element at position i to the given updated value if the current value == the expected value.
compareAndSet(Object, Object, int, int) - Method in class edu.emory.mathcs.backport.java.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 in edu.emory.mathcs.backport.java.util.concurrent: A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.
ConcurrentHashMap - Class in edu.emory.mathcs.backport.java.util.concurrent: A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates.
ConcurrentHashMap(int, float, int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Creates a new, empty map with the specified initial capacity, load factor and concurrency level.
ConcurrentHashMap(int, float) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Creates a new, empty map with the specified initial capacity and load factor and with the default concurrencyLevel (16).
ConcurrentHashMap(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Creates a new, empty map with the specified initial capacity, and with default load factor (0.75) and concurrencyLevel (16).
ConcurrentHashMap() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Creates a new, empty map with a default initial capacity (16), load factor (0.75) and concurrencyLevel (16).
ConcurrentHashMap(Map) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Creates a new map with the same mappings as the given map.
ConcurrentLinkedQueue - Class in edu.emory.mathcs.backport.java.util.concurrent: An unbounded thread-safe queue based on linked nodes.
ConcurrentLinkedQueue() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue: Creates a ConcurrentLinkedQueue that is initially empty.
ConcurrentLinkedQueue(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue: Creates a ConcurrentLinkedQueue initially containing the elements of the given collection, added in traversal order of the collection's iterator.
ConcurrentMap - Interface in edu.emory.mathcs.backport.java.util.concurrent: A Map providing additional atomic putIfAbsent, remove, and replace methods.
ConcurrentNavigableMap - Interface in edu.emory.mathcs.backport.java.util.concurrent: A ConcurrentMap supporting NavigableMap operations, and recursively so for its navigable sub-maps.
ConcurrentSkipListMap - Class in edu.emory.mathcs.backport.java.util.concurrent: A scalable concurrent ConcurrentNavigableMap implementation.
ConcurrentSkipListMap() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Constructs a new, empty map, sorted according to the natural ordering of the keys.
ConcurrentSkipListMap(Comparator) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Constructs a new, empty map, sorted according to the specified comparator.
ConcurrentSkipListMap(Map) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Constructs a new map containing the same mappings as the given map, sorted according to the natural ordering of the keys.
ConcurrentSkipListMap(SortedMap) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Constructs a new map containing the same mappings and using the same ordering as the specified sorted map.
ConcurrentSkipListSet - Class in edu.emory.mathcs.backport.java.util.concurrent: A scalable concurrent NavigableSet implementation based on a ConcurrentSkipListMap.
ConcurrentSkipListSet() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Constructs a new, empty set that orders its elements according to their natural ordering.
ConcurrentSkipListSet(Comparator) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Constructs a new, empty set that orders its elements according to the specified comparator.
ConcurrentSkipListSet(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Constructs a new set containing the elements in the specified collection, that orders its elements according to their natural ordering.
ConcurrentSkipListSet(SortedSet) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Constructs a new set containing the same elements and using the same ordering as the specified sorted set.
Condition - Interface in edu.emory.mathcs.backport.java.util.concurrent.locks: 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.backport.java.util.ArrayDeque: Returns true if this deque contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Returns true if this queue contains the specified element.
contains(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Returns true if this deque contains the specified element.
contains(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Returns true if this queue contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.ConcurrentLinkedQueue: Returns true if this queue contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Returns true if this set contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Returns true if this set contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Returns true if this deque contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Returns true if this queue contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Always returns false.
contains(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Returns true if this deque contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Returns true if this queue contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
containsAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
containsAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Returns true if this set contains all of the elements of the specified collection.
containsAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Returns false unless the given collection is empty.
containsKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Tests if the specified object is a key in this table.
containsKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns true if this map contains a mapping for the specified key.
containsKey(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
containsValue(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Returns true if this map maps one or more keys to the specified value.
containsValue(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns true if this map maps one or more keys to the specified value.
containsValue(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
convert(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Convert the given time duration in the given unit to this unit.
copy(List, List) - Static method in class edu.emory.mathcs.backport.java.util.Collections
copyOf(Object[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOf(Object[], int, Class) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOf(byte[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOf(short[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOf(int[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOf(long[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOf(char[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOf(float[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOf(double[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOf(boolean[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(Object[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(Object[], int, int, Class) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(byte[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(short[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(int[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(long[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(char[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(float[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(double[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
copyOfRange(boolean[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
CopyOnWriteArrayList - Class in edu.emory.mathcs.backport.java.util.concurrent
CopyOnWriteArrayList() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
CopyOnWriteArrayList(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
CopyOnWriteArrayList(Object[]) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
CopyOnWriteArraySet - Class in edu.emory.mathcs.backport.java.util.concurrent: A Set that uses an internal CopyOnWriteArrayList for all of its operations.
CopyOnWriteArraySet() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Creates an empty set.
CopyOnWriteArraySet(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Creates a set containing all of the elements of the specified collection.
countDown() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch: Decrements the count of the latch, releasing all waiting threads if the count reaches zero.
CountDownLatch - Class in edu.emory.mathcs.backport.java.util.concurrent: 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.backport.java.util.concurrent.CountDownLatch: Constructs a CountDownLatch initialized with the given count.
CyclicBarrier - Class in edu.emory.mathcs.backport.java.util.concurrent: A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
CyclicBarrier(int, Runnable) - Constructor for class edu.emory.mathcs.backport.java.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.
CyclicBarrier(int) - Constructor for class edu.emory.mathcs.backport.java.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 when the barrier is tripped.

D

DAYS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
decorateTask(Runnable, RunnableScheduledFuture) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Modifies or replaces the task used to execute a runnable.
decorateTask(Callable, RunnableScheduledFuture) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Modifies or replaces the task used to execute a callable.
decrementAndGet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Atomically decrements by one the current value.
decrementAndGet(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Atomically decrements by one the element at index i.
decrementAndGet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Atomically decrements by one the current value.
decrementAndGet(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Atomically decrements by one the element at index i.
deepEquals(Object[], Object[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
deepHashCode(Object[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
deepToString(Object[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
defaultThreadFactory() - Static method in class edu.emory.mathcs.backport.java.util.concurrent.Executors: Returns a default thread factory used to create new threads.
Delayed - Interface in edu.emory.mathcs.backport.java.util.concurrent: A mix-in style interface for marking objects that should be acted upon after a given delay.
DelayQueue - Class in edu.emory.mathcs.backport.java.util.concurrent: 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.backport.java.util.concurrent.DelayQueue: Creates a new DelayQueue that is initially empty.
DelayQueue(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Creates a DelayQueue initially containing the elements of the given collection of Delayed instances.
Deque - Interface in edu.emory.mathcs.backport.java.util: A linear collection that supports element insertion and removal at both ends.
descendingIterator() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
descendingIterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Returns an iterator over the elements in this set in descending order.
descendingIterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Returns an iterator over the elements in this deque in reverse sequential order.
descendingIterator() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Returns an iterator over the elements in this deque in reverse sequential order.
descendingIterator() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
descendingIterator() - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns an iterator over the elements in this set, in descending order.
descendingIterator() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
descendingKeySet() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap: Returns a reverse order NavigableSet view of the keys contained in this map.
descendingKeySet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
descendingKeySet() - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a reverse order NavigableSet view of the keys contained in this map.
descendingKeySet() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
descendingMap() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap: Returns a reverse order view of the mappings contained in this map.
descendingMap() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
descendingMap() - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a reverse order view of the mappings contained in this map.
descendingMap() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
descendingSet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Returns a reverse order view of the elements contained in this set.
descendingSet() - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns a reverse order view of the elements contained in this set.
descendingSet() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
disjoint(Collection, Collection) - Static method in class edu.emory.mathcs.backport.java.util.Collections
done() - Method in class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.helpers.WaitQueue.WaitNode
doubleValue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger
doubleValue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong
doWait(WaitQueue.QueuedSync) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue.WaitNode
doWaitUninterruptibly(WaitQueue.QueuedSync) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue.WaitNode
drainPermits() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Acquires and returns all permits that are immediately available.
drainTo(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue
drainTo(Collection, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue
drainTo(Collection) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Removes all available elements from this queue and adds them to the given collection.
drainTo(Collection, int) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Removes at most the given number of available elements from this queue and adds them to the given collection.
drainTo(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue
drainTo(Collection, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue
drainTo(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
drainTo(Collection, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
drainTo(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue
drainTo(Collection, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue
drainTo(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue
drainTo(Collection, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue
drainTo(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue
drainTo(Collection, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue

E

edu.emory.mathcs.backport.java.util - package edu.emory.mathcs.backport.java.util
edu.emory.mathcs.backport.java.util.concurrent - package edu.emory.mathcs.backport.java.util.concurrent: Utility classes commonly useful in concurrent programming.
edu.emory.mathcs.backport.java.util.concurrent.atomic - package edu.emory.mathcs.backport.java.util.concurrent.atomic: Atomics A small toolkit of classes that support lock-free thread-safe programming on single variables.
edu.emory.mathcs.backport.java.util.concurrent.helpers - package edu.emory.mathcs.backport.java.util.concurrent.helpers: Auxiliary and helper classes for backport.util.concurrent, NOT present in java.util.concurrent.
edu.emory.mathcs.backport.java.util.concurrent.locks - package edu.emory.mathcs.backport.java.util.concurrent.locks: Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors.
element() - Method in class edu.emory.mathcs.backport.java.util.AbstractQueue: Retrieves, but does not remove, the head of this queue.
element() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Retrieves, but does not remove, the head of the queue represented by this deque.
element() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque).
element() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Retrieves, but does not remove, the head of the queue represented by this deque.
element() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque).
element() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
element() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Retrieves, but does not remove, the head of this queue.
element() - Method in interface edu.emory.mathcs.backport.java.util.Queue: Retrieves, but does not remove, the head of this queue.
elements() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Returns an enumeration of the values in this table.
emptyList() - Static method in class edu.emory.mathcs.backport.java.util.Collections
emptyMap() - Static method in class edu.emory.mathcs.backport.java.util.Collections
emptySet() - Static method in class edu.emory.mathcs.backport.java.util.Collections
entrySet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Returns a Set view of the mappings contained in this map.
entrySet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a Set view of the mappings contained in this map.
entrySet() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
enumeration(Collection) - Static method in class edu.emory.mathcs.backport.java.util.Collections
equals(Object) - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleEntry
equals(Object) - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleImmutableEntry
equals(long[], long[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
equals(int[], int[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
equals(short[], short[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
equals(char[], char[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
equals(byte[], byte[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
equals(boolean[], boolean[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
equals(double[], double[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
equals(float[], float[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
equals(Object[], Object[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
equals(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Compares the specified object with this map for equality.
equals(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Compares the specified object with this set for equality.
equals(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
equals(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Compares the specified object with this set for equality.
equals(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap.Entry
exchange(Object) - Method in class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.Exchanger: Waits for another thread to arrive at this exchange point (unless the current thread is interrupted or the specified waiting time elapses), and then transfers the given object to it, receiving its object in return.
Exchanger - Class in edu.emory.mathcs.backport.java.util.concurrent: A synchronization point at which threads can pair and swap elements within pairs.
Exchanger() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.Exchanger: Creates a new Exchanger.
execute(Runnable) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.Executor: Executes the given command at some time in the future.
execute(Runnable) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Executes command with zero required delay.
execute(Runnable) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Executes the given task sometime in the future.
ExecutionException - Exception in edu.emory.mathcs.backport.java.util.concurrent: Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
ExecutionException() - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.ExecutionException: Constructs an ExecutionException with no detail message.
ExecutionException(String) - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.ExecutionException: Constructs an ExecutionException with the specified detail message.
ExecutionException(String, Throwable) - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.ExecutionException: Constructs an ExecutionException with the specified detail message and cause.
ExecutionException(Throwable) - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.ExecutionException: Constructs an ExecutionException with the specified cause.
Executor - Interface in edu.emory.mathcs.backport.java.util.concurrent: An object that executes submitted Runnable tasks.
ExecutorCompletionService - Class in edu.emory.mathcs.backport.java.util.concurrent: A CompletionService that uses a supplied Executor to execute tasks.
ExecutorCompletionService(Executor) - Constructor for class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.ExecutorCompletionService: Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.
Executors - Class in edu.emory.mathcs.backport.java.util.concurrent: Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package.
ExecutorService - Interface in edu.emory.mathcs.backport.java.util.concurrent: An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks.
extract() - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
extract() - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue

F

FIFOWaitQueue - Class in edu.emory.mathcs.backport.java.util.concurrent.helpers: Simple linked list queue used in FIFOSemaphore.
FIFOWaitQueue() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
fill(long[], long) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(long[], int, int, long) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(int[], int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(int[], int, int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(short[], short) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(short[], int, int, short) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(char[], char) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(char[], int, int, char) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(byte[], byte) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(byte[], int, int, byte) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(boolean[], boolean) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(boolean[], int, int, boolean) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(double[], double) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(double[], int, int, double) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(float[], float) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(float[], int, int, float) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(Object[], Object) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(Object[], int, int, Object) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
fill(List, Object) - Static method in class edu.emory.mathcs.backport.java.util.Collections
finalize() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Invokes shutdown when this executor is no longer referenced and it has no threads.
first() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
first() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
firstEntry() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a key-value mapping associated with the least key in this map, or null if the map is empty.
firstEntry() - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a key-value mapping associated with the least key in this map, or null if the map is empty.
firstEntry() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
firstKey() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
firstKey() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
floatValue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger
floatValue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong
floor(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
floor(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns the greatest element in this set less than or equal to the given element, or null if there is no such element.
floor(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
floorEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.
floorEntry(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.
floorEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
floorKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
floorKey(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns the greatest key less than or equal to the given key, or null if there is no such key.
floorKey(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
frequency(Collection, Object) - Static method in class edu.emory.mathcs.backport.java.util.Collections
Future - Interface in edu.emory.mathcs.backport.java.util.concurrent: A Future represents the result of an asynchronous computation.
FutureTask - Class in edu.emory.mathcs.backport.java.util.concurrent: A cancellable asynchronous computation.
FutureTask(Callable) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.FutureTask: Creates a FutureTask that will, upon running, execute the given Callable.
FutureTask(Runnable, Object) - Constructor for class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.atomic.AtomicBoolean: Returns the current value.
get() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Gets the current value.
get(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Gets the current value at position i.
get() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Gets the current value.
get(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Gets the current value at position i.
get(boolean[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicMarkableReference: Returns the current values of both the reference and the mark.
get() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference: Gets the current value.
get(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray: Gets the current value at position i.
get(int[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicStampedReference: Returns the current values of both the reference and the stamp.
get(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
get(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
get(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
get() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.Future: Waits if necessary for the computation to complete, and then retrieves its result.
get(long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.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() - Method in class edu.emory.mathcs.backport.java.util.concurrent.FutureTask
get(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.FutureTask
get(int) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
get(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
getActiveCount() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the approximate number of threads that are actively executing tasks.
getAndAdd(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Atomically adds the given value to the current value.
getAndAdd(int, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Atomically adds the given value to the element at index i.
getAndAdd(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Atomically adds the given value to the current value.
getAndAdd(int, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Atomically adds the given value to the element at index i.
getAndDecrement() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Atomically decrements by one the current value.
getAndDecrement(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Atomically decrements by one the element at index i.
getAndDecrement() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Atomically decrements by one the current value.
getAndDecrement(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Atomically decrements by one the element at index i.
getAndIncrement() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Atomically increments by one the current value.
getAndIncrement(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Atomically increments by one the element at index i.
getAndIncrement() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Atomically increments by one the current value.
getAndIncrement(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Atomically increments by one the element at index i.
getAndSet(boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean: Atomically sets to the given value and returns the previous value.
getAndSet(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Atomically sets to the given value and returns the old value.
getAndSet(int, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Atomically sets the element at position i to the given value and returns the old value.
getAndSet(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Atomically sets to the given value and returns the old value.
getAndSet(int, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Atomically sets the element at position i to the given value and returns the old value.
getAndSet(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference: Atomically sets to the given value and returns the old value.
getAndSet(int, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray: Atomically sets the element at position i to the given value and returns the old value.
getCompletedTaskCount() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the approximate total number of tasks that have completed execution.
getContinueExistingPeriodicTasksAfterShutdownPolicy() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Gets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown.
getCorePoolSize() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the core number of threads.
getCount() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch: Returns the current count.
getDelay(TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.Delayed: Returns the remaining delay associated with this object, in the given time unit.
getExecuteExistingDelayedTasksAfterShutdownPolicy() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Gets the policy on whether to execute existing delayed tasks even when this executor has been shutdown.
getFirst() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
getFirst() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
getFirst() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves, but does not remove, the first element of this deque.
getFirst() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
getHoldCount() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Queries the number of holds on this lock by the current thread.
getHoldCount() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Queries the number of holds on this write lock by the current thread.
getKeepAliveTime(TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the thread keep-alive time, which is the amount of time that threads in excess of the core pool size may remain idle before being terminated.
getKey() - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleEntry: Returns the key corresponding to this entry.
getKey() - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleImmutableEntry: Returns the key corresponding to this entry.
getKey() - Method in class edu.emory.mathcs.backport.java.util.TreeMap.Entry
getLargestPoolSize() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the largest number of threads that have ever simultaneously been in the pool.
getLast() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
getLast() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
getLast() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves, but does not remove, the last element of this deque.
getLast() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
getLength() - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
getLength() - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue
getMaximumPoolSize() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the maximum allowed number of threads.
getNumberWaiting() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CyclicBarrier: Returns the number of parties currently waiting at the barrier.
getOwner() - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue.WaitNode
getOwner() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Returns the thread that currently owns this lock, or null if not owned.
getOwner() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock: Returns the thread that currently owns the write lock, or null if not owned.
getParties() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CyclicBarrier: Returns the number of parties required to trip this barrier.
getPoolSize() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the current number of threads in the pool.
getQueue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Returns the task queue used by this executor.
getQueue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the task queue used by this executor.
getQueuedThreads() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Returns a collection containing threads that may be waiting to acquire this lock.
getQueuedThreads() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Returns a collection containing threads that may be waiting to acquire.
getQueueLength() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Returns an estimate of the number of threads waiting to acquire this lock.
getQueueLength() - Method in class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.Semaphore: Returns an estimate of the number of threads waiting to acquire.
getReadHoldCount() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock: Queries the number of reentrant read holds on this lock by the current thread.
getReadLockCount() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock: Queries the number of read locks held for this lock.
getReference() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicMarkableReference: Returns the current value of the reference.
getReference() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicStampedReference: Returns the current value of the reference.
getRejectedExecutionHandler() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the current handler for unexecutable tasks.
getRemoveOnCancelPolicy() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Gets the policy on whether to cancellation of a a task should remove it from the work queue.
getStamp() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicStampedReference: Returns the current value of the stamp.
getTaskCount() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the approximate total number of tasks that have ever been scheduled for execution.
getThreadFactory() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns the thread factory used to create new threads.
getValue() - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleEntry: Returns the value corresponding to this entry.
getValue() - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleImmutableEntry: Returns the value corresponding to this entry.
getValue() - Method in class edu.emory.mathcs.backport.java.util.TreeMap.Entry: return the element value
getWaitingThreads() - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
getWaitingThreads() - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue
getWaitingThreads(Condition) - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Returns a collection containing those threads that may be waiting on the given condition associated with this lock.
getWaitQueueLength(Condition) - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Returns an estimate of the number of threads waiting on the given condition associated with this lock.
getWriteHoldCount() - Method in class edu.emory.mathcs.backport.java.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.backport.java.util.AbstractMap.SimpleEntry
hashCode() - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleImmutableEntry
hashCode(long[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
hashCode(int[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
hashCode(short[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
hashCode(char[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
hashCode(byte[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
hashCode(boolean[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
hashCode(float[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
hashCode(double[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
hashCode(Object[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
hashCode() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
hashCode() - Method in class edu.emory.mathcs.backport.java.util.TreeMap.Entry
hasNodes() - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
hasNodes() - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue
hasQueuedThread(Thread) - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Queries whether the given thread is waiting to acquire this lock.
hasQueuedThreads() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Queries whether any threads are waiting to acquire this lock.
hasQueuedThreads() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock: Queries whether any threads are waiting to acquire the read or write lock.
hasQueuedThreads() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Queries whether any threads are waiting to acquire.
hasWaiters(Condition) - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Queries whether any threads are waiting on the given condition associated with this lock.
head_ - Variable in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
headMap(Object, boolean) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap
headMap(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap
headMap(Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
headMap(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
headMap(Object, boolean) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a view of the portion of this map whose keys are less than (or equal to, if inclusive is true) toKey.
headMap(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap
headMap(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
headMap(Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
headSet(Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
headSet(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
headSet(Object, boolean) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns a view of the portion of this set whose elements are less than (or equal to, if inclusive is true) toElement.
headSet(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet
headSet(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
headSet(Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
higher(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
higher(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns the least element in this set strictly greater than the given element, or null if there is no such element.
higher(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
higherEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.
higherEntry(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.
higherEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
higherKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
higherKey(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns the least key strictly greater than the given key, or null if there is no such key.
higherKey(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
HOURS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit

I

incrementAndGet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Atomically increments by one the current value.
incrementAndGet(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Atomically increments by one the element at index i.
incrementAndGet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Atomically increments by one the current value.
incrementAndGet(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Atomically increments by one the element at index i.
indexOf(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
indexOf(Object, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
indexOf(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
indexOfSubList(List, List) - Static method in class edu.emory.mathcs.backport.java.util.Collections
insert(WaitQueue.WaitNode) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
insert(WaitQueue.WaitNode) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue
intValue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger
intValue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong
invokeAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService
invokeAll(Collection, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService
invokeAll(Collection) - Method in interface edu.emory.mathcs.backport.java.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 interface edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.AbstractExecutorService
invokeAny(Collection, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService
invokeAny(Collection) - Method in interface edu.emory.mathcs.backport.java.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 interface edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.CyclicBarrier: Queries if this barrier is in a broken state.
isCancelled() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.Future: Returns true if this task was cancelled before it completed normally.
isCancelled() - Method in class edu.emory.mathcs.backport.java.util.concurrent.FutureTask
isDone() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.Future: Returns true if this task completed.
isDone() - Method in class edu.emory.mathcs.backport.java.util.concurrent.FutureTask
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Returns true if this deque contains no elements.
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Returns true if this map contains no key-value mappings.
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue: Returns true if this queue contains no elements.
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns true if this map contains no key-value mappings.
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Returns true if this set contains no elements.
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Returns true if this set contains no elements.
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Always returns true.
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Returns true if this queue contains no elements.
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
isEmpty() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
isFair() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Returns true if this lock has fairness set true.
isFair() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock: Returns true if this lock has fairness set true.
isFair() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Returns true if this semaphore has fairness set true.
isHeldByCurrentThread() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Queries if this lock is held by the current thread.
isHeldByCurrentThread() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Queries if this write lock is held by the current thread.
isLocked() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Queries if this lock is held by any thread.
isMarked() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicMarkableReference: Returns the current value of the mark.
isPeriodic() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.RunnableScheduledFuture: Returns true if this is a periodic task.
isShutdown() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ExecutorService: Returns true if this executor has been shut down.
isShutdown() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor
isTerminated() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ExecutorService: Returns true if all tasks have completed following shut down.
isTerminated() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor
isTerminating() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Returns true if this executor is in the process of terminating after ThreadPoolExecutor.shutdown() or ThreadPoolExecutor.shutdownNow() but has not completely terminated.
isWaiting(Thread) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
isWaiting(Thread) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue
isWriteLocked() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock: Queries if the write lock is held by any thread.
isWriteLockedByCurrentThread() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock: Queries if the write lock is held by the current thread.
iterator() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Returns an iterator over the elements in this deque.
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Returns an iterator over the elements in this queue in proper sequence.
iterator() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Returns an iterator over the elements in this deque in proper sequence.
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue: Returns an iterator over the elements in this queue in proper sequence.
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Returns an iterator over the elements in this set in ascending order.
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Returns an iterator over the elements contained in this set in the order in which these elements were added.
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Returns an iterator over all the elements (both expired and unexpired) in this queue.
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Returns an iterator over the elements in this deque in proper sequence.
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Returns an iterator over the elements in this queue in proper sequence.
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Returns an iterator over the elements in this queue.
iterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Returns an empty iterator in which hasNext always returns false.
iterator() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Returns an iterator over the elements in this deque in proper sequence.
iterator() - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns an iterator over the elements in this set, in ascending order.
iterator() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Returns an iterator over the elements in this queue.
iterator() - Method in class edu.emory.mathcs.backport.java.util.TreeSet

K

keys() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Returns an enumeration of the keys in this table.
keySet() - Method in class edu.emory.mathcs.backport.java.util.AbstractMap
keySet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Returns a Set view of the keys contained in this map.
keySet() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap: Returns a NavigableSet view of the keys contained in this map.
keySet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a NavigableSet view of the keys contained in this map.
keySet() - Method in class edu.emory.mathcs.backport.java.util.TreeMap

L

last() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
last() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
lastEntry() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
lastEntry() - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
lastEntry() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
lastIndexOf(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
lastIndexOf(Object, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
lastIndexOf(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
lastIndexOfSubList(List, List) - Static method in class edu.emory.mathcs.backport.java.util.Collections
lastKey() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
lastKey() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
lazySet(boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean: Eventually sets to the given value.
lazySet(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Eventually sets to the given value.
lazySet(int, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Eventually sets the element at position i to the given value.
lazySet(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Eventually sets to the given value.
lazySet(int, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Eventually sets the element at position i to the given value.
lazySet(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference: Eventually sets to the given value.
lazySet(int, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray: Eventually sets the element at position i to the given value.
length() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Returns the length of the array.
length() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Returns the length of the array.
length() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray: Returns the length of the array.
LinkedBlockingDeque - Class in edu.emory.mathcs.backport.java.util.concurrent: An optionally-bounded blocking deque based on linked nodes.
LinkedBlockingDeque() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE.
LinkedBlockingDeque(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Creates a LinkedBlockingDeque with the given (fixed) capacity.
LinkedBlockingDeque(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE, initially containing the elements of the given collection, added in traversal order of the collection's iterator.
LinkedBlockingQueue - Class in edu.emory.mathcs.backport.java.util.concurrent: An optionally-bounded blocking queue based on linked nodes.
LinkedBlockingQueue() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Creates a LinkedBlockingQueue with a capacity of Integer.MAX_VALUE.
LinkedBlockingQueue(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Creates a LinkedBlockingQueue with the given (fixed) capacity.
LinkedBlockingQueue(Collection) - Constructor for class edu.emory.mathcs.backport.java.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.
LinkedList - Class in edu.emory.mathcs.backport.java.util
LinkedList() - Constructor for class edu.emory.mathcs.backport.java.util.LinkedList
LinkedList(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.LinkedList
list(Enumeration) - Static method in class edu.emory.mathcs.backport.java.util.Collections
listIterator() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
listIterator(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
listIterator() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
listIterator(int) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
Lock - Interface in edu.emory.mathcs.backport.java.util.concurrent.locks: Lock implementations provide more extensive locking operations than can be obtained using synchronized methods and statements.
lock() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.locks.Lock: Acquires the lock.
lock() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Acquires the lock.
lock() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock: Acquires the read lock.
lock() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Acquires the write lock.
lockInterruptibly() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.locks.Lock: Acquires the lock unless the current thread is interrupted.
lockInterruptibly() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Acquires the lock unless the current thread is interrupted.
lockInterruptibly() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock: Acquires the read lock unless the current thread is interrupted.
lockInterruptibly() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Acquires the write lock unless the current thread is interrupted.
longValue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger
longValue() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong
lower(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
lower(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns the greatest element in this set strictly less than the given element, or null if there is no such element.
lower(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
lowerEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.
lowerEntry(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.
lowerEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
lowerKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
lowerKey(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns the greatest key strictly less than the given key, or null if there is no such key.
lowerKey(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap

M

max(Collection) - Static method in class edu.emory.mathcs.backport.java.util.Collections
max(Collection, Comparator) - Static method in class edu.emory.mathcs.backport.java.util.Collections
MICROSECONDS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
MILLISECONDS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
min(Collection) - Static method in class edu.emory.mathcs.backport.java.util.Collections
min(Collection, Comparator) - Static method in class edu.emory.mathcs.backport.java.util.Collections
MINUTES - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit

N

name() - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Returns the name of this enum constant, exactly as declared in its enum declaration.
NANOSECONDS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
nanoTime() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.helpers.NanoTimer: Returns the current value of the most precise available system timer, in nanoseconds.
nanoTime() - Static method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.Utils: Returns the current value of the most precise available system timer, in nanoseconds.
NanoTimer - Interface in edu.emory.mathcs.backport.java.util.concurrent.helpers: Interface to specify custom implementation of precise timer.
navigableKeySet() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap: Returns a NavigableSet view of the keys contained in this map.
navigableKeySet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
navigableKeySet() - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a NavigableSet view of the keys contained in this map.
navigableKeySet() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
NavigableMap - Interface in edu.emory.mathcs.backport.java.util: A SortedMap extended with navigation methods returning the closest matches for given search targets.
NavigableSet - Interface in edu.emory.mathcs.backport.java.util: A SortedSet extended with navigation methods reporting closest matches for given search targets.
nCopies(int, Object) - Static method in class edu.emory.mathcs.backport.java.util.Collections
newCachedThreadPool() - Static method in class edu.emory.mathcs.backport.java.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.backport.java.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 interface edu.emory.mathcs.backport.java.util.concurrent.locks.Lock: Returns a new Condition instance that is bound to this Lock instance.
newCondition() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Returns a Condition instance for use with this Lock instance.
newCondition() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock: Throws UnsupportedOperationException because ReadLocks do not support conditions.
newCondition() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Returns a Condition instance for use with this Lock instance.
newFixedThreadPool(int) - Static method in class edu.emory.mathcs.backport.java.util.concurrent.Executors: Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue.
newFixedThreadPool(int, ThreadFactory) - Static method in class edu.emory.mathcs.backport.java.util.concurrent.Executors: Creates a thread pool that reuses a fixed number 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.backport.java.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.backport.java.util.concurrent.Executors: Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.
newSetFromMap(Map) - Static method in class edu.emory.mathcs.backport.java.util.Collections
newSingleThreadExecutor() - Static method in class edu.emory.mathcs.backport.java.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.backport.java.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.backport.java.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.backport.java.util.concurrent.Executors: Creates a single-threaded executor that can schedule commands to run after a given delay, or to execute periodically.
newTaskFor(Runnable, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService: Returns a RunnableFuture for the given runnable and default value.
newTaskFor(Callable) - Method in class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService: Returns a RunnableFuture for the given callable task.
newThread(Runnable) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ThreadFactory: Constructs a new Thread.

O

offer(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Inserts the specified element at the end of this deque.
offer(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Inserts the specified element at the tail of this queue if it is possible to do so immediately without exceeding the queue's capacity, returning true upon success and false if this queue is full.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Inserts the specified element at the tail of this queue, waiting up to the specified wait time for space to become available if the queue is full.
offer(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and false if no space is currently available.
offer(Object, long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque), waiting up to the specified wait time if necessary for space to become available.
offer(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and false if no space is currently available.
offer(Object, long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available.
offer(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue: Inserts the specified element at the tail of this queue.
offer(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Inserts the specified element into this delay queue.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Inserts the specified element into this delay queue.
offer(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.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) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Inserts the specified element at the tail of this queue if it is possible to do so immediately without exceeding the queue's capacity, returning true upon success and false if this queue is full.
offer(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Inserts the specified element into this priority queue.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Inserts the specified element into this priority queue.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.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) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Inserts the specified element into this queue, if another thread is waiting to receive it.
offer(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and false if no space is currently available.
offer(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
offer(Object) - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Inserts the specified element into this priority queue.
offer(Object) - Method in interface edu.emory.mathcs.backport.java.util.Queue: Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions.
offerFirst(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Inserts the specified element at the front of this deque.
offerFirst(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element at the front of this deque if it is possible to do so immediately without violating capacity restrictions, returning true upon success and false if no space is currently available.
offerFirst(Object, long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element at the front of this deque, waiting up to the specified wait time if necessary for space to become available.
offerFirst(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
offerFirst(Object, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
offerFirst(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Inserts the specified element at the front of this deque unless it would violate capacity restrictions.
offerFirst(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
offerLast(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Inserts the specified element at the end of this deque.
offerLast(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element at the end of this deque if it is possible to do so immediately without violating capacity restrictions, returning true upon success and false if no space is currently available.
offerLast(Object, long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element at the end of this deque, waiting up to the specified wait time if necessary for space to become available.
offerLast(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
offerLast(Object, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
offerLast(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Inserts the specified element at the end of this deque unless it would violate capacity restrictions.
offerLast(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
ordinal() - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Returns the ordinal of this enumeration constant (its position in its enum declaration, where the initial constant is assigned an ordinal of zero).

P

peek() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Retrieves, but does not remove, the head of the queue represented by this deque, or returns null if this deque is empty.
peek() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue
peek() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque), or returns null if this deque is empty.
peek() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue
peek() - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
peek() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
peek() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue
peek() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue
peek() - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Always returns null.
peek() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque), or returns null if this deque is empty.
peek() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
peek() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
peek() - Method in interface edu.emory.mathcs.backport.java.util.Queue: Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
peekFirst() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
peekFirst() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
peekFirst() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves, but does not remove, the first element of this deque, or returns null if this deque is empty.
peekFirst() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
peekLast() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
peekLast() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
peekLast() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves, but does not remove, the last element of this deque, or returns null if this deque is empty.
peekLast() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
poll() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), or returns null if this deque is empty.
poll() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue
poll(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue
poll() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), or returns null if this deque is empty.
poll(long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), waiting up to the specified wait time if necessary for an element to become available.
poll(long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an element to become available.
poll() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.CompletionService: Retrieves and removes the Future representing the next completed task or null if none are present.
poll(long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.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() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue
poll() - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Retrieves and removes the head of this queue, or returns null if this queue has no elements with an expired delay.
poll(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Retrieves and removes the head of this queue, waiting if necessary until an element with an expired delay is available on this queue, or the specified wait time expires.
poll() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ExecutorCompletionService
poll(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ExecutorCompletionService
poll() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
poll(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
poll(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue
poll() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue
poll() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue
poll(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue
poll(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.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() - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Retrieves and removes the head of this queue, if another thread is currently making an element available.
poll() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), or returns null if this deque is empty.
poll() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
poll() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Retrieves and removes the head of this queue, or returns null if this queue is empty.
poll() - Method in interface edu.emory.mathcs.backport.java.util.Queue: Retrieves and removes the head of this queue, or returns null if this queue is empty.
pollFirst() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
pollFirst(long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves and removes the first element of this deque, waiting up to the specified wait time if necessary for an element to become available.
pollFirst() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
pollFirst() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
pollFirst(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
pollFirst() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves and removes the first element of this deque, or returns null if this deque is empty.
pollFirst() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
pollFirst() - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Retrieves and removes the first (lowest) element, or returns null if this set is empty.
pollFirst() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
pollFirstEntry() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty.
pollFirstEntry() - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty.
pollFirstEntry() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
pollLast() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
pollLast(long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves and removes the last element of this deque, waiting up to the specified wait time if necessary for an element to become available.
pollLast() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
pollLast() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
pollLast(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
pollLast() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves and removes the last element of this deque, or returns null if this deque is empty.
pollLast() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
pollLast() - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Retrieves and removes the last (highest) element, or returns null if this set is empty.
pollLast() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
pollLastEntry() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
pollLastEntry() - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
pollLastEntry() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
pop() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Pops an element from the stack represented by this deque.
pop() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
pop() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Pops an element from the stack represented by this deque.
pop() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
prestartAllCoreThreads() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Starts all core threads, causing them to idly wait for work.
prestartCoreThread() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Starts a core thread, causing it to idly wait for work.
PriorityBlockingQueue - Class in edu.emory.mathcs.backport.java.util.concurrent: 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.backport.java.util.concurrent.PriorityBlockingQueue: Creates a PriorityBlockingQueue with the default initial capacity (11) that orders its elements according to their natural ordering.
PriorityBlockingQueue(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Creates a PriorityBlockingQueue with the specified initial capacity that orders its elements according to their natural ordering.
PriorityBlockingQueue(int, Comparator) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Creates a PriorityBlockingQueue with the specified initial capacity that orders its elements according to the specified comparator.
PriorityBlockingQueue(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Creates a PriorityBlockingQueue containing the elements in the specified collection.
PriorityQueue - Class in edu.emory.mathcs.backport.java.util: An unbounded queue that supports element retrieval in the order of relative priority.
PriorityQueue() - Constructor for class edu.emory.mathcs.backport.java.util.PriorityQueue: Creates a PriorityQueue with the default initial capacity (11) that orders its elements according to their natural ordering.
PriorityQueue(int) - Constructor for class edu.emory.mathcs.backport.java.util.PriorityQueue: Creates a PriorityQueue with the specified initial capacity that orders its elements according to their natural ordering.
PriorityQueue(Comparator) - Constructor for class edu.emory.mathcs.backport.java.util.PriorityQueue: Creates a PriorityQueue with the specified initial capacity that orders its elements according to the specified comparator.
PriorityQueue(int, Comparator) - Constructor for class edu.emory.mathcs.backport.java.util.PriorityQueue
PriorityQueue(PriorityQueue) - Constructor for class edu.emory.mathcs.backport.java.util.PriorityQueue: Creates a PriorityQueue containing the elements from the specified priority queue.
PriorityQueue(SortedSet) - Constructor for class edu.emory.mathcs.backport.java.util.PriorityQueue: Creates a PriorityQueue containing the elements from the specified sorted set.
PriorityQueue(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.PriorityQueue: Creates a PriorityQueue containing the elements in the specified collection.
privilegedCallable(Callable) - Static method in class edu.emory.mathcs.backport.java.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.backport.java.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.backport.java.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.backport.java.util.concurrent.ThreadPoolExecutor: Tries to remove from the work queue all Future tasks that have been cancelled.
push(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Pushes an element onto the stack represented by this deque.
push(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Pushes an element onto the stack represented by this deque.
push(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
push(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Pushes an element onto the stack represented by this deque (in other words, at the head of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
push(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
put(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Inserts the specified element at the tail of this queue, waiting for space to become available if the queue is full.
put(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque), waiting if necessary for space to become available.
put(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Inserts the specified element into this queue, waiting if necessary for space to become available.
put(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Maps the specified key to the specified value in this table.
put(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Associates the specified value with the specified key in this map.
put(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Inserts the specified element into this delay queue.
put(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
put(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Inserts the specified element at the tail of this queue, waiting if necessary for space to become available.
put(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Inserts the specified element into this priority queue.
put(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Adds the specified element to this queue, waiting if necessary for another thread to receive it.
put(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
putAll(Map) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Copies all of the mappings from the specified map to this one.
putAll(Map) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
putBack(WaitQueue.WaitNode) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
putBack(WaitQueue.WaitNode) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue
putFirst(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element at the front of this deque, waiting if necessary for space to become available.
putFirst(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
putIfAbsent(Object, Object) - Method in class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.ConcurrentMap: If the specified key is not already associated with a value, associate it with the given value.
putIfAbsent(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: If the specified key is not already associated with a value, associate it with the given value.
putLast(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Inserts the specified element at the end of this deque, waiting if necessary for space to become available.
putLast(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque

Q

Queue - Interface in edu.emory.mathcs.backport.java.util: A collection designed for holding elements prior to processing.

R

readLock() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.locks.ReadWriteLock: Returns the lock used for reading.
readLock() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock
readResolve() - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
ReadWriteLock - Interface in edu.emory.mathcs.backport.java.util.concurrent.locks: 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.backport.java.util.concurrent.helpers.WaitQueue.QueuedSync
reducePermits(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Shrinks the number of available permits by the indicated reduction.
ReentrantLock - Class in edu.emory.mathcs.backport.java.util.concurrent.locks: 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.backport.java.util.concurrent.locks.ReentrantLock: Creates an instance of ReentrantLock.
ReentrantLock(boolean) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Creates an instance of ReentrantLock with the given fairness policy.
ReentrantReadWriteLock - Class in edu.emory.mathcs.backport.java.util.concurrent.locks: An implementation of ReadWriteLock supporting similar semantics to ReentrantLock.
ReentrantReadWriteLock() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock: Creates a new ReentrantReadWriteLock with default (nonfair) ordering properties.
ReentrantReadWriteLock.ReadLock - Class in edu.emory.mathcs.backport.java.util.concurrent.locks: The lock returned by method ReentrantReadWriteLock.readLock().
ReentrantReadWriteLock.ReadLock(ReentrantReadWriteLock) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock: Constructor for use by subclasses
ReentrantReadWriteLock.WriteLock - Class in edu.emory.mathcs.backport.java.util.concurrent.locks: The lock returned by method ReentrantReadWriteLock.writeLock().
ReentrantReadWriteLock.WriteLock(ReentrantReadWriteLock) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Constructor for use by subclasses
rejectedExecution(Runnable, ThreadPoolExecutor) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionHandler: Method that may be invoked by a ThreadPoolExecutor when execute cannot accept a task.
rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.AbortPolicy: Always throws RejectedExecutionException.
rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class edu.emory.mathcs.backport.java.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 class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.ThreadPoolExecutor.DiscardPolicy: Does nothing, which has the effect of discarding task r.
RejectedExecutionException - Exception in edu.emory.mathcs.backport.java.util.concurrent: Exception thrown by an Executor when a task cannot be accepted for execution.
RejectedExecutionException() - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException: Constructs a RejectedExecutionException with no detail message.
RejectedExecutionException(String) - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException: Constructs a RejectedExecutionException with the specified detail message.
RejectedExecutionException(String, Throwable) - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException: Constructs a RejectedExecutionException with the specified detail message and cause.
RejectedExecutionException(Throwable) - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException: Constructs a RejectedExecutionException with the specified cause.
RejectedExecutionHandler - Interface in edu.emory.mathcs.backport.java.util.concurrent: A handler for tasks that cannot be executed by a ThreadPoolExecutor.
release() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Releases a permit, returning it to the semaphore.
release(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Releases the given number of permits, returning them to the semaphore.
remainingCapacity() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Returns the number of additional elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking.
remainingCapacity() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Returns the number of additional elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking, or Integer.MAX_VALUE if there is no intrinsic limit.
remainingCapacity() - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Always returns Integer.MAX_VALUE because a DelayQueue is not capacity constrained.
remainingCapacity() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Returns the number of additional elements that this deque can ideally (in the absence of memory or resource constraints) accept without blocking.
remainingCapacity() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Returns the number of additional elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking.
remainingCapacity() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Always returns Integer.MAX_VALUE because a PriorityBlockingQueue is not capacity constrained.
remainingCapacity() - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Always returns zero.
remove() - Method in class edu.emory.mathcs.backport.java.util.AbstractQueue: Retrieves and removes the head of this queue.
remove() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Retrieves and removes the head of the queue represented by this deque.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Removes a single instance of the specified element from this deque.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Removes a single instance of the specified element from this queue, if it is present.
remove() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque).
remove(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Removes the first occurrence of the specified element from this deque.
remove(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Removes a single instance of the specified element from this queue, if it is present.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Removes the key (and its corresponding value) from this map.
remove(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Removes the entry for a key only if currently mapped to a given value.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue: Removes a single instance of the specified element from this queue, if it is present.
remove(Object, Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentMap: Removes the entry for a key only if currently mapped to a given value.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Removes the mapping for the specified key from this map if present.
remove(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Removes the entry for a key only if currently mapped to a given value.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Removes the specified element from this set if it is present.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
remove(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Removes the specified element from this set if it is present.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Removes a single instance of the specified element from this queue, if it is present, whether or not it has expired.
remove() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Retrieves and removes the head of the queue represented by this deque.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Removes the first occurrence of the specified element from this deque.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Removes a single instance of the specified element from this queue, if it is present.
remove(Object) - Method in class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.SynchronousQueue: Always returns false.
remove(Runnable) - Method in class edu.emory.mathcs.backport.java.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.
remove() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque).
remove(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Removes the first occurrence of the specified element from this deque.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
remove(int) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
remove() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
remove() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Retrieves and removes the head of this queue.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Removes a single instance of the specified element from this queue, if it is present.
remove() - Method in interface edu.emory.mathcs.backport.java.util.Queue: Retrieves and removes the head of this queue.
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
remove(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
removeAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Removes from this set all of its elements that are contained in the specified collection.
removeAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
removeAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Removes from this set all of its elements that are contained in the specified collection.
removeAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Always returns false.
removeFirst() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
removeFirst() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
removeFirst() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves and removes the first element of this deque.
removeFirst() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
removeFirstOccurrence(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Removes the first occurrence of the specified element in this deque (when traversing the deque from head to tail).
removeFirstOccurrence(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Removes the first occurrence of the specified element from this deque.
removeFirstOccurrence(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
removeFirstOccurrence(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Removes the first occurrence of the specified element from this deque.
removeFirstOccurrence(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
removeLast() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
removeLast() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
removeLast() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Retrieves and removes the last element of this deque.
removeLast() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
removeLastOccurrence(Object) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Removes the last occurrence of the specified element in this deque (when traversing the deque from head to tail).
removeLastOccurrence(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Removes the last occurrence of the specified element from this deque.
removeLastOccurrence(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
removeLastOccurrence(Object) - Method in interface edu.emory.mathcs.backport.java.util.Deque: Removes the last occurrence of the specified element from this deque.
removeLastOccurrence(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
replace(Object, Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Replaces the entry for a key only if currently mapped to a given value.
replace(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Replaces the entry for a key only if currently mapped to some value.
replace(Object, Object, Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentMap: Replaces the entry for a key only if currently mapped to a given value.
replace(Object, Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentMap: Replaces the entry for a key only if currently mapped to some value.
replace(Object, Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Replaces the entry for a key only if currently mapped to a given value.
replace(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Replaces the entry for a key only if currently mapped to some value.
replaceAll(List, Object, Object) - Static method in class edu.emory.mathcs.backport.java.util.Collections
reset() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CyclicBarrier: Resets the barrier to its initial state.
retainAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
retainAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Retains only the elements in this set that are contained in the specified collection.
retainAll(Collection) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Always returns false.
reverse(List) - Static method in class edu.emory.mathcs.backport.java.util.Collections
reverseOrder() - Static method in class edu.emory.mathcs.backport.java.util.Collections
reverseOrder(Comparator) - Static method in class edu.emory.mathcs.backport.java.util.Collections
rotate(List, int) - Static method in class edu.emory.mathcs.backport.java.util.Collections
run() - Method in class edu.emory.mathcs.backport.java.util.concurrent.FutureTask: Sets this Future to the result of its computation unless it has been cancelled.
run() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.RunnableFuture: Sets this Future to the result of its computation unless it has been cancelled.
runAndReset() - Method in class edu.emory.mathcs.backport.java.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.
RunnableFuture - Interface in edu.emory.mathcs.backport.java.util.concurrent: A Future that is Runnable.
RunnableScheduledFuture - Interface in edu.emory.mathcs.backport.java.util.concurrent: A ScheduledFuture that is Runnable.

S

schedule(Runnable, long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ScheduledExecutorService: Creates and executes a one-shot action that becomes enabled after the given delay.
schedule(Callable, long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.ScheduledThreadPoolExecutor
schedule(Callable, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor
scheduleAtFixedRate(Runnable, long, long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.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.
scheduleAtFixedRate(Runnable, long, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor
ScheduledExecutorService - Interface in edu.emory.mathcs.backport.java.util.concurrent: An ExecutorService that can schedule commands to run after a given delay, or to execute periodically.
ScheduledFuture - Interface in edu.emory.mathcs.backport.java.util.concurrent: A delayed result-bearing action that can be cancelled.
ScheduledThreadPoolExecutor - Class in edu.emory.mathcs.backport.java.util.concurrent: 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.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Creates a new ScheduledThreadPoolExecutor with the given core pool size.
ScheduledThreadPoolExecutor(int, ThreadFactory) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
ScheduledThreadPoolExecutor(int, RejectedExecutionHandler) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
ScheduledThreadPoolExecutor(int, ThreadFactory, RejectedExecutionHandler) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
scheduleWithFixedDelay(Runnable, long, long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.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.
scheduleWithFixedDelay(Runnable, long, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor
SECONDS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
Semaphore - Class in edu.emory.mathcs.backport.java.util.concurrent: A counting semaphore.
Semaphore(int) - Constructor for class edu.emory.mathcs.backport.java.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.backport.java.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.backport.java.util.concurrent.atomic.AtomicBoolean: Unconditionally sets to the given value.
set(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Sets to the given value.
set(int, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Sets the element at position i to the given value.
set(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Sets to the given value.
set(int, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Sets the element at position i to the given value.
set(Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicMarkableReference: Unconditionally sets the value of both the reference and mark.
set(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference: Sets to the given value.
set(int, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray: Sets the element at position i to the given value.
set(Object, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicStampedReference: Unconditionally sets the value of both the reference and stamp.
set(int, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
set(Object) - Method in class edu.emory.mathcs.backport.java.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(int, Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Sets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown.
setCorePoolSize(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Sets the core number of threads.
setException(Throwable) - Method in class edu.emory.mathcs.backport.java.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.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Sets the policy on whether to execute existing delayed tasks even when this executor has been shutdown.
setKeepAliveTime(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Sets the time limit for which threads may remain idle before being terminated.
setMaximumPoolSize(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Sets the maximum allowed number of threads.
setRejectedExecutionHandler(RejectedExecutionHandler) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Sets a new handler for unexecutable tasks.
setRemoveOnCancelPolicy(boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor: Sets the policy on whether to cancellation of a a task should remove it from the work queue.
setThreadFactory(ThreadFactory) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Sets the thread factory used to create new threads.
setValue(Object) - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleEntry: Replaces the value corresponding to this entry with the specified value.
setValue(Object) - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleImmutableEntry: Replaces the value corresponding to this entry with the specified value (optional operation).
setValue(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap.Entry: set the element value
shuffle(List) - Static method in class edu.emory.mathcs.backport.java.util.Collections
shuffle(List, Random) - Static method in class edu.emory.mathcs.backport.java.util.Collections
shutdown() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ExecutorService: 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.backport.java.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.backport.java.util.concurrent.ThreadPoolExecutor: Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
shutdownNow() - Method in interface edu.emory.mathcs.backport.java.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.
shutdownNow() - Method in class edu.emory.mathcs.backport.java.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.backport.java.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.
signal(WaitQueue.QueuedSync) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue.WaitNode
signal() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.locks.Condition: Wakes up one waiting thread.
signalAll() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.locks.Condition: Wakes up all waiting threads.
singleton(Object) - Static method in class edu.emory.mathcs.backport.java.util.Collections
singletonList(Object) - Static method in class edu.emory.mathcs.backport.java.util.Collections
singletonMap(Object, Object) - Static method in class edu.emory.mathcs.backport.java.util.Collections
size() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Returns the number of elements in this deque.
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Returns the number of elements in this queue.
size() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Returns the number of elements in this deque.
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Returns the number of key-value mappings in this map.
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue: Returns the number of elements in this queue.
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns the number of key-value mappings in this map.
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet: Returns the number of elements in this set.
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Returns the number of elements in this set.
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Returns the number of elements in this deque.
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Returns the number of elements in this queue.
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue
size() - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Always returns zero.
size() - Method in interface edu.emory.mathcs.backport.java.util.Deque: Returns the number of elements in this deque.
size() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
size() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Returns the number of elements in this priority queue.
size() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
size() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
sleep(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Performs a Thread.sleep using this unit.
sort(long[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(long[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(int[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(int[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(short[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(short[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(char[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(char[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(byte[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(byte[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(double[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(double[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(float[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(float[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(Object[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(Object[], int, int) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(Object[], Comparator) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(Object[], int, int, Comparator) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
sort(List) - Static method in class edu.emory.mathcs.backport.java.util.Collections
sort(List, Comparator) - Static method in class edu.emory.mathcs.backport.java.util.Collections
subList(int, int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
subMap(Object, boolean, Object, boolean) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap
subMap(Object, Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap
subMap(Object, boolean, Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
subMap(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
subMap(Object, boolean, Object, boolean) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a view of the portion of this map whose keys range from fromKey to toKey.
subMap(Object, Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap
subMap(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
subMap(Object, boolean, Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
submit(Runnable) - Method in class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService
submit(Runnable, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService
submit(Callable) - Method in class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService
submit(Callable) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.CompletionService: Submits a value-returning task for execution and returns a Future representing the pending results of the task.
submit(Runnable, Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.CompletionService: Submits a Runnable task for execution and returns a Future representing that task.
submit(Callable) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ExecutorCompletionService
submit(Runnable, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ExecutorCompletionService
submit(Callable) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ExecutorService: Submits a value-returning task for execution and returns a Future representing the pending results of the task.
submit(Runnable, Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ExecutorService: Submits a Runnable task for execution and returns a Future representing that task.
submit(Runnable) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ExecutorService: Submits a Runnable task for execution and returns a Future representing that task.
submit(Runnable) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor
submit(Runnable, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor
submit(Callable) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor
subSet(Object, boolean, Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
subSet(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
subSet(Object, boolean, Object, boolean) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns a view of the portion of this set whose elements range from fromElement to toElement.
subSet(Object, Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet
subSet(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
subSet(Object, boolean, Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
swap(List, int, int) - Static method in class edu.emory.mathcs.backport.java.util.Collections
synchronizedCollection(Collection) - Static method in class edu.emory.mathcs.backport.java.util.Collections
synchronizedList(List) - Static method in class edu.emory.mathcs.backport.java.util.Collections
synchronizedMap(Map) - Static method in class edu.emory.mathcs.backport.java.util.Collections
synchronizedSet(Set) - Static method in class edu.emory.mathcs.backport.java.util.Collections
synchronizedSortedMap(SortedMap) - Static method in class edu.emory.mathcs.backport.java.util.Collections
synchronizedSortedSet(SortedSet) - Static method in class edu.emory.mathcs.backport.java.util.Collections
SynchronousQueue - Class in edu.emory.mathcs.backport.java.util.concurrent: A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.
SynchronousQueue() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Creates a SynchronousQueue with nonfair access policy.
SynchronousQueue(boolean) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Creates a SynchronousQueue with specified fairness policy.

T

tail_ - Variable in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
tailMap(Object, boolean) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap
tailMap(Object) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap
tailMap(Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
tailMap(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
tailMap(Object, boolean) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap: Returns a view of the portion of this map whose keys are greater than (or equal to, if inclusive is true) fromKey.
tailMap(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap
tailMap(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
tailMap(Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
tailSet(Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
tailSet(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
tailSet(Object, boolean) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet: Returns a view of the portion of this set whose elements are greater than (or equal to, if inclusive is true) fromElement.
tailSet(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableSet
tailSet(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
tailSet(Object, boolean) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
take() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue
take() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), waiting if necessary until an element becomes available.
take() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue: Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.
take() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.CompletionService: Retrieves and removes the Future representing the next completed task, waiting if none are yet present.
take() - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Retrieves and removes the head of this queue, waiting if necessary until an element with an expired delay is available on this queue.
take() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ExecutorCompletionService
take() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
take() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue
take() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue
take() - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Retrieves and removes the head of this queue, waiting if necessary for another thread to insert it.
takeFirst() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves and removes the first element of this deque, waiting if necessary until an element becomes available.
takeFirst() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
takeLast() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque: Retrieves and removes the last element of this deque, waiting if necessary until an element becomes available.
takeLast() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
takeOver(WaitQueue.WaitNode) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue.QueuedSync
terminated() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Method invoked when the Executor has terminated.
ThreadFactory - Interface in edu.emory.mathcs.backport.java.util.concurrent: An object that creates new threads on demand.
ThreadHelpers - Class in edu.emory.mathcs.backport.java.util.concurrent.helpers: Emulation of some new functionality present in java.lang.Thread in J2SE 5.0.
ThreadHelpers.UncaughtExceptionHandler - Interface in edu.emory.mathcs.backport.java.util.concurrent.helpers: Abstraction of the exception handler which receives notifications of exceptions occurred possibly in various parts of the system.
ThreadPoolExecutor - Class in edu.emory.mathcs.backport.java.util.concurrent: An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured using Executors factory methods.
ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Creates a new ThreadPoolExecutor with the given initial parameters and default thread factory and rejected execution handler.
ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Creates a new ThreadPoolExecutor with the given initial parameters and default rejected execution handler.
ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, RejectedExecutionHandler) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Creates a new ThreadPoolExecutor with the given initial parameters and default thread factory.
ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory, RejectedExecutionHandler) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor: Creates a new ThreadPoolExecutor with the given initial parameters.
ThreadPoolExecutor.AbortPolicy - Class in edu.emory.mathcs.backport.java.util.concurrent: A handler for rejected tasks that throws a RejectedExecutionException.
ThreadPoolExecutor.AbortPolicy() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.AbortPolicy: Creates an AbortPolicy.
ThreadPoolExecutor.CallerRunsPolicy - Class in edu.emory.mathcs.backport.java.util.concurrent: 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.backport.java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy: Creates a CallerRunsPolicy.
ThreadPoolExecutor.DiscardOldestPolicy - Class in edu.emory.mathcs.backport.java.util.concurrent: 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.backport.java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy: Creates a DiscardOldestPolicy for the given executor.
ThreadPoolExecutor.DiscardPolicy - Class in edu.emory.mathcs.backport.java.util.concurrent: A handler for rejected tasks that silently discards the rejected task.
ThreadPoolExecutor.DiscardPolicy() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.DiscardPolicy: Creates a DiscardPolicy.
timedJoin(Thread, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Performs a timed Thread.join using this time unit.
timedWait(Object, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Performs a timed Object.wait using this time unit.
TimeoutException - Exception in edu.emory.mathcs.backport.java.util.concurrent: Exception thrown when a blocking operation times out.
TimeoutException() - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.TimeoutException: Constructs a TimeoutException with no specified detail message.
TimeoutException(String) - Constructor for exception edu.emory.mathcs.backport.java.util.concurrent.TimeoutException: Constructs a TimeoutException with the specified detail message.
TimeUnit - Class in edu.emory.mathcs.backport.java.util.concurrent: 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.backport.java.util.AbstractCollection
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.AbstractCollection
toArray() - Method in class edu.emory.mathcs.backport.java.util.AbstractList
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.AbstractList
toArray() - Method in class edu.emory.mathcs.backport.java.util.AbstractSequentialList
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.AbstractSequentialList
toArray() - Method in class edu.emory.mathcs.backport.java.util.AbstractSet
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.AbstractSet
toArray() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Returns an array containing all of the elements in this deque in proper sequence (from first to last element).
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque: Returns an array containing all of the elements in this deque in proper sequence (from first to last element); the runtime type of the returned array is that of the specified array.
toArray() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Returns an array containing all of the elements in this queue, in proper sequence.
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue: Returns an array containing all of the elements in this queue, in proper sequence; the runtime type of the returned array is that of the specified array.
toArray() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
toArray() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Returns an array containing all of the elements in this set.
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet: Returns an array containing all of the elements in this set; the runtime type of the returned array is that of the specified array.
toArray() - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Returns an array containing all of the elements in this queue.
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue: Returns an array containing all of the elements in this queue; the runtime type of the returned array is that of the specified array.
toArray() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Returns an array containing all of the elements in this deque, in proper sequence (from first to last element).
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque: Returns an array containing all of the elements in this deque, in proper sequence; the runtime type of the returned array is that of the specified array.
toArray() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Returns an array containing all of the elements in this queue, in proper sequence.
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue: Returns an array containing all of the elements in this queue, in proper sequence; the runtime type of the returned array is that of the specified array.
toArray() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Returns an array containing all of the elements in this queue.
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue: Returns an array containing all of the elements in this queue; the runtime type of the returned array is that of the specified array.
toArray() - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Returns a zero-length array.
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue: Sets the zeroeth element of the specified array to null (if the array has non-zero length) and returns it.
toArray() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
toArray() - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Returns an array containing all of the elements in this queue.
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.PriorityQueue: Returns an array containing all of the elements in this queue; the runtime type of the returned array is that of the specified array.
toArray() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
toArray(Object[]) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
toDays(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Equivalent to DAYS.convert(duration, this).
toHours(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Equivalent to HOURS.convert(duration, this).
toMicros(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Equivalent to MICROSECONDS.convert(duration, this).
toMillis(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Equivalent to MILLISECONDS.convert(duration, this).
toMinutes(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Equivalent to MINUTES.convert(duration, this).
toNanos(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Equivalent to NANOSECONDS.convert(duration, this).
toSeconds(long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Equivalent to SECONDS.convert(duration, this).
toString() - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleEntry: Returns a String representation of this map entry.
toString() - Method in class edu.emory.mathcs.backport.java.util.AbstractMap.SimpleImmutableEntry: Returns a String representation of this map entry.
toString(long[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
toString(int[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
toString(short[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
toString(char[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
toString(byte[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
toString(boolean[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
toString(float[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
toString(double[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
toString(Object[]) - Static method in class edu.emory.mathcs.backport.java.util.Arrays
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean: Returns the String representation of the current value.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger: Returns the String representation of the current value.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray: Returns the String representation of the current values of array.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong: Returns the String representation of the current value.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray: Returns the String representation of the current values of array.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference: Returns the String representation of the current value.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray: Returns the String representation of the current values of array.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch: Returns a string identifying this latch, as well as its state.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Returns a string identifying this lock, as well as its lock state.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock: Returns a string identifying this lock, as well as its lock state.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock: Returns a string identifying this lock, as well as its lock state.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Returns a string identifying this lock, as well as its lock state.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Returns a string identifying this semaphore, as well as its state.
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
toString() - Method in class edu.emory.mathcs.backport.java.util.TreeMap.Entry
TreeMap - Class in edu.emory.mathcs.backport.java.util: Sorted map implementation based on a red-black tree and implementing all the methods from the NavigableMap interface.
TreeMap() - Constructor for class edu.emory.mathcs.backport.java.util.TreeMap
TreeMap(Comparator) - Constructor for class edu.emory.mathcs.backport.java.util.TreeMap
TreeMap(SortedMap) - Constructor for class edu.emory.mathcs.backport.java.util.TreeMap
TreeMap(Map) - Constructor for class edu.emory.mathcs.backport.java.util.TreeMap
TreeMap.Entry - Class in edu.emory.mathcs.backport.java.util
TreeMap.Entry(Object, Object) - Constructor for class edu.emory.mathcs.backport.java.util.TreeMap.Entry: Make a new node with given element, null links, and BLACK color.
TreeSet - Class in edu.emory.mathcs.backport.java.util
TreeSet() - Constructor for class edu.emory.mathcs.backport.java.util.TreeSet
TreeSet(Comparator) - Constructor for class edu.emory.mathcs.backport.java.util.TreeSet
TreeSet(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.TreeSet
TreeSet(SortedSet) - Constructor for class edu.emory.mathcs.backport.java.util.TreeSet
tryAcquire() - Method in class edu.emory.mathcs.backport.java.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.backport.java.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.
tryAcquire(int) - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Acquires the given number of permits from this semaphore, only if all are available at the time of invocation.
tryAcquire(int, long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore: Acquires the given number of permits from this semaphore, if all become available within the given waiting time and the current thread has not been interrupted.
tryLock() - Method in interface edu.emory.mathcs.backport.java.util.concurrent.locks.Lock: Acquires the lock only if it is free at the time of invocation.
tryLock(long, TimeUnit) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.locks.Lock: Acquires the lock if it is free within the given waiting time and the current thread has not been interrupted.
tryLock() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Acquires the lock only if it is not held by another thread at the time of invocation.
tryLock(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.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() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock: Acquires the read lock only if the write lock is not held by another thread at the time of invocation.
tryLock(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock: Acquires the read lock if the write lock is not held by another thread within the given waiting time and the current thread has not been interrupted.
tryLock() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Acquires the write lock only if it is not held by another thread at the time of invocation.
tryLock(long, TimeUnit) - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Acquires the write lock if it is not held by another thread within the given waiting time and the current thread has not been interrupted.

U

uncaughtException(Thread, Throwable) - Method in interface edu.emory.mathcs.backport.java.util.concurrent.helpers.ThreadHelpers.UncaughtExceptionHandler: Notification of the uncaught exception that occurred within specified thread.
unconfigurableExecutorService(ExecutorService) - Static method in class edu.emory.mathcs.backport.java.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.backport.java.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 interface edu.emory.mathcs.backport.java.util.concurrent.locks.Lock: Releases the lock.
unlock() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock: Attempts to release this lock.
unlock() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock: Attempts to release this lock.
unlock() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock: Attempts to release this lock.
unmodifiableCollection(Collection) - Static method in class edu.emory.mathcs.backport.java.util.Collections
unmodifiableList(List) - Static method in class edu.emory.mathcs.backport.java.util.Collections
unmodifiableMap(Map) - Static method in class edu.emory.mathcs.backport.java.util.Collections
unmodifiableSet(Set) - Static method in class edu.emory.mathcs.backport.java.util.Collections
unmodifiableSortedMap(SortedMap) - Static method in class edu.emory.mathcs.backport.java.util.Collections
unmodifiableSortedSet(SortedSet) - Static method in class edu.emory.mathcs.backport.java.util.Collections
Utils - Class in edu.emory.mathcs.backport.java.util.concurrent.helpers: This class groups together the functionality of java.util.concurrent that cannot be fully and reliably implemented in backport, but for which some form of emulation is possible.

V

valueOf(String) - Static method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit: Returns the enum constant of this type with the specified name.
values() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap: Returns a Collection view of the values contained in this map.
values() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap: Returns a Collection view of the values contained in this map.
values() - Static method in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit

W

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

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