Index

Overview

Package

Class

Use

Deprecated

Index

Home >> All >> edu >> emory >> mathcs >> util >> [ concurrent overview ]

PREV NEXT

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

A

AlarmClock - class edu.emory.mathcs.util.concurrent.AlarmClock.: This class provide some value-added over java.util.Timer: that is, it enables rescheduling of previously scheduled tasks.
AlarmClock(Timer, Runnable) - Constructor for class edu.emory.mathcs.util.concurrent.AlarmClock
AsyncTask - class edu.emory.mathcs.util.concurrent.AsyncTask.: A class maintaining a single reference variable serving as the result of an operation.
AsyncTask() - Constructor for class edu.emory.mathcs.util.concurrent.AsyncTask
AsyncTask(Callback) - Constructor for class edu.emory.mathcs.util.concurrent.AsyncTask
abortWhenBlocked() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Set the policy for blocked execution to be to throw a RuntimeException.
acc - Variable in class edu.emory.mathcs.util.concurrent.DelegatedRunnable
acc - Variable in class edu.emory.mathcs.util.concurrent.PlainThreadFactory
addThread(Runnable) - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Create and start a thread to handle a new command.
allowTake() - Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue: Notify a waiting take if needed
appendContextStackTrace(Throwable, Throwable) - Static method in class edu.emory.mathcs.util.concurrent.AsyncTask
asyncDestroyThreadGroup(ThreadGroup, Callback) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
asyncDestroyThreadGroup(ThreadGroup, Callback, ThreadDeath) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
asyncDestroyThreadGroup(ThreadGroup, boolean, Callback, ThreadDeath) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
asyncDestroyThreadGroup(ThreadGroup, Thread[], Callback, ThreadDeath) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
asyncResumeThreadGroup(ThreadGroup, Thread[], Callback) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
asyncStopThreadGroup(ThreadGroup, Callback) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
asyncStopThreadGroup(ThreadGroup, boolean, Callback, ThreadDeath) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
asyncStopThreadGroup(ThreadGroup, Thread[], Callback, ThreadDeath) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
asyncSuspendThreadGroup(ThreadGroup, boolean, Callback) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
asyncSuspendThreadGroup(ThreadGroup, Thread[], Callback) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
await() - Method in class edu.emory.mathcs.util.concurrent.CountDownLatch: Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted 55 .
await(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.CountDownLatch: Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted 55 , or the specified waiting time elapses.
awaitTermination(long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService: Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.
awaitTerminationAfterShutdown(long) - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Wait for a shutdown pool to fully terminate, or until the timeout has expired.
awaitTerminationAfterShutdown() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Wait for a shutdown pool to fully terminate.

B

BlockingQueue - interface edu.emory.mathcs.util.concurrent.BlockingQueue.: A java.util.Queue that additionally supports operations that wait for elements to exist when retrieving them, and wait for space to exist when putting them.
BoundedLinkedQueue - class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue.: A bounded variant of LinkedQueue class.
BoundedLinkedQueue(int) - Constructor for class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue: Create a queue with the given capacity
BoundedLinkedQueue() - Constructor for class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue: Create a queue with the current default capacity
beg - Variable in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
blockedAction(Runnable) - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor.AbortWhenBlocked
blockedAction(Runnable) - Method in interface edu.emory.mathcs.util.concurrent.PooledExecutor.BlockedExecutionHandler: Return true if successfully handled so, execute should terminate; else return false if execute loop should be retried.
blockedAction(Runnable) - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor.DiscardOldestWhenBlocked
blockedAction(Runnable) - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor.DiscardWhenBlocked
blockedAction(Runnable) - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor.RunWhenBlocked
blockedAction(Runnable) - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor.WaitWhenBlocked
blockedExecutionHandler_ - Variable in class edu.emory.mathcs.util.concurrent.PooledExecutor: The current handler for unserviceable requests.
buf - Variable in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue

C

CANCELLED - Static variable in class edu.emory.mathcs.util.concurrent.SynchronousQueue: Special marker used in queue nodes to indicate that the thread waiting for a change in the node has timed out or been interrupted.
Callable - interface edu.emory.mathcs.util.concurrent.Callable.: A task that returns a result and may throw an exception.
Callback - interface edu.emory.mathcs.util.concurrent.Callback.: Abstraction of a callback, to be invoked by a middleware upon completion of some asynchronously scheduled action.
Cancellable - interface edu.emory.mathcs.util.concurrent.Cancellable.: Something, usually a task, that can be cancelled.
CancellationException - exception edu.emory.mathcs.util.concurrent.CancellationException.: Indicates that the result of a value-producing task, such as a FutureTask, cannot be retrieved because the task was cancelled.
CancellationException() - Constructor for class edu.emory.mathcs.util.concurrent.CancellationException: Constructs a CancellationException with no detail message.
CancellationException(String) - Constructor for class edu.emory.mathcs.util.concurrent.CancellationException: Constructs a CancellationException with the specified detail message.
CompletedFuture - class edu.emory.mathcs.util.concurrent.CompletedFuture.: Trivial implementation of Future that is always completed.
CompletedFuture(Object, Throwable) - Constructor for class edu.emory.mathcs.util.concurrent.CompletedFuture
CountDownLatch - class edu.emory.mathcs.util.concurrent.CountDownLatch.: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
CountDownLatch(int) - Constructor for class edu.emory.mathcs.util.concurrent.CountDownLatch: Constructs a CountDownLatch initialized with the given count.
call() - Method in interface edu.emory.mathcs.util.concurrent.Callable: Computes a result, or throws an exception if unable to do so.
call() - Method in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
callback - Variable in class edu.emory.mathcs.util.concurrent.AsyncTask: Optional callback to invoke when task completes
cancel() - Method in class edu.emory.mathcs.util.concurrent.AlarmClock: Cancel the scheduled task.
cancel(boolean) - Method in class edu.emory.mathcs.util.concurrent.AsyncTask
cancel(boolean) - Method in interface edu.emory.mathcs.util.concurrent.Cancellable: Attempt to cancel execution of this task.
cancel(boolean) - Method in class edu.emory.mathcs.util.concurrent.CompletedFuture: Always returns false.
cancellationException - Variable in class edu.emory.mathcs.util.concurrent.AsyncTask
cancellationHandler - Variable in class edu.emory.mathcs.util.concurrent.AsyncTask: Wrapper for the thread in which async task is executed, or the task itself if it implements Cancellable.
capacity() - Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue: Return the current capacity of this queue
capacity() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
capacity_ - Variable in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue: Number of elements allowed
cause - Variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
ccl - Variable in class edu.emory.mathcs.util.concurrent.ThreadContext
childValue(Object) - Method in class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal.ThreadLocalMap
completed - Variable in class edu.emory.mathcs.util.concurrent.AsyncTask: completion status
completed(Object) - Method in interface edu.emory.mathcs.util.concurrent.Callback: Called when action completed successfully.
completed(Object) - Static method in class edu.emory.mathcs.util.concurrent.CompletedFuture: Creates a successfully completed future with specified result.
completed(Object, Callback) - Static method in class edu.emory.mathcs.util.concurrent.CompletedFuture: Creates a successfully completed future with specified result and completion callback.
convert(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit: Convert the given time duration in the given unit to the current unit.
count - Variable in class edu.emory.mathcs.util.concurrent.CountDownLatch
countDown() - Method in class edu.emory.mathcs.util.concurrent.CountDownLatch: Decrements the count of the latch, releasing all waiting threads if the count reaches zero.
createCancellationHandler(Callable) - Method in class edu.emory.mathcs.util.concurrent.AsyncTask: Overridable cancellation policy that governs what should be done upon cancellation of tasks that have already started running.
createPerformer(Callable, boolean) - Method in class edu.emory.mathcs.util.concurrent.AsyncTask: Creates a runnable that will execute specified call and then mark this AsyncTask with the result of that call.
createPerformer(Callable, boolean) - Method in class edu.emory.mathcs.util.concurrent.SecureAsyncTask: Creates a runnable that will execute specified call and then mark this AsyncTask with the result of that call.
createThreads(int) - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Create and start up to numberOfThreads threads in the pool.

D

DEFAULT_KEEPALIVETIME - Static variable in class edu.emory.mathcs.util.concurrent.PooledExecutor: The maximum time to keep worker threads alive waiting for new tasks; used if not otherwise specified.
DEFAULT_MAXIMUMPOOLSIZE - Static variable in class edu.emory.mathcs.util.concurrent.PooledExecutor: The maximum pool size; used if not otherwise specified.
DEFAULT_MINIMUMPOOLSIZE - Static variable in class edu.emory.mathcs.util.concurrent.PooledExecutor: The minimum pool size; used if not otherwise specified.
DESTROY - Static variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
DefaultChannelCapacity - class edu.emory.mathcs.util.concurrent.DefaultChannelCapacity.: A utility class to set the default capacity of BoundedChannel implementations that otherwise require a capacity argument
DefaultChannelCapacity() - Constructor for class edu.emory.mathcs.util.concurrent.DefaultChannelCapacity
DelegatableThreadLocal - class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal.: Version of a java.lang.InheritableThreadLocal that can be propagated to worker threads by means of ThreadContext.
DelegatableThreadLocal() - Constructor for class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal: Creates a new instance of DelegatableThreadLocal
DelegatableThreadLocal.ThreadLocalMap - class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal.ThreadLocalMap.
DelegatableThreadLocal.ThreadLocalMap() - Constructor for class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal.ThreadLocalMap
DelegatedRunnable - class edu.emory.mathcs.util.concurrent.DelegatedRunnable.: Wrapper for a runnable that ensures that further executions (even if performed by different threads) inherit current access control context and ThreadContext.
DelegatedRunnable(Runnable) - Constructor for class edu.emory.mathcs.util.concurrent.DelegatedRunnable: Construct new DelegatedRunnable wrapper for a given task.
DynamicArrayBlockingQueue - class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue.: This class represents queue of objects.
DynamicArrayBlockingQueue() - Constructor for class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue: Creates new queue object with initial capacity of 16 and unlimited maximum capacity.
DynamicArrayBlockingQueue(int) - Constructor for class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue: Creates new queue object with specified initial capacity and unlimited maximum capacity.
DynamicArrayBlockingQueue(int, int) - Constructor for class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue: Creates new queue object with specified initial capacity and specified maximum capacity.
decreasePending() - Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor
defaultCapacity_ - Static variable in class edu.emory.mathcs.util.concurrent.DefaultChannelCapacity: the current default capacity
delegThreadLocals - Variable in class edu.emory.mathcs.util.concurrent.ThreadContext
deq() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue.Queue
destroyThreadGroup(ThreadGroup, long) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
destroyThreadGroup(ThreadGroup, long, ThreadDeath) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
destroyThreadGroup(ThreadGroup, long, boolean, ThreadDeath) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
destroyThreadGroup(ThreadGroup, long, Thread[], ThreadDeath) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
discardOldestWhenBlocked() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Set the policy for blocked execution to be to discard the oldest unhandled request
discardWhenBlocked() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Set the policy for blocked execution to be to return without executing the request.
doOp(int, ThreadGroup, Thread[], ThreadDeath, Callback) - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
done - Variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
drain() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Remove all unprocessed tasks from pool queue, and return them in a java.util.List.

E

ENDTASK - Static variable in class edu.emory.mathcs.util.concurrent.QueuedExecutor: Special queue element to signal termination
ExecutionException - exception edu.emory.mathcs.util.concurrent.ExecutionException.: Exception thrown when attempting to retrieve the result of a task that aborted.
ExecutionException() - Constructor for class edu.emory.mathcs.util.concurrent.ExecutionException: Constructs a ExecutionException with no detail message.
ExecutionException(String) - Constructor for class edu.emory.mathcs.util.concurrent.ExecutionException: Constructs a ExecutionException with the specified detail message.
ExecutionException(String, Throwable) - Constructor for class edu.emory.mathcs.util.concurrent.ExecutionException: Constructs a ExecutionException with the specified detail message and cause.
ExecutionException(Throwable) - Constructor for class edu.emory.mathcs.util.concurrent.ExecutionException: Constructs a ExecutionException with the specified cause.
Executor - interface edu.emory.mathcs.util.concurrent.Executor.: An object that executes submitted tasks.
ExecutorService - interface edu.emory.mathcs.util.concurrent.ExecutorService.: An executor that provides methods to manage termination.
edu.emory.mathcs.util.concurrent - package edu.emory.mathcs.util.concurrent
end - Variable in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
engine - Variable in class edu.emory.mathcs.util.concurrent.AlarmClock
enlargeForPut() - Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
enlargeForPutAtHead() - Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
enq(LinkedNode) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue.Queue
exception - Variable in class edu.emory.mathcs.util.concurrent.CompletedFuture
excessNanos(long, long) - Method in class edu.emory.mathcs.util.concurrent.TimeUnit: Utility method to compute the excess-nanosecond argument to wait, sleep, join.
exclude - Variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
exec() - Method in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
execTGOperation(ThreadGroup, Thread[], int) - Method in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
execute(Runnable) - Method in interface edu.emory.mathcs.util.concurrent.Executor: Executes the given command at some time in the future.
execute(Runnable) - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Arrange for the given command to be executed by a thread in this pool.
execute(Runnable) - Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor: Arrange for execution of the command in the background thread by adding it to the queue.
execute(Runnable) - Method in class edu.emory.mathcs.util.concurrent.SecurePooledExecutor
execute(Runnable) - Method in class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor
extract() - Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue: Main mechanics for take/poll
extract() - Method in class edu.emory.mathcs.util.concurrent.LinkedQueue: Main mechanics for take/poll

F

Future - interface edu.emory.mathcs.util.concurrent.Future.: A Future represents the result of an asynchronous computation.
failed(Throwable) - Method in interface edu.emory.mathcs.util.concurrent.Callback: Called when action failed.
failed(Throwable) - Static method in class edu.emory.mathcs.util.concurrent.CompletedFuture: Creates a failed future with specified failure cause.
failed(Throwable, Callback) - Static method in class edu.emory.mathcs.util.concurrent.CompletedFuture: Creates a failed future with specified failure cause and completion callback.
finalCountdown - Variable in class edu.emory.mathcs.util.concurrent.QueuedExecutor
firstTask_ - Variable in class edu.emory.mathcs.util.concurrent.PooledExecutor.Worker
full() - Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue

G

get() - Method in class edu.emory.mathcs.util.concurrent.AsyncTask
get(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.AsyncTask
get() - Method in class edu.emory.mathcs.util.concurrent.CompletedFuture
get(long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.CompletedFuture
get() - Static method in class edu.emory.mathcs.util.concurrent.DefaultChannelCapacity: Get the default capacity used in default (no-argument) constructor for BoundedChannels that otherwise require a capacity argument.
get() - Method in class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal
get() - Method in interface edu.emory.mathcs.util.concurrent.Future: Waits if necessary for computation to complete, and then retrieves its result.
get(long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.Future: Waits if necessary for at most the given time for the computation to complete, and then retrieves its result.
getBlockedExecutionHandler() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Get the handler for blocked execution
getContext() - Static method in class edu.emory.mathcs.util.concurrent.ThreadContext: Takes the snapshot of the current thread's state.
getCount() - Method in class edu.emory.mathcs.util.concurrent.CountDownLatch: Returns the current count.
getCurrentLocals() - Static method in class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal: Used by ThreadContext.
getKeepAliveTime() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Return the number of milliseconds to keep threads alive waiting for new commands.
getMaximumPoolSize() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Return the maximum number of threads to simultaneously execute New unqueued requests will be handled according to the current blocking policy once this limit is exceeded.
getMinimumPoolSize() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Return the minimum number of threads to simultaneously execute.
getNextIdx() - Method in class edu.emory.mathcs.util.concurrent.PlainThreadFactory
getNextTask() - Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor
getPending() - Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor
getPerformer(Callable) - Method in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner.Result
getPoolSize() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Return the current number of active threads in the pool.
getResult() - Method in class edu.emory.mathcs.util.concurrent.AsyncTask: Gets the result of the task.
getTask() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Get a task from the handoff queue, or null if shutting down.
getThread() - Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor: Return the thread being used to process commands, or null if there is no such thread.
getThreadFactory() - Method in class edu.emory.mathcs.util.concurrent.ThreadFactoryUser: Get the factory for creating new threads.
getTopLevelThreadGroup() - Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils: Returns the root thread group.
group - Variable in class edu.emory.mathcs.util.concurrent.PlainThreadFactory

H

handOff_ - Variable in class edu.emory.mathcs.util.concurrent.PooledExecutor: The channel used to hand off the command to a thread in the pool.
head - Variable in class edu.emory.mathcs.util.concurrent.SynchronousQueue.Queue
head_ - Variable in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue: Dummy header node of list.
head_ - Variable in class edu.emory.mathcs.util.concurrent.LinkedQueue: Dummy header node of list.

I

INITIAL_DEFAULT_CAPACITY - Static variable in class edu.emory.mathcs.util.concurrent.DefaultChannelCapacity: The initial value of the default capacity is 1024
idx - Variable in class edu.emory.mathcs.util.concurrent.PlainThreadFactory
increasePending() - Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor
index - Variable in class edu.emory.mathcs.util.concurrent.TimeUnit: the index of this unit
initialCount - Variable in class edu.emory.mathcs.util.concurrent.CountDownLatch
initialValue() - Method in class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal.ThreadLocalMap
initialValue() - Method in class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal
insert(Object) - Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue: Create and insert a node.
insert(Object) - Method in class edu.emory.mathcs.util.concurrent.LinkedQueue: Main mechanics for put/offer
interruptAll() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Interrupt all threads in the pool, causing them all to terminate.
invokeCallback(Object, Throwable) - Method in class edu.emory.mathcs.util.concurrent.AsyncTask
isCancelled() - Method in class edu.emory.mathcs.util.concurrent.AsyncTask
isCancelled() - Method in interface edu.emory.mathcs.util.concurrent.Cancellable: Returns true if this task was cancelled before it completed normally.
isCancelled() - Method in class edu.emory.mathcs.util.concurrent.CompletedFuture: Always returns false.
isDone() - Method in class edu.emory.mathcs.util.concurrent.AsyncTask: Checks if the task has completed.
isDone() - Method in interface edu.emory.mathcs.util.concurrent.Cancellable: Returns true if this task ran to completion or was cancelled.
isDone() - Method in class edu.emory.mathcs.util.concurrent.CompletedFuture: Always returns true.
isDone() - Method in interface edu.emory.mathcs.util.concurrent.Future: Returns true if the underlying task has completed.
isEmpty() - Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
isEmpty() - Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
isShutdown() - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService: Returns true if this executor has been shut down.
isTerminated() - Method in interface edu.emory.mathcs.util.concurrent.ExecutorService: Returns true if all tasks have completed following shut down.
isTerminatedAfterShutdown() - Method in class edu.emory.mathcs.util.concurrent.PooledExecutor: Return true if a shutDown method has succeeded in terminating all threads.
iterator() - Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
iterator() - Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
iterator() - Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
iterator() - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue

K

keepAliveTime_ - Variable in class edu.emory.mathcs.util.concurrent.PooledExecutor: The maximum time for an idle thread to wait for new task.

L

LinkedNode - class edu.emory.mathcs.util.concurrent.LinkedNode.: A standard linked list node used in various queue classes
LinkedNode() - Constructor for class edu.emory.mathcs.util.concurrent.LinkedNode
LinkedNode(Object) - Constructor for class edu.emory.mathcs.util.concurrent.LinkedNode
LinkedNode(Object, LinkedNode) - Constructor for class edu.emory.mathcs.util.concurrent.LinkedNode
LinkedQueue - class edu.emory.mathcs.util.concurrent.LinkedQueue.: A linked list based channel implementation.
LinkedQueue() - Constructor for class edu.emory.mathcs.util.concurrent.LinkedQueue
last - Variable in class edu.emory.mathcs.util.concurrent.SynchronousQueue.Queue
last - Variable in class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor.TaskQueue
last_ - Variable in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue: The last node of list.
last_ - Variable in class edu.emory.mathcs.util.concurrent.LinkedQueue: The last node of list.
length - Variable in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue

M

MICROSECONDS - Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit: Unit for one-microsecond granularities
MILLISECONDS - Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit: Unit for one-millisecond granularities
MS - Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit
maxcap - Variable in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
maximumPoolSize_ - Variable in class edu.emory.mathcs.util.concurrent.PooledExecutor: The maximum number of threads allowed in pool.
minimumPoolSize_ - Variable in class edu.emory.mathcs.util.concurrent.PooledExecutor: The minumum number of threads to maintain in pool.
multipliers - Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit: quick lookup table for conversion factors

N

NANOSECONDS - Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit: Unit for one-nanosecond granularities
NO_ITERATOR - Static variable in class edu.emory.mathcs.util.concurrent.SynchronousQueue
NS - Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit
name - Variable in class edu.emory.mathcs.util.concurrent.PlainThreadFactory
newThread(Runnable) - Method in class edu.emory.mathcs.util.concurrent.PlainThreadFactory
newThread(Runnable) - Method in interface edu.emory.mathcs.util.concurrent.ThreadFactory: Create a new thread that will run the given command when started
next - Variable in class edu.emory.mathcs.util.concurrent.LinkedNode
next - Variable in class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor.TaskQueue.Node

O

offer(Object, long, TimeUnit) - Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue: Add the given object to the queue, waiting if necessary up to a specified wait time for space to become available.
offer(Object) - Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
offer(Object) - Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue: Puts specified object at the bottom of the queue, if possible.
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue: Puts specified object at the bottom of the queue with specified timeout and returns true if operation succeeded, false otherwise.
offer(Object) - Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
offer(Object) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
offer(Object, long, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
offerAtHead(Object) - Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue: Inserts specified object at the top of the queue, so the next call to get() would return this object.
offerAtHead(Object, int, TimeUnit) - Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue: Inserts specified object at the top of the queue, so the next call to get() would return this object, with specified timeout and returns true if operation succeeded, false otherwise.
op - Variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner




P

PlainThreadFactory - class edu.emory.mathcs.util.concurrent.PlainThreadFactory.
Thread factory implementation that attempts to ensure that created threads
 are equivalent regardless of threads that request creation.
PlainThreadFactory() - 
Constructor for class edu.emory.mathcs.util.concurrent.PlainThreadFactory
Creates a new tread factory that creates threads within a default
 thread group.
PlainThreadFactory(String) - 
Constructor for class edu.emory.mathcs.util.concurrent.PlainThreadFactory
Creates a new tread factory that uses default thread group and
 specified thread name prefix.
PlainThreadFactory(ThreadGroup) - 
Constructor for class edu.emory.mathcs.util.concurrent.PlainThreadFactory
Creates a new tread factory that creates threads within the specified
 thread group.
PlainThreadFactory(ThreadGroup, String) - 
Constructor for class edu.emory.mathcs.util.concurrent.PlainThreadFactory
Creates a new tread factory that creates threads within the specified
 thread group, and uses specified thread name prefix.
PooledExecutor - class edu.emory.mathcs.util.concurrent.PooledExecutor.
A tunable, extensible thread pool class.
PooledExecutor() - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor
Create a new pool with all default settings
PooledExecutor(int) - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor
Create a new pool with all default settings except
 for maximum pool size.
PooledExecutor(BlockingQueue) - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor
Create a new pool that uses the supplied Queue for queuing, and
 with all default parameter settings.
PooledExecutor(BlockingQueue, int) - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor
Create a new pool that uses the supplied Queue for queuing, and
 with all default parameter settings except for maximum pool size.
PooledExecutor.AbortWhenBlocked - class edu.emory.mathcs.util.concurrent.PooledExecutor.AbortWhenBlocked.
Class defining Abort action.
PooledExecutor.AbortWhenBlocked() - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor.AbortWhenBlocked
 
PooledExecutor.BlockedExecutionHandler - interface edu.emory.mathcs.util.concurrent.PooledExecutor.BlockedExecutionHandler.
Class for actions to take when execute() blocks.
PooledExecutor.DiscardOldestWhenBlocked - class edu.emory.mathcs.util.concurrent.PooledExecutor.DiscardOldestWhenBlocked.
Class defining DiscardOldest action.
PooledExecutor.DiscardOldestWhenBlocked() - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor.DiscardOldestWhenBlocked
 
PooledExecutor.DiscardWhenBlocked - class edu.emory.mathcs.util.concurrent.PooledExecutor.DiscardWhenBlocked.
Class defining Discard action.
PooledExecutor.DiscardWhenBlocked() - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor.DiscardWhenBlocked
 
PooledExecutor.RunWhenBlocked - class edu.emory.mathcs.util.concurrent.PooledExecutor.RunWhenBlocked.
Class defining Run action.
PooledExecutor.RunWhenBlocked() - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor.RunWhenBlocked
 
PooledExecutor.WaitWhenBlocked - class edu.emory.mathcs.util.concurrent.PooledExecutor.WaitWhenBlocked.
Class defining Wait action.
PooledExecutor.WaitWhenBlocked() - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor.WaitWhenBlocked
 
PooledExecutor.Worker - class edu.emory.mathcs.util.concurrent.PooledExecutor.Worker.
Class defining the basic run loop for pooled threads.
PooledExecutor.Worker(Runnable) - 
Constructor for class edu.emory.mathcs.util.concurrent.PooledExecutor.Worker
 
peek() - 
Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
 
peek() - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
 
peek() - 
Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
 
peek() - 
Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
peek0() - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
 
pending - 
Variable in class edu.emory.mathcs.util.concurrent.QueuedExecutor
 
perform(Runnable) - 
Method in class edu.emory.mathcs.util.concurrent.ThreadContext
Temporarily recovers current thread's state from this snapshot and then
 executes the specified task.
perform(Callable) - 
Method in class edu.emory.mathcs.util.concurrent.ThreadContext
Temporarily recovers current thread's state from this snapshot and then
 executes the specified call.
perform(PrivilegedAction) - 
Method in class edu.emory.mathcs.util.concurrent.ThreadContext
Temporarily recovers current thread's state from this snapshot and then
 performs the specified action.
perform(PrivilegedExceptionAction) - 
Method in class edu.emory.mathcs.util.concurrent.ThreadContext
Temporarily recovers current thread's state from this snapshot and then
 performs the specified action.
poll(long, TimeUnit) - 
Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Retrieve and remove the first element from the queue, waiting
 if necessary up to a specified wait time if no objects are
 present on the queue.
poll() - 
Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
 
poll(long, TimeUnit) - 
Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
 
poll(long, TimeUnit) - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
Gets the object from the top of the queue.
poll() - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
Remove and return an element from the queue if one is available.
poll() - 
Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
 
poll(long, TimeUnit) - 
Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
 
poll() - 
Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
poll(long, TimeUnit) - 
Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
pool - 
Variable in class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor
 
poolSize_ - 
Variable in class edu.emory.mathcs.util.concurrent.PooledExecutor
Current pool size.
priority - 
Variable in class edu.emory.mathcs.util.concurrent.ThreadContext
 
prvTGroup - 
Static variable in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
put(Object) - 
Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Add the given object to the queue, waiting if necessary for
 space to become available.
put(Object) - 
Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
 
put(Object) - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
 
put(Object) - 
Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
 
put(Object) - 
Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
put(Runnable) - 
Method in class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor.TaskQueue
 
put0(Object) - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
 
putAtHead(Object) - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
Inserts specified object at the top of the queue, so the next call
 to poll() or take() would return this object.
putAtHead0(Object) - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
 
putGuard_ - 
Variable in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
Helper monitor.
putLock_ - 
Variable in class edu.emory.mathcs.util.concurrent.LinkedQueue
Helper monitor for managing access to last node.
putSidePutPermits_ - 
Variable in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
One side of a split permit count.



Q

QueuedExecutor - class edu.emory.mathcs.util.concurrent.QueuedExecutor.
An implementation of Executor that queues incoming
 requests until they can be processed by a single background
 thread.
QueuedExecutor(BlockingQueue, long) - 
Constructor for class edu.emory.mathcs.util.concurrent.QueuedExecutor
Construct a new QueuedExecutor that uses
 the supplied Channel as its queue, and with specified timeout
 
QueuedExecutor(BlockingQueue) - 
Constructor for class edu.emory.mathcs.util.concurrent.QueuedExecutor
Construct a new QueuedExecutor that uses
 the supplied Channel as its queue.
QueuedExecutor(long) - 
Constructor for class edu.emory.mathcs.util.concurrent.QueuedExecutor
Construct a new QueuedExecutor that uses
 a BoundedLinkedQueue with the current
 DefaultChannelCapacity as its queue, and with specified timeout
QueuedExecutor() - 
Constructor for class edu.emory.mathcs.util.concurrent.QueuedExecutor
Construct a new QueuedExecutor that uses
 a BoundedLinkedQueue with the current
 DefaultChannelCapacity as its queue.
QueuedExecutor.RunLoop - class edu.emory.mathcs.util.concurrent.QueuedExecutor.RunLoop.
The runloop is isolated in its own Runnable class
 just so that the main
 class need not implement Runnable,  which would
 allow others to directly invoke run, which would
 never make sense here.
QueuedExecutor.RunLoop() - 
Constructor for class edu.emory.mathcs.util.concurrent.QueuedExecutor.RunLoop
 
queue - 
Variable in class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor
 
queue_ - 
Variable in class edu.emory.mathcs.util.concurrent.QueuedExecutor
The queue



R

RESUME - 
Static variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
 
RejectedExecutionException - exception edu.emory.mathcs.util.concurrent.RejectedExecutionException.
Thrown by an Executor when a task cannot be accepted for execution.
RejectedExecutionException() - 
Constructor for class edu.emory.mathcs.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with no detail message.
RejectedExecutionException(String) - 
Constructor for class edu.emory.mathcs.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with the
 specified detail message.
RejectedExecutionException(String, Throwable) - 
Constructor for class edu.emory.mathcs.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with the
 specified detail message and cause.
RejectedExecutionException(Throwable) - 
Constructor for class edu.emory.mathcs.util.concurrent.RejectedExecutionException
Constructs a RejectedExecutionException with the
 specified cause.
reconcilePutPermits() - 
Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
Move put permits from take side to put side;
 return the number of put side permits that are available.
remainingCapacity() - 
Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Return the number of elements that this queue can ideally (in
 the absence of memory or resource constraints) accept without
 blocking, or Integer.MAX_VALUE if there is no
 intrinsic limit.
remainingCapacity() - 
Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
 
remainingCapacity() - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
 
remainingCapacity() - 
Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
result - 
Variable in class edu.emory.mathcs.util.concurrent.AsyncTask
result of a task
result - 
Variable in class edu.emory.mathcs.util.concurrent.CompletedFuture
 
result - 
Variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
 
resultException - 
Variable in class edu.emory.mathcs.util.concurrent.AsyncTask
exception object in case task completed abruptly
resumeThread(Thread) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
resumeThreadGroup(ThreadGroup, long, Thread[]) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
resumeThreadMethod - 
Static variable in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
run() - 
Method in class edu.emory.mathcs.util.concurrent.DelegatedRunnable
Execute wrapped runnable within access control
 context and ThreadContext associated to this object at
 the creation time.
run() - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor.Worker
 
run() - 
Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor.RunLoop
 
run() - 
Method in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
 
runLoop_ - 
Variable in class edu.emory.mathcs.util.concurrent.QueuedExecutor
 
runWhenBlocked() - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Set the policy for blocked execution to be that the current
 thread executes the command if there are no available threads in
 the pool.
runnable - 
Variable in class edu.emory.mathcs.util.concurrent.DelegatedRunnable
 
runnable - 
Variable in class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor.TaskQueue.Node
 



S

S - 
Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit
 
SECONDS - 
Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit
Unit for one-second granularities
STOP - 
Static variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
 
SUSPEND - 
Static variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
 
SecureAsyncTask - class edu.emory.mathcs.util.concurrent.SecureAsyncTask.
Variant of AsyncTask that overrides method
 createPerformer 55  so that
 it always runs with a fixed access control context and
 thread context inherited from the caller of
 createPerformer method.
SecureAsyncTask() - 
Constructor for class edu.emory.mathcs.util.concurrent.SecureAsyncTask
 
SecureAsyncTask(Callback) - 
Constructor for class edu.emory.mathcs.util.concurrent.SecureAsyncTask
 
SecurePooledExecutor - class edu.emory.mathcs.util.concurrent.SecurePooledExecutor.
Version of PooledExecutor that ensures propagation of access control context
 and thread context from call initiator to the thread
 executing the call.
SecurePooledExecutor() - 
Constructor for class edu.emory.mathcs.util.concurrent.SecurePooledExecutor
Create a new pool with all default settings.
SecurePooledExecutor(int) - 
Constructor for class edu.emory.mathcs.util.concurrent.SecurePooledExecutor
Create a new pool with all default settings except
 for maximum pool size.
SecurePooledExecutor(BlockingQueue) - 
Constructor for class edu.emory.mathcs.util.concurrent.SecurePooledExecutor
Create a new pool that uses the supplied Queue for queuing, and
 with all default parameter settings.
SecurePooledExecutor(BlockingQueue, int) - 
Constructor for class edu.emory.mathcs.util.concurrent.SecurePooledExecutor
Create a new pool that uses the supplied Queue for queuing, and
 with all default parameter settings except for maximum pool size.
SynchronousQueue - class edu.emory.mathcs.util.concurrent.SynchronousQueue.
A rendezvous channel, similar to those used in CSP and Ada.
SynchronousQueue() - 
Constructor for class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
SynchronousQueue.Queue - class edu.emory.mathcs.util.concurrent.SynchronousQueue.Queue.
Simple FIFO queue class to hold waiting puts/takes.
SynchronousQueue.Queue() - 
Constructor for class edu.emory.mathcs.util.concurrent.SynchronousQueue.Queue
 
set(int) - 
Static method in class edu.emory.mathcs.util.concurrent.DefaultChannelCapacity
Set the default capacity used in
 default (no-argument) constructor for BoundedChannels
 that otherwise require a capacity argument.
set(Object) - 
Method in class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal
 
setAlarmDelay(long) - 
Method in class edu.emory.mathcs.util.concurrent.AlarmClock
Reschedule previously scheduled task.
setAlarmDelayIfSooner(long) - 
Method in class edu.emory.mathcs.util.concurrent.AlarmClock
Reschedule previously scheduled task unless it would postpone it.
setBlockedExecutionHandler(PooledExecutor.BlockedExecutionHandler) - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Set the handler for blocked execution
setCapacity(int) - 
Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
Reset the capacity of this queue.
setCompleted(Object) - 
Method in class edu.emory.mathcs.util.concurrent.AsyncTask
Marks the task as completed.
setCurrentLocals(Map) - 
Static method in class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal
Used by ThreadContext.
setFailed(Throwable) - 
Method in class edu.emory.mathcs.util.concurrent.AsyncTask
Marks the task as failed.
setFailed(Throwable) - 
Method in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner.Result
 
setKeepAliveTime(long) - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Set the number of milliseconds to keep threads alive waiting for
 new commands.
setMaximumPoolSize(int) - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Set the maximum number of threads to use.
setMinimumPoolSize(int) - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Set the minimum number of threads to use.
setThreadFactory(ThreadFactory) - 
Method in class edu.emory.mathcs.util.concurrent.SecurePooledExecutor
This method is disabled to prevent circumventing the context delegation
 performed by thie executor.
setThreadFactory(ThreadFactory) - 
Method in class edu.emory.mathcs.util.concurrent.ThreadFactoryUser
Set the factory for creating new threads.
shutdown() - 
Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Initiates an orderly shutdown in which previously submitted tasks
 are executed, but no new tasks will be accepted.
shutdownAfterProcessingCurrentTask() - 
Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor
Terminate background thread after it processes the
 current task, removing other queued tasks and leaving them unprocessed.
shutdownAfterProcessingCurrentlyQueuedTasks() - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Terminate threads after processing all elements currently in
 queue.
shutdownAfterProcessingCurrentlyQueuedTasks(PooledExecutor.BlockedExecutionHandler) - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Terminate threads after processing all elements currently in
 queue.
shutdownAfterProcessingCurrentlyQueuedTasks() - 
Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor
Terminate background thread after it processes all
 elements currently in queue.
shutdownNow() - 
Method in interface edu.emory.mathcs.util.concurrent.ExecutorService
Attempts to stop all actively executing tasks, halts the
 processing of waiting tasks, and returns a list of the tasks that were
 awaiting execution.
shutdownNow() - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Interrupt all threads and disable construction of new
 threads.
shutdownNow(PooledExecutor.BlockedExecutionHandler) - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Interrupt all threads and disable construction of new
 threads.
shutdownNow() - 
Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor
Terminate background thread even if it is currently processing
 a task.
shutdown_ - 
Variable in class edu.emory.mathcs.util.concurrent.PooledExecutor
Shutdown flag - latches true when a shutdown method is called
 in order to disable queuing/handoffs of new tasks.
shutdown_ - 
Variable in class edu.emory.mathcs.util.concurrent.QueuedExecutor
true if thread should shut down after processing current task
size() - 
Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
Return the number of elements in the queue.
size() - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
Returns the number of items in this queue.
size() - 
Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
 
size() - 
Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
sleep(long) - 
Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Perform a Thread.sleep using the current time unit.
start(Executor, Callable) - 
Static method in class edu.emory.mathcs.util.concurrent.AsyncTask
Schedules specified task with given executor, and returns
 completion handle that can be used to access the result or to cancel
 the task.
start(Executor, Callable, Callback) - 
Static method in class edu.emory.mathcs.util.concurrent.AsyncTask
Schedules specified task with given executor, and returns
 completion handle that can be used to access the result or to cancel
 the task.
start(Executor, Callable, Callback, boolean) - 
Static method in class edu.emory.mathcs.util.concurrent.AsyncTask
Schedules specified task with given executor, and returns
 completion handle that can be used to access the result or to cancel
 the task.
start(Executor, Callable) - 
Static method in class edu.emory.mathcs.util.concurrent.SecureAsyncTask
Schedules specified task with given executor, and returns
 completion handle that can be used to access the result or to cancel
 the task.
start(Executor, Callable, Callback) - 
Static method in class edu.emory.mathcs.util.concurrent.SecureAsyncTask
Schedules specified task with given executor, and returns
 completion handle that can be used to access the result or to cancel
 the task.
start(Executor, Callable, Callback, boolean) - 
Static method in class edu.emory.mathcs.util.concurrent.SecureAsyncTask
Schedules specified task with given executor, and returns
 completion handle that can be used to access the result or to cancel
 the task.
stop() - 
Method in class edu.emory.mathcs.util.concurrent.QueuedExecutor
Called from within the run loop when the processing thread is about to
 exit.
stopThread(Thread) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
Stops specified thread.
stopThread(Thread, ThreadDeath) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
Stops specified thread with specified cause.
stopThread(Thread, long, ThreadDeath) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
Stops specified thread with specified timeout and cause.
stopThreadGroup(ThreadGroup, long) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
stopThreadGroup(ThreadGroup, long, boolean, ThreadDeath) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
stopThreadGroup(ThreadGroup, long, Thread[], ThreadDeath) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
stopThreadMethod - 
Static variable in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
suspendThread(Thread) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
suspendThreadGroup(ThreadGroup, long, boolean) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
suspendThreadGroup(ThreadGroup, long, Thread[]) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
suspendThreadMethod - 
Static variable in class edu.emory.mathcs.util.concurrent.ThreadUtils
 
sync(Future, long) - 
Static method in class edu.emory.mathcs.util.concurrent.ThreadUtils
 



T

ThreadContext - class edu.emory.mathcs.util.concurrent.ThreadContext.
Represents an immutable snapshot of a thread state.
ThreadContext(ClassLoader, int, Map) - 
Constructor for class edu.emory.mathcs.util.concurrent.ThreadContext
 
ThreadFactory - interface edu.emory.mathcs.util.concurrent.ThreadFactory.
Interface describing any class that can generate
 new Thread objects.
ThreadFactoryUser - class edu.emory.mathcs.util.concurrent.ThreadFactoryUser.
Base class for Executors and related classes that rely on thread factories.
ThreadFactoryUser() - 
Constructor for class edu.emory.mathcs.util.concurrent.ThreadFactoryUser
 
ThreadSerializingExecutor - class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor.
The executor that delegates to other executor (usually pooling executor) but
 ensures that tasks scheduled from a single thread are executed sequentially.
ThreadSerializingExecutor(Executor) - 
Constructor for class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor
Creates a new thread serializing executor that delegates to the
 specified executor.
ThreadSerializingExecutor.TaskQueue - class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor.TaskQueue.
 
ThreadSerializingExecutor.TaskQueue() - 
Constructor for class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor.TaskQueue
 
ThreadSerializingExecutor.TaskQueue.Node - class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor.TaskQueue.Node.
 
ThreadSerializingExecutor.TaskQueue.Node(Runnable) - 
Constructor for class edu.emory.mathcs.util.concurrent.ThreadSerializingExecutor.TaskQueue.Node
 
ThreadUtils - class edu.emory.mathcs.util.concurrent.ThreadUtils.
Low-level thread access utilities.
ThreadUtils() - 
Constructor for class edu.emory.mathcs.util.concurrent.ThreadUtils
 
ThreadUtils.Executioner - class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner.
 
ThreadUtils.Executioner(ThreadGroup, int, Thread[], ThreadDeath, Callback) - 
Constructor for class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
 
ThreadUtils.Executioner.Result - class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner.Result.
 
ThreadUtils.Executioner.Result(Callback) - 
Constructor for class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner.Result
 
TimeUnit - class edu.emory.mathcs.util.concurrent.TimeUnit.
A TimeUnit represents time durations at a given unit of 
 granularity and provides utility methods to convert across units, 
 and to perform timing and delay operations in these units.
TimeUnit(int) - 
Constructor for class edu.emory.mathcs.util.concurrent.TimeUnit
private constructor
TimeoutException - exception edu.emory.mathcs.util.concurrent.TimeoutException.
Exception thrown when a blocking operation times out.
TimeoutException() - 
Constructor for class edu.emory.mathcs.util.concurrent.TimeoutException
Constructs a TimeoutException with no specified detail
 message.
TimeoutException(String) - 
Constructor for class edu.emory.mathcs.util.concurrent.TimeoutException
Constructs a TimeoutException with the specified detail
 message.
take() - 
Method in interface edu.emory.mathcs.util.concurrent.BlockingQueue
Retrieve and remove the first element from the queue, waiting
 if no objects are present on the queue.
take() - 
Method in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
 
take() - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
Retrieve and remove the first element from the queue, waiting
 if no objects are present on the queue.
take() - 
Method in class edu.emory.mathcs.util.concurrent.LinkedQueue
 
take() - 
Method in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
take0() - 
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
 
takeGuard_ - 
Variable in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
Helper monitor.
takeSidePutPermits_ - 
Variable in class edu.emory.mathcs.util.concurrent.BoundedLinkedQueue
Number of takes since last reconcile
task - 
Variable in class edu.emory.mathcs.util.concurrent.AlarmClock
 
tc - 
Variable in class edu.emory.mathcs.util.concurrent.DelegatedRunnable
 
tc - 
Variable in class edu.emory.mathcs.util.concurrent.PlainThreadFactory
 
tg - 
Variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
 
threadComparator - 
Static variable in class edu.emory.mathcs.util.concurrent.ThreadUtils.Executioner
 
threadFactory_ - 
Variable in class edu.emory.mathcs.util.concurrent.ThreadFactoryUser
 
threadLocalMap - 
Static variable in class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal
 
thread_ - 
Variable in class edu.emory.mathcs.util.concurrent.QueuedExecutor
The thread used to process commands
threads_ - 
Variable in class edu.emory.mathcs.util.concurrent.PooledExecutor
The set of active threads, declared as a map from workers to
 their threads.
timedJoin(Thread, long) - 
Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Perform a timed Thread.join using the current time unit.
timedWait(Object, long) - 
Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Perform a timed Object.wait using the current time unit.
timeout - 
Variable in class edu.emory.mathcs.util.concurrent.QueuedExecutor
how long to wait before stopping runner for empty queue
timerTask - 
Variable in class edu.emory.mathcs.util.concurrent.AlarmClock
 
toNanos(long) - 
Method in class edu.emory.mathcs.util.concurrent.TimeUnit
Equivalent to NANOSECONDS.convert(duration, this).
toString() - 
Method in class edu.emory.mathcs.util.concurrent.CountDownLatch
Returns a string identifying this latch, as well as its state.



U

US - 
Static variable in class edu.emory.mathcs.util.concurrent.TimeUnit
 
UncaughtExceptionHandler - interface edu.emory.mathcs.util.concurrent.UncaughtExceptionHandler.
Abstraction of the exception handler which receives notifications of
 exceptions occurred possibly in various parts of the system.
uncaughtException(Thread, Throwable) - 
Method in interface edu.emory.mathcs.util.concurrent.UncaughtExceptionHandler
Notification of the uncaught exception that occurred within specified
 thread.



V

value - 
Variable in class edu.emory.mathcs.util.concurrent.LinkedNode
 



W

waitFor() - 
Method in class edu.emory.mathcs.util.concurrent.AsyncTask
Waits for the task to complete.
waitFor(long) - 
Method in class edu.emory.mathcs.util.concurrent.AsyncTask
Waits for the task to complete for timeout milliseconds.
waitWhenBlocked() - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Set the policy for blocked execution to be to wait until a thread
 is available.
waitingForTake_ - 
Variable in class edu.emory.mathcs.util.concurrent.LinkedQueue
The number of threads waiting for a take.
waitingPuts - 
Variable in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
waitingTakes - 
Variable in class edu.emory.mathcs.util.concurrent.SynchronousQueue
 
workerDone(PooledExecutor.Worker) - 
Method in class edu.emory.mathcs.util.concurrent.PooledExecutor
Cleanup method called upon termination of worker thread.


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







  
      Overview 
      Package 
      Class 
      Use 
      Deprecated 
    Index 
  









Home >> All >> edu  >> emory  >> mathcs  >> util  >> [ concurrent overview ]

 PREV  NEXT