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 edu.emory.mathcs.backport.java.util.AbstractCollection.
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 edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService.
Provides default implementations of ExecutorService execution methods.
AbstractExecutorService() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.AbstractExecutorService
 
AbstractList - class edu.emory.mathcs.backport.java.util.AbstractList.
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 edu.emory.mathcs.backport.java.util.AbstractMap.
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 edu.emory.mathcs.backport.java.util.AbstractMap.SimpleEntry.
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 edu.emory.mathcs.backport.java.util.AbstractMap.SimpleImmutableEntry.
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 edu.emory.mathcs.backport.java.util.AbstractQueue.
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 edu.emory.mathcs.backport.java.util.AbstractSequentialList.
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 edu.emory.mathcs.backport.java.util.AbstractSet.
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.
ArrayBlockingQueue - class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue.
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 edu.emory.mathcs.backport.java.util.ArrayDeque.
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 edu.emory.mathcs.backport.java.util.Arrays.
 
AtomicBoolean - class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean.
A value that may be updated atomically.
AtomicBoolean(boolean) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean
Creates a new with the given initial value.
AtomicBoolean() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean
Creates a new with initial value .
AtomicInteger - class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger.
An 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 .
AtomicIntegerArray - class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray.
An 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 edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong.
A 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 .
AtomicLongArray - class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray.
A 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 edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicMarkableReference.
An 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 with the given initial values.
AtomicReference - class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference.
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 edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray.
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 edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicStampedReference.
An 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 with the given initial values.
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 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
 
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.
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.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
 
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.
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 .
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 .
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.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
 
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
 
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.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
 
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
 
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.
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.
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

BlockingDeque - interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque.
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 edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue.
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 edu.emory.mathcs.backport.java.util.concurrent.BrokenBarrierException.
Exception thrown when a thread tries to wait upon a barrier that is in a broken state, or which enters the broken state while the thread is waiting.
BrokenBarrierException() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.BrokenBarrierException
Constructs a BrokenBarrierException with no specified detail message.
BrokenBarrierException(String) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.BrokenBarrierException
Constructs a BrokenBarrierException with the specified detail message.
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
 

C

Callable - interface edu.emory.mathcs.backport.java.util.concurrent.Callable.
A task that returns a result and may throw an exception.
CancellationException - exception edu.emory.mathcs.backport.java.util.concurrent.CancellationException.
Exception indicating that the result of a value-producing task, such as a FutureTask, cannot be retrieved because the task was cancelled.
CancellationException() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.CancellationException
Constructs a CancellationException with no detail message.
CancellationException(String) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.CancellationException
Constructs a CancellationException with the specified detail message.
Collections - class edu.emory.mathcs.backport.java.util.Collections.
Augments Collections with methods added in Java 5.0 and higher.
CompletionService - interface edu.emory.mathcs.backport.java.util.concurrent.CompletionService.
A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.
ConcurrentHashMap - class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap.
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 edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue.
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 edu.emory.mathcs.backport.java.util.concurrent.ConcurrentMap.
A Map providing additional atomic putIfAbsent, remove, and replace methods.
ConcurrentNavigableMap - interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentNavigableMap.
A ConcurrentMap supporting NavigableMap operations, and recursively so for its navigable sub-maps.
ConcurrentSkipListMap - class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap.
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 edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet.
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 edu.emory.mathcs.backport.java.util.concurrent.locks.Condition.
factors out the 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.
CopyOnWriteArrayList - class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList.
 
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 edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet.
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.
CountDownLatch - class edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch.
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
CountDownLatch(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.CountDownLatch
Constructs a initialized with the given count.
CyclicBarrier - class edu.emory.mathcs.backport.java.util.concurrent.CyclicBarrier.
A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
CyclicBarrier(int, 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.
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(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
 
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 if there is no such element.
ceiling(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
 
ceiling(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
 
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 if there is no such key.
ceilingEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
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 if there is no such key.
ceilingKey(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
ceilingKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
 
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.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
 
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.
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.LinkedList
 
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.TreeMap
 
clone() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
 
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
 
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.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
 
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.
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 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 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.
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 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
 
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 if this queue contains the specified element.
contains(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue
Always returns false.
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.TreeMap
 
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.
containsValue(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.
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
 
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.

D

DAYS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
 
DelayQueue - class edu.emory.mathcs.backport.java.util.concurrent.DelayQueue.
An unbounded blocking queue of Delayed elements, in which an element can only be taken when its delay has expired.
DelayQueue() - Constructor for class edu.emory.mathcs.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.
Delayed - interface edu.emory.mathcs.backport.java.util.concurrent.Delayed.
A mix-in style interface for marking objects that should be acted upon after a given delay.
Deque - interface edu.emory.mathcs.backport.java.util.Deque.
A linear collection that supports element insertion and removal at both ends.
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 .
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 .
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.
descendingIterator() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
 
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
 
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.
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
 
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
 
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
 
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
 
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
 
descendingSet() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
Returns a reverse order view of the elements contained in this set.
disjoint(Collection, Collection) - Static method in class edu.emory.mathcs.backport.java.util.Collections
 
doTimedWait(WaitQueue.QueuedSync, long) - Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue.WaitNode
 
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
 
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).
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
 
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

Exchanger - class edu.emory.mathcs.backport.java.util.concurrent.Exchanger.
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.
ExecutionException - exception edu.emory.mathcs.backport.java.util.concurrent.ExecutionException.
Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
ExecutionException() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ExecutionException
Constructs an ExecutionException with no detail message.
ExecutionException(String) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ExecutionException
Constructs an ExecutionException with the specified detail message.
ExecutionException(String, Throwable) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ExecutionException
Constructs an ExecutionException with the specified detail message and cause.
ExecutionException(Throwable) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ExecutionException
Constructs an ExecutionException with the specified cause.
Executor - interface edu.emory.mathcs.backport.java.util.concurrent.Executor.
An object that executes submitted Runnable tasks.
ExecutorCompletionService - class edu.emory.mathcs.backport.java.util.concurrent.ExecutorCompletionService.
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.
ExecutorService - interface edu.emory.mathcs.backport.java.util.concurrent.ExecutorService.
An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks.
Executors - class edu.emory.mathcs.backport.java.util.concurrent.Executors.
Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package.
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.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.
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.
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.TreeMap
 
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.
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.TreeMap.Entry
 
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.
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.
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.
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 edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue.
Simple linked list queue used in FIFOSemaphore.
FIFOWaitQueue() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
 
Future - interface edu.emory.mathcs.backport.java.util.concurrent.Future.
A Future represents the result of an asynchronous computation.
FutureTask - class edu.emory.mathcs.backport.java.util.concurrent.FutureTask.
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.
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 there are no threads.
first() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
 
first() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
 
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 if the map is empty.
firstEntry() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
firstKey() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
firstKey() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
 
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 interface edu.emory.mathcs.backport.java.util.NavigableSet
Returns the greatest element in this set less than or equal to the given element, or if there is no such element.
floor(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
 
floor(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
 
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 if there is no such key.
floorEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
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 if there is no such key.
floorKey(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
floorKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
 
frequency(Collection, Object) - Static method in class edu.emory.mathcs.backport.java.util.Collections
 

G

get(int) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
 
get(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
get(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap
Returns the value to which the specified key is mapped, or 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 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() - 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 .
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 .
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 .
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.
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 .
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 .
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 .
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 .
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 .
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 .
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 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 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 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 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
 
getFirst() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
 
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 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
 
getLast() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
 
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 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 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.
getQueueLength() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore
Returns an estimate of the number of threads 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.
getQueuedThreads() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore
Returns a collection containing threads that may be waiting to acquire.
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.
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.
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
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.
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.
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

HOURS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
 
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.Semaphore
Queries whether any threads are waiting to acquire.
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.
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.
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.TreeMap.Entry
 
hashCode() - Method in class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList
 
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 is true) .
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
 
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
 
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 is true) .
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
 
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
 
head_ - Variable in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
 
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 if there is no such element.
higher(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
 
higher(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
 
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 if there is no such key.
higherEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
higherKey(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap
Returns the least key strictly greater than the given key, or if there is no such key.
higherKey(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
higherKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
 

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 .
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 .
indexOf(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
 
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
 
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.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
 
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.
isFair() - Method in class edu.emory.mathcs.backport.java.util.concurrent.Semaphore
Returns if this semaphore has fairness set true.
isFair() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock
Returns if this lock has fairness set true.
isFair() - Method in class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock
Returns if this lock 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 shutdown or 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 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
 
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.

K

keySet() - Method in class edu.emory.mathcs.backport.java.util.AbstractMap
keySet() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
keys() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap
Returns an enumeration of the keys in this table.

L

LinkedBlockingDeque - class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque.
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 edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue.
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 edu.emory.mathcs.backport.java.util.LinkedList.
 
LinkedList() - Constructor for class edu.emory.mathcs.backport.java.util.LinkedList
 
LinkedList(Collection) - Constructor for class edu.emory.mathcs.backport.java.util.LinkedList
 
Lock - interface edu.emory.mathcs.backport.java.util.concurrent.locks.Lock.
implementations provide more extensive locking operations than can be obtained using methods and statements.
last() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
 
last() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
 
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 if the map is empty.
lastEntry() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
lastIndexOf(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
 
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
 
lastIndexOfSubList(List, List) - Static method in class edu.emory.mathcs.backport.java.util.Collections
 
lastKey() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
lastKey() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
 
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 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 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 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.
list(Enumeration) - Static method in class edu.emory.mathcs.backport.java.util.Collections
 
listIterator() - Method in class edu.emory.mathcs.backport.java.util.LinkedList
 
listIterator(int) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
 
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
 
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 interface edu.emory.mathcs.backport.java.util.NavigableSet
Returns the greatest element in this set strictly less than the given element, or if there is no such element.
lower(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeSet
 
lower(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet
 
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 if there is no such key.
lowerEntry(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
lowerKey(Object) - Method in interface edu.emory.mathcs.backport.java.util.NavigableMap
Returns the greatest key strictly less than the given key, or if there is no such key.
lowerKey(Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
lowerKey(Object) - Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
 

M

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
 
MINUTES - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
 
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
 
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
 

N

NANOSECONDS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
 
NanoTimer - interface edu.emory.mathcs.backport.java.util.concurrent.helpers.NanoTimer.
Interface to specify custom implementation of precise timer.
NavigableMap - interface edu.emory.mathcs.backport.java.util.NavigableMap.
A SortedMap extended with navigation methods returning the closest matches for given search targets.
NavigableSet - interface edu.emory.mathcs.backport.java.util.NavigableSet.
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
 
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.
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.
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
 
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
 
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 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 because 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 .

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

PriorityBlockingQueue - class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue.
An unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies blocking retrieval operations.
PriorityBlockingQueue() - Constructor for class edu.emory.mathcs.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 edu.emory.mathcs.backport.java.util.PriorityQueue.
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.
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 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.
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.
peekFirst() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
 
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
 
peekFirst() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
 
peekLast() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
 
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
 
peekLast() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
 
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 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.
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.
pollFirst() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
 
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 if this set is empty.
pollFirst() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
 
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
 
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 if the map is empty.
pollFirstEntry() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
pollLast() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
 
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 if this set is empty.
pollLast() - Method in class edu.emory.mathcs.backport.java.util.TreeSet
 
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
 
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 if the map is empty.
pollLastEntry() - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
pop() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
Pops an element from the stack represented by this deque.
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
 
pop() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
 
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.
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.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
 
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
 
put(Object, Object) - Method in class edu.emory.mathcs.backport.java.util.TreeMap
 
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.
putAll(Map) - 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.
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. This is equivalent to
   if (!map.containsKey(key))
       return map.put(key, value);
   else
       return map.get(key);
except that the action is performed atomically.
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. This is equivalent to
   if (!map.containsKey(key))
       return map.put(key, value);
   else
       return map.get(key);
except that the action is performed atomically.
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 edu.emory.mathcs.backport.java.util.Queue.
A collection designed for holding elements prior to processing.

R

ReadWriteLock - interface edu.emory.mathcs.backport.java.util.concurrent.locks.ReadWriteLock.
A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing.
ReentrantLock - class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock.
A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor lock accessed using 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(boolean) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock
Creates an instance of with the given fairness policy.
ReentrantReadWriteLock - class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.
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 with default (nonfair) ordering properties.
ReentrantReadWriteLock.ReadLock - class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock.
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 edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.
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
RejectedExecutionException - exception edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException.
Exception thrown by an Executor when a task cannot be accepted for execution.
RejectedExecutionException() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with no detail message.
RejectedExecutionException(String) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with the specified detail message.
RejectedExecutionException(String, Throwable) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with the specified detail message and cause.
RejectedExecutionException(Throwable) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with the specified cause.
RejectedExecutionHandler - interface edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionHandler.
A handler for tasks that cannot be executed by a ThreadPoolExecutor.
RunnableFuture - interface edu.emory.mathcs.backport.java.util.concurrent.RunnableFuture.
A Future that is Runnable.
RunnableScheduledFuture - interface edu.emory.mathcs.backport.java.util.concurrent.RunnableScheduledFuture.
A ScheduledFuture that is Runnable.
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
 
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.
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.
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() - 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
 
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. This is equivalent to
   if (map.containsKey(key) && map.get(key).equals(value)) {
       map.remove(key);
       return true;
   } else return false;
except that the action is performed atomically.
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. This is equivalent to
   if (map.containsKey(key) && map.get(key).equals(value)) {
       map.remove(key);
       return true;
   } else return false;
except that the action is performed atomically.
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.
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 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
 
removeFirst() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
 
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.Deque
Removes the first occurrence of the specified element from this deque.
removeFirstOccurrence(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
 
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
 
removeLast() - Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
 
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
 
removeLast() - Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
 
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.Deque
Removes the last occurrence of the specified element from this deque.
removeLastOccurrence(Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
 
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
 
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. This is equivalent to
   if (map.containsKey(key) && map.get(key).equals(oldValue)) {
       map.put(key, newValue);
       return true;
   } else return false;
except that the action is performed atomically.
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. This is equivalent to
   if (map.containsKey(key)) {
       return map.put(key, value);
   } else return null;
except that the action is performed atomically.
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. This is equivalent to
   if (map.containsKey(key) && map.get(key).equals(oldValue)) {
       map.put(key, newValue);
       return true;
   } else return false;
except that the action is performed atomically.
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. This is equivalent to
   if (map.containsKey(key)) {
       return map.put(key, value);
   } else return null;
except that the action is performed atomically.
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.

S

SECONDS - Static variable in class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit
 
ScheduledExecutorService - interface edu.emory.mathcs.backport.java.util.concurrent.ScheduledExecutorService.
An ExecutorService that can schedule commands to run after a given delay, or to execute periodically.
ScheduledFuture - interface edu.emory.mathcs.backport.java.util.concurrent.ScheduledFuture.
A delayed result-bearing action that can be cancelled.
ScheduledThreadPoolExecutor - class edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor.
A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically.
ScheduledThreadPoolExecutor(int) - Constructor for class edu.emory.mathcs.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.
Semaphore - class edu.emory.mathcs.backport.java.util.concurrent.Semaphore.
A counting semaphore.
Semaphore(int) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.Semaphore
Creates a 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 with the given number of permits and the given fairness setting.
SynchronousQueue - class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue.
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.
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
 
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
 
set(int, Object) - Method in class edu.emory.mathcs.backport.java.util.LinkedList
 
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(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 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 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 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.
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.
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 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
 
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.
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.NavigableMap
Returns a view of the portion of this map whose keys range from to .
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
 
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
 
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 to .
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
 
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
 
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
 
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
 

T

ThreadFactory - interface edu.emory.mathcs.backport.java.util.concurrent.ThreadFactory.
An object that creates new threads on demand.
ThreadHelpers - class edu.emory.mathcs.backport.java.util.concurrent.helpers.ThreadHelpers.
Emulation of some new functionality present in java.lang.Thread in J2SE 5.0.
ThreadHelpers.UncaughtExceptionHandler - interface edu.emory.mathcs.backport.java.util.concurrent.helpers.ThreadHelpers.UncaughtExceptionHandler.
Abstraction of the exception handler which receives notifications of exceptions occurred possibly in various parts of the system.
ThreadPoolExecutor - class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.
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 edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.AbortPolicy.
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 edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy.
A handler for rejected tasks that runs the rejected task directly in the calling thread of the execute method, unless the executor has been shut down, in which case the task is discarded.
ThreadPoolExecutor.CallerRunsPolicy() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
Creates a CallerRunsPolicy.
ThreadPoolExecutor.DiscardOldestPolicy - class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy.
A handler for rejected tasks that discards the oldest unhandled request and then retries execute, unless the executor is shut down, in which case the task is discarded.
ThreadPoolExecutor.DiscardOldestPolicy() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy
Creates a DiscardOldestPolicy for the given executor.
ThreadPoolExecutor.DiscardPolicy - class edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor.DiscardPolicy.
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.
TimeUnit - class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit.
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to convert across units, and to perform timing and delay operations in these units.
TimeoutException - exception edu.emory.mathcs.backport.java.util.concurrent.TimeoutException.
Exception thrown when a blocking operation times out.
TimeoutException() - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.TimeoutException
Constructs a TimeoutException with no specified detail message.
TimeoutException(String) - Constructor for class edu.emory.mathcs.backport.java.util.concurrent.TimeoutException
Constructs a TimeoutException with the specified detail message.
TreeMap - class edu.emory.mathcs.backport.java.util.TreeMap.
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 edu.emory.mathcs.backport.java.util.TreeMap.Entry.
 
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 edu.emory.mathcs.backport.java.util.TreeSet.
 
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
 
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 is true) .
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
 
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
 
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 is true) .
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
 
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
 
tail_ - Variable in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
 
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.
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.
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.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
 
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.
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.TreeMap.Entry
 
toString() - Method in class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue
 
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.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.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.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.WriteLock
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.
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

Utils - class edu.emory.mathcs.backport.java.util.concurrent.helpers.Utils.
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.
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
 

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 edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue.
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 edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue.QueuedSync.
 
WaitQueue.WaitNode - class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue.WaitNode.
 
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 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 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