|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectjava.util.concurrent.AbstractExecutorService
org.apache.cassandra.concurrent.ContinuationsExecutor
public class ContinuationsExecutor
An ExecutorService
that executes each submitted task using one of
possibly several pooled threads, normally configured using Executors
factory methods.
Thread pools address two different problems: they usually provide improved
performance when executing large numbers of asynchronous tasks, due to
reduced per-task invocation overhead, and they provide a means of bounding
and managing the resources, including threads, consumed when executing a
collection of tasks. Each ContinuationsExecutor
also maintains some
basic statistics, such as the number of completed tasks.
To be useful across a wide range of contexts, this class provides many
adjustable parameters and extensibility hooks. However, programmers are urged
to use the more convenient Executors
factory methods Executors.newCachedThreadPool()
(unbounded thread pool, with automatic thread
reclamation), Executors.newFixedThreadPool(int)
(fixed size thread pool)
and Executors.newSingleThreadExecutor()
(single background thread),
that preconfigure settings for the most common usage scenarios. Otherwise,
use the following guide when manually configuring and tuning this class:
ContinuationsExecutor
will automatically adjust the pool size
(see getPoolSize()
) according to the bounds set by corePoolSize (see
getCorePoolSize()
) and maximumPoolSize (see
getMaximumPoolSize()
).
When a new task is submitted in method execute(java.lang.Runnable)
, and fewer than
corePoolSize threads are running, a new thread is created to handle the
request, even if other worker threads are idle. If there are more than
corePoolSize but less than maximumPoolSize threads running, a new thread will
be created only if the queue is full. By setting corePoolSize and
maximumPoolSize the same, you create a fixed-size thread pool. By setting
maximumPoolSize to an essentially unbounded value such as
Integer.MAX_VALUE
, you allow the pool to accommodate an arbitrary
number of concurrent tasks. Most typically, core and maximum pool sizes are
set only upon construction, but they may also be changed dynamically using
setCorePoolSize(int)
and setMaximumPoolSize(int)
. prestartCoreThread()
or prestartAllCoreThreads()
. You probably
want to prestart threads if you construct the pool with a non-empty queue.
ThreadFactory
. If not otherwise
specified, a Executors.defaultThreadFactory()
is used, that creates
threads to all be in the same ThreadGroup
and with the same
NORM_PRIORITY
priority and non-daemon status. By supplying a
different ThreadFactory, you can alter the thread's name, thread group,
priority, daemon status, etc. If a ThreadFactory
fails to create a
thread when asked by returning null from newThread
, the executor
will continue, but might not be able to execute any tasks. Threads should
possess the "modifyThread" RuntimePermission
. If worker threads or
other threads using the pool do not possess this permission, service may be
degraded: configuration changes may not take effect in a timely manner, and a
shutdown pool may remain in a state in which termination is possible but not
completed.getKeepAliveTime(java.util.concurrent.TimeUnit)
). This provides a means of reducing resource
consumption when the pool is not being actively used. If the pool becomes
more active later, new threads will be constructed. This parameter can also
be changed dynamically using method setKeepAliveTime(long, java.util.concurrent.TimeUnit)
. Using a value
of Long.MAX_VALUE
TimeUnit.NANOSECONDS
effectively disables
idle threads from ever terminating prior to shut down. By default, the
keep-alive policy applies only when there are more than corePoolSizeThreads.
But method allowCoreThreadTimeOut(boolean)
can be used to apply this
time-out policy to core threads as well, so long as the keepAliveTime value
is non-zero. BlockingQueue
may be used to transfer and hold submitted
tasks. The use of this queue interacts with pool sizing:
SynchronousQueue
that hands off tasks to threads without otherwise
holding them. Here, an attempt to queue a task will fail if no threads are
immediately available to run it, so a new thread will be constructed. This
policy avoids lockups when handling sets of requests that might have internal
dependencies. Direct handoffs generally require unbounded maximumPoolSizes to
avoid rejection of new submitted tasks. This in turn admits the possibility
of unbounded thread growth when commands continue to arrive on average faster
than they can be processed. LinkedBlockingQueue
without a predefined capacity) will cause new
tasks to wait in the queue when all corePoolSize threads are busy. Thus, no
more than corePoolSize threads will ever be created. (And the value of the
maximumPoolSize therefore doesn't have any effect.) This may be appropriate
when each task is completely independent of others, so tasks cannot affect
each others execution; for example, in a web page server. While this style of
queuing can be useful in smoothing out transient bursts of requests, it
admits the possibility of unbounded work queue growth when commands continue
to arrive on average faster than they can be processed. ArrayBlockingQueue
) helps prevent resource exhaustion when used with
finite maximumPoolSizes, but can be more difficult to tune and control. Queue
sizes and maximum pool sizes may be traded off for each other: Using large
queues and small pools minimizes CPU usage, OS resources, and
context-switching overhead, but can lead to artificially low throughput. If
tasks frequently block (for example if they are I/O bound), a system may be
able to schedule time for more threads than you otherwise allow. Use of small
queues generally requires larger pool sizes, which keeps CPUs busier but may
encounter unacceptable scheduling overhead, which also decreases throughput.
execute(java.lang.Runnable)
will be rejected
when the Executor has been shut down, and also when the Executor uses finite
bounds for both maximum threads and work queue capacity, and is saturated. In
either case, the execute
method invokes the RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, org.apache.cassandra.concurrent.ContinuationsExecutor)
method of its RejectedExecutionHandler
. Four predefined handler policies are provided:
ContinuationsExecutor.AbortPolicy
, the handler
throws a runtime RejectedExecutionException
upon rejection. ContinuationsExecutor.CallerRunsPolicy
, the thread that invokes
execute
itself runs the task. This provides a simple feedback control
mechanism that will slow down the rate that new tasks are submitted. ContinuationsExecutor.DiscardPolicy
, a task that cannot be
executed is simply dropped. ContinuationsExecutor.DiscardOldestPolicy
, if the executor is
not shut down, the task at the head of the work queue is dropped, and then
execution is retried (which can fail again, causing this to be repeated.)
RejectedExecutionHandler
classes. Doing so requires some care especially
when policies are designed to work only under particular capacity or queuing
policies. protected
overridable beforeExecute(java.lang.Thread, java.lang.Runnable)
and afterExecute(java.lang.Runnable, java.lang.Throwable)
methods that are called before and after execution
of each task. These can be used to manipulate the execution environment; for
example, reinitializing ThreadLocals, gathering statistics, or adding log
entries. Additionally, method terminated()
can be overridden to
perform any special processing that needs to be done once the Executor has
fully terminated.
If hook or callback methods throw exceptions, internal worker threads may in turn fail and abruptly terminate.
getQueue()
allows access to the work queue for purposes of
monitoring and debugging. Use of this method for any other purpose is
strongly discouraged. Two supplied methods, remove(java.lang.Runnable)
and
purge()
are available to assist in storage reclamation when large
numbers of queued tasks become cancelled.shutdown
automatically. If you would like
to ensure that unreferenced pools are reclaimed even if users forget to call
shutdown()
, then you must arrange that unused threads eventually die,
by setting appropriate keep-alive times, using a lower bound of zero core
threads and/or setting allowCoreThreadTimeOut(boolean)
. Extension example. Most extensions of this class override one or more of the protected hook methods. For example, here is a subclass that adds a simple pause/resume feature:
class PausableThreadPoolExecutor extends ContinuationsExecutor {
private boolean isPaused;
private ReentrantLock pauseLock = new ReentrantLock();
private Condition unpaused = pauseLock.newCondition();
public PausableThreadPoolExecutor(...) { super(...); }
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
pauseLock.lock();
try {
while (isPaused) unpaused.await();
} catch (InterruptedException ie) {
t.interrupt();
} finally {
pauseLock.unlock();
}
}
public void pause() {
pauseLock.lock();
try {
isPaused = true;
} finally {
pauseLock.unlock();
}
}
public void resume() {
pauseLock.lock();
try {
isPaused = false;
unpaused.signalAll();
} finally {
pauseLock.unlock();
}
}
}
Nested Class Summary | |
---|---|
static class |
ContinuationsExecutor.AbortPolicy
A handler for rejected tasks that throws a RejectedExecutionException . |
static class |
ContinuationsExecutor.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. |
static class |
ContinuationsExecutor.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. |
static class |
ContinuationsExecutor.DiscardPolicy
A handler for rejected tasks that silently discards the rejected task. |
Constructor Summary | |
---|---|
ContinuationsExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
java.util.concurrent.TimeUnit unit,
java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue)
Creates a new ContinuationsExecutor with the given initial
parameters and default thread factory and rejected execution handler. |
|
ContinuationsExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
java.util.concurrent.TimeUnit unit,
java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue,
org.apache.cassandra.concurrent.RejectedExecutionHandler handler)
Creates a new ContinuationsExecutor with the given initial
parameters and default thread factory. |
|
ContinuationsExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
java.util.concurrent.TimeUnit unit,
java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue,
java.util.concurrent.ThreadFactory threadFactory)
Creates a new ContinuationsExecutor with the given initial
parameters and default rejected execution handler. |
|
ContinuationsExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
java.util.concurrent.TimeUnit unit,
java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue,
java.util.concurrent.ThreadFactory threadFactory,
org.apache.cassandra.concurrent.RejectedExecutionHandler handler)
Creates a new ContinuationsExecutor with the given initial
parameters. |
Method Summary | |
---|---|
protected void |
afterExecute(java.lang.Runnable r,
java.lang.Throwable t)
Method invoked upon completion of execution of the given Runnable. |
void |
allowCoreThreadTimeOut(boolean value)
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. |
boolean |
allowsCoreThreadTimeOut()
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. |
boolean |
awaitTermination(long timeout,
java.util.concurrent.TimeUnit unit)
|
protected void |
beforeExecute(java.lang.Thread t,
java.lang.Runnable r)
Method invoked prior to executing the given Runnable in the given thread. |
static void |
doPostProcessing(org.apache.commons.javaflow.Continuation c)
|
void |
execute(java.lang.Runnable command)
Executes the given task sometime in the future. |
protected void |
finalize()
Invokes shutdown when this executor is no longer referenced and
it has no threads. |
int |
getActiveCount()
Returns the approximate number of threads that are actively executing tasks. |
long |
getCompletedTaskCount()
Returns the approximate total number of tasks that have completed execution. |
int |
getCorePoolSize()
Returns the core number of threads. |
long |
getKeepAliveTime(java.util.concurrent.TimeUnit unit)
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. |
int |
getLargestPoolSize()
Returns the largest number of threads that have ever simultaneously been in the pool. |
int |
getMaximumPoolSize()
Returns the maximum allowed number of threads. |
int |
getPoolSize()
Returns the current number of threads in the pool. |
java.util.concurrent.BlockingQueue<java.lang.Runnable> |
getQueue()
Returns the task queue used by this executor. |
org.apache.cassandra.concurrent.RejectedExecutionHandler |
getRejectedExecutionHandler()
Returns the current handler for unexecutable tasks. |
long |
getTaskCount()
Returns the approximate total number of tasks that have ever been scheduled for execution. |
java.util.concurrent.ThreadFactory |
getThreadFactory()
Returns the thread factory used to create new threads. |
boolean |
isShutdown()
|
boolean |
isTerminated()
|
boolean |
isTerminating()
Returns true if this executor is in the process of terminating after shutdown() or shutdownNow() but has not completely
terminated. |
int |
prestartAllCoreThreads()
Starts all core threads, causing them to idly wait for work. |
boolean |
prestartCoreThread()
Starts a core thread, causing it to idly wait for work. |
void |
purge()
Tries to remove from the work queue all Future tasks that have
been cancelled. |
static void |
putInTls(IContinuable run)
|
boolean |
remove(java.lang.Runnable task)
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. |
void |
setCorePoolSize(int corePoolSize)
Sets the core number of threads. |
void |
setKeepAliveTime(long time,
java.util.concurrent.TimeUnit unit)
Sets the time limit for which threads may remain idle before being terminated. |
void |
setMaximumPoolSize(int maximumPoolSize)
Sets the maximum allowed number of threads. |
void |
setRejectedExecutionHandler(org.apache.cassandra.concurrent.RejectedExecutionHandler handler)
Sets a new handler for unexecutable tasks. |
void |
setThreadFactory(java.util.concurrent.ThreadFactory threadFactory)
Sets the thread factory used to create new threads. |
void |
shutdown()
Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. |
java.util.List<java.lang.Runnable> |
shutdownNow()
Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution. |
protected void |
terminated()
Method invoked when the Executor has terminated. |
Methods inherited from class java.util.concurrent.AbstractExecutorService |
---|
invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor, submit, submit, submit |
Methods inherited from class java.lang.Object |
---|
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
public ContinuationsExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue)
ContinuationsExecutor
with the given initial
parameters and default thread factory and rejected execution handler. It
may be more convenient to use one of the Executors
factory
methods instead of this general purpose constructor.
corePoolSize
- the number of threads to keep in the pool, even if they are
idle, unless allowCoreThreadTimeOut
is setmaximumPoolSize
- the maximum number of threads to allow in the poolkeepAliveTime
- when the number of threads is greater than the core, this is
the maximum time that excess idle threads will wait for new
tasks before terminating.unit
- the time unit for the keepAliveTime
argumentworkQueue
- the queue to use for holding tasks before they are executed.
This queue will hold only the Runnable
tasks submitted
by the execute
method.
java.lang.IllegalArgumentException
- if one of the following holds:corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize
java.lang.NullPointerException
- if workQueue
is nullpublic ContinuationsExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue, java.util.concurrent.ThreadFactory threadFactory)
ContinuationsExecutor
with the given initial
parameters and default rejected execution handler.
corePoolSize
- the number of threads to keep in the pool, even if they are
idle, unless allowCoreThreadTimeOut
is setmaximumPoolSize
- the maximum number of threads to allow in the poolkeepAliveTime
- when the number of threads is greater than the core, this is
the maximum time that excess idle threads will wait for new
tasks before terminating.unit
- the time unit for the keepAliveTime
argumentworkQueue
- the queue to use for holding tasks before they are executed.
This queue will hold only the Runnable
tasks submitted
by the execute
method.threadFactory
- the factory to use when the executor creates a new thread
java.lang.IllegalArgumentException
- if one of the following holds:corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize
java.lang.NullPointerException
- if workQueue
or threadFactory
is nullpublic ContinuationsExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue, org.apache.cassandra.concurrent.RejectedExecutionHandler handler)
ContinuationsExecutor
with the given initial
parameters and default thread factory.
corePoolSize
- the number of threads to keep in the pool, even if they are
idle, unless allowCoreThreadTimeOut
is setmaximumPoolSize
- the maximum number of threads to allow in the poolkeepAliveTime
- when the number of threads is greater than the core, this is
the maximum time that excess idle threads will wait for new
tasks before terminating.unit
- the time unit for the keepAliveTime
argumentworkQueue
- the queue to use for holding tasks before they are executed.
This queue will hold only the Runnable
tasks submitted
by the execute
method.handler
- the handler to use when execution is blocked because the
thread bounds and queue capacities are reached
java.lang.IllegalArgumentException
- if one of the following holds:corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize
java.lang.NullPointerException
- if workQueue
or handler
is nullpublic ContinuationsExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue, java.util.concurrent.ThreadFactory threadFactory, org.apache.cassandra.concurrent.RejectedExecutionHandler handler)
ContinuationsExecutor
with the given initial
parameters.
corePoolSize
- the number of threads to keep in the pool, even if they are
idle, unless allowCoreThreadTimeOut
is setmaximumPoolSize
- the maximum number of threads to allow in the poolkeepAliveTime
- when the number of threads is greater than the core, this is
the maximum time that excess idle threads will wait for new
tasks before terminating.unit
- the time unit for the keepAliveTime
argumentworkQueue
- the queue to use for holding tasks before they are executed.
This queue will hold only the Runnable
tasks submitted
by the execute
method.threadFactory
- the factory to use when the executor creates a new threadhandler
- the handler to use when execution is blocked because the
thread bounds and queue capacities are reached
java.lang.IllegalArgumentException
- if one of the following holds:corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize
java.lang.NullPointerException
- if workQueue
or threadFactory
or
handler
is nullMethod Detail |
---|
public static void putInTls(IContinuable run)
public static void doPostProcessing(org.apache.commons.javaflow.Continuation c)
public void execute(java.lang.Runnable command)
RejectedExecutionHandler
.
command
- the task to execute
java.util.concurrent.RejectedExecutionException
- at discretion of RejectedExecutionHandler
, if the
task cannot be accepted for execution
java.lang.NullPointerException
- if command
is nullpublic void shutdown()
java.lang.SecurityException
public java.util.List<java.lang.Runnable> shutdownNow()
There are no guarantees beyond best-effort attempts to stop processing
actively executing tasks. This implementation cancels tasks via
Thread.interrupt()
, so any task that fails to respond to
interrupts may never terminate.
java.lang.SecurityException
public boolean isShutdown()
public boolean isTerminating()
shutdown()
or shutdownNow()
but has not completely
terminated. This method may be useful for debugging. A return of
true
reported a sufficient period after shutdown may indicate
that submitted tasks have ignored or suppressed interruption, causing
this executor not to properly terminate.
public boolean isTerminated()
public boolean awaitTermination(long timeout, java.util.concurrent.TimeUnit unit) throws java.lang.InterruptedException
java.lang.InterruptedException
protected void finalize()
shutdown
when this executor is no longer referenced and
it has no threads.
finalize
in class java.lang.Object
public void setThreadFactory(java.util.concurrent.ThreadFactory threadFactory)
threadFactory
- the new thread factory
java.lang.NullPointerException
- if threadFactory is nullgetThreadFactory()
public java.util.concurrent.ThreadFactory getThreadFactory()
setThreadFactory(java.util.concurrent.ThreadFactory)
public void setRejectedExecutionHandler(org.apache.cassandra.concurrent.RejectedExecutionHandler handler)
handler
- the new handler
java.lang.NullPointerException
- if handler is nullgetRejectedExecutionHandler()
public org.apache.cassandra.concurrent.RejectedExecutionHandler getRejectedExecutionHandler()
setRejectedExecutionHandler(org.apache.cassandra.concurrent.RejectedExecutionHandler)
public void setCorePoolSize(int corePoolSize)
corePoolSize
- the new core size
java.lang.IllegalArgumentException
- if corePoolSize < 0
getCorePoolSize()
public int getCorePoolSize()
setCorePoolSize(int)
public boolean prestartCoreThread()
false
if all core threads have
already been started.
true
if a thread was startedpublic int prestartAllCoreThreads()
public boolean allowsCoreThreadTimeOut()
true
if core threads are allowed to time out, else
false
public void allowCoreThreadTimeOut(boolean value)
true
. This method should in general be called before the
pool is actively used.
value
- true
if should time out, else false
java.lang.IllegalArgumentException
- if value is true
and the current keep-alive time is
not greater than zeropublic void setMaximumPoolSize(int maximumPoolSize)
maximumPoolSize
- the new maximum
java.lang.IllegalArgumentException
- if the new maximum is less than or equal to zero, or less
than the core pool sizegetMaximumPoolSize()
public int getMaximumPoolSize()
setMaximumPoolSize(int)
public void setKeepAliveTime(long time, java.util.concurrent.TimeUnit unit)
time
- the time to wait. A time value of zero will cause excess
threads to terminate immediately after executing tasks.unit
- the time unit of the time
argument
java.lang.IllegalArgumentException
- if time
less than zero or if time
is zero and
allowsCoreThreadTimeOut
getKeepAliveTime(java.util.concurrent.TimeUnit)
public long getKeepAliveTime(java.util.concurrent.TimeUnit unit)
unit
- the desired time unit of the result
setKeepAliveTime(long, java.util.concurrent.TimeUnit)
public java.util.concurrent.BlockingQueue<java.lang.Runnable> getQueue()
public boolean remove(java.lang.Runnable task)
This method may be useful as one part of a cancellation scheme. It may
fail to remove tasks that have been converted into other forms before
being placed on the internal queue. For example, a task entered using
submit
might be converted into a form that maintains
Future
status. However, in such cases, method purge()
may
be used to remove those Futures that have been cancelled.
task
- the task to remove
public void purge()
Future
tasks that have
been cancelled. This method can be useful as a storage reclamation
operation, that has no other impact on functionality. Cancelled tasks are
never executed, but may accumulate in work queues until worker threads
can actively remove them. Invoking this method instead tries to remove
them now. However, this method may fail to remove tasks in the presence
of interference by other threads.
public int getPoolSize()
public int getActiveCount()
public int getLargestPoolSize()
public long getTaskCount()
public long getCompletedTaskCount()
protected void beforeExecute(java.lang.Thread t, java.lang.Runnable r)
t
that will execute task
r
, and may be used to re-initialize ThreadLocals, or to perform
logging.
This implementation does nothing, but may be customized in subclasses.
Note: To properly nest multiple overridings, subclasses should generally
invoke super.beforeExecute
at the end of this method.
t
- the thread that will run task r
r
- the task that will be executedprotected void afterExecute(java.lang.Runnable r, java.lang.Throwable t)
RuntimeException
or Error
that
caused execution to terminate abruptly.
This implementation does nothing, but may be customized in subclasses.
Note: To properly nest multiple overridings, subclasses should generally
invoke super.afterExecute
at the beginning of this method.
Note: When actions are enclosed in tasks (such as
FutureTask
) either explicitly or via methods such as
submit
, these task objects catch and maintain computational
exceptions, and so they do not cause abrupt termination, and the internal
exceptions are not passed to this method. If you would like to
trap both kinds of failures in this method, you can further probe for
such cases, as in this sample subclass that prints either the direct
cause or the underlying exception if a task has been aborted:
{
r
- the runnable that has completedt
- the exception that caused termination, or null if execution
completed normallyprotected void terminated()
super.terminated
within this method.
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |