java.util.concurrent.ScheduledThreadPoolExecutor
A ThreadPoolExecutor that can additionally schedule
commands to run after a given delay, or to execute
periodically. This class is preferable to Timer
when multiple worker threads are needed, or when the additional
flexibility or capabilities of ThreadPoolExecutor (which
this class extends) are required.
Delayed tasks execute no sooner than they are enabled, but
without any real-time guarantees about when, after they are
enabled, they will commence. Tasks scheduled for exactly the same
execution time are enabled in first-in-first-out (FIFO) order of
submission.
While this class inherits from ThreadPoolExecutor, a few
of the inherited tuning methods are not useful for it. In
particular, because it acts as a fixed-sized pool using
corePoolSize threads and an unbounded queue, adjustments
to maximumPoolSize have no useful effect.
Summary
Public Constructors
Public Methods
|
|
|
|
|
void |
execute(Runnable command) |
|
|
|
|
|
boolean |
getContinueExistingPeriodicTasksAfterShutdownPolicy() |
|
|
|
|
|
boolean |
getExecuteExistingDelayedTasksAfterShutdownPolicy() |
|
|
|
|
|
BlockingQueue<Runnable> |
getQueue() |
|
|
|
|
|
boolean |
remove(Runnable task) |
|
|
|
|
|
ScheduledFuture<?> |
schedule(Runnable command, long delay, TimeUnit unit) |
|
|
|
|
<V> |
ScheduledFuture<V> |
schedule(Callable<V> callable, long delay, TimeUnit unit) |
|
|
|
|
|
ScheduledFuture<?> |
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) |
|
|
|
|
|
ScheduledFuture<?> |
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) |
|
|
|
|
|
void |
setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value) |
|
|
|
|
|
void |
setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value) |
|
|
|
|
|
void |
shutdown() |
|
|
|
|
|
List<Runnable> |
shutdownNow() |
|
|
|
|
<T> |
Future<T> |
submit(Runnable task, T result) |
|
|
|
|
<T> |
Future<T> |
submit(Callable<T> task) |
|
|
|
|
|
Future<?> |
submit(Runnable task) |
afterExecute,
awaitTermination,
beforeExecute,
execute,
finalize,
getActiveCount,
getCompletedTaskCount,
getCorePoolSize,
getKeepAliveTime,
getLargestPoolSize,
getMaximumPoolSize,
getPoolSize,
getQueue,
getRejectedExecutionHandler,
getTaskCount,
getThreadFactory,
isShutdown,
isTerminated,
isTerminating,
prestartAllCoreThreads,
prestartCoreThread,
purge,
remove,
setCorePoolSize,
setKeepAliveTime,
setMaximumPoolSize,
setRejectedExecutionHandler,
setThreadFactory,
shutdown,
shutdownNow,
terminated
clone,
equals,
finalize,
getClass,
hashCode,
notify,
notifyAll,
toString,
wait,
wait,
wait
awaitTermination,
invokeAll,
invokeAll,
invokeAny,
invokeAny,
isShutdown,
isTerminated,
shutdown,
shutdownNow,
submit,
submit,
submit
|
|
|
|
|
ScheduledFuture<?> |
schedule(Runnable command, long delay, TimeUnit unit) |
|
|
|
|
<V> |
ScheduledFuture<V> |
schedule(Callable<V> callable, long delay, TimeUnit unit) |
|
|
|
|
|
ScheduledFuture<?> |
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) |
|
|
|
|
|
ScheduledFuture<?> |
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) |
Details
Public Constructors
public
ScheduledThreadPoolExecutor(int corePoolSize)
Creates a new ScheduledThreadPoolExecutor with the given core
pool size.
Parameters
corePoolSize
| the number of threads to keep in the pool,
even if they are idle. |
public
ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory)
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
Parameters
corePoolSize
| the number of threads to keep in the pool,
even if they are idle. |
threadFactory
| the factory to use when the executor
creates a new thread. |
public
ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler)
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
Parameters
corePoolSize
| the number of threads to keep in the pool,
even if they are idle. |
handler
| the handler to use when execution is blocked
because the thread bounds and queue capacities are reached. |
public
ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler)
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
Parameters
corePoolSize
| the number of threads to keep in the pool,
even if they are idle. |
threadFactory
| the factory to use when the executor
creates a new thread. |
handler
| the handler to use when execution is blocked
because the thread bounds and queue capacities are reached. |
Public Methods
public
void
execute(Runnable command)
Execute command with zero required delay. This has effect
equivalent to
schedule(command, 0, anyUnit). Note
that inspections of the queue and of the list returned by
shutdownNow will access the zero-delayed
ScheduledFuture, not the
command itself.
Parameters
command
| the task to execute |
public
boolean
getContinueExistingPeriodicTasksAfterShutdownPolicy()
Get the policy on whether to continue executing existing
periodic tasks even when this executor has been
shutdown. In this case, these tasks will only
terminate upon
shutdownNow or after setting the policy
to
false when already shutdown. This value is by
default false.
Returns
- true if will continue after shutdown.
public
boolean
getExecuteExistingDelayedTasksAfterShutdownPolicy()
Get policy on whether to execute existing delayed
tasks even when this executor has been
shutdown. In
this case, these tasks will only terminate upon
shutdownNow, or after setting the policy to
false when already shutdown. This value is by default
true.
Returns
- true if will execute after shutdown.
Returns the task queue used by this executor. Each element of
this queue is a
ScheduledFuture, including those
tasks submitted using
execute which are for scheduling
purposes used as the basis of a zero-delay
ScheduledFuture. Iteration over this queue is
not guaranteed to traverse tasks in the order in
which they will execute.
public
boolean
remove(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.
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.
Returns
- true if the task was removed
Creates and executes a one-shot action that becomes enabled
after the given delay.
Creates and executes a ScheduledFuture that becomes enabled after the
given delay.
public
ScheduledFuture<?>
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
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.
If any execution of the task
encounters an exception, subsequent executions are suppressed.
Otherwise, the task will only terminate via cancellation or
termination of the executor.
public
ScheduledFuture<?>
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
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. If any execution of the task
encounters an exception, subsequent executions are suppressed.
Otherwise, the task will only terminate via cancellation or
termination of the executor.
public
void
setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value)
Set policy on whether to continue executing existing periodic
tasks even when this executor has been
shutdown. In
this case, these tasks will only terminate upon
shutdownNow, or after setting the policy to
false when already shutdown. This value is by default
false.
Parameters
value
| if true, continue after shutdown, else don't. |
public
void
setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)
Set policy on whether to execute existing delayed
tasks even when this executor has been
shutdown. In
this case, these tasks will only terminate upon
shutdownNow, or after setting the policy to
false when already shutdown. This value is by default
true.
Parameters
value
| if true, execute after shutdown, else don't. |
public
void
shutdown()
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be accepted. If the
ExecuteExistingDelayedTasksAfterShutdownPolicy has
been set false, existing delayed tasks whose delays
have not yet elapsed are cancelled. And unless the
ContinueExistingPeriodicTasksAfterShutdownPolicy has
been set true, future executions of existing periodic
tasks will be cancelled.
Attempts to stop all actively executing tasks, halts the
processing of waiting tasks, and returns a list of the tasks that were
awaiting execution.
There are no guarantees beyond best-effort attempts to stop
processing actively executing tasks. This implementation
cancels tasks via interrupt(), so if any tasks mask or
fail to respond to interrupts, they may never terminate.
Returns
- list of tasks that never commenced execution. Each
element of this list is a ScheduledFuture,
including those tasks submitted using execute, which
are for scheduling purposes used as the basis of a zero-delay
ScheduledFuture.
public
Future<T>
submit(Runnable task, T result)
Submits a Runnable task for execution and returns a Future
representing that task that will upon completion return
the given result.
Submits a value-returning task for execution and returns a Future
representing the pending results of the task.
If you would like to immediately block waiting
for a task, you can use constructions of the form
result = exec.submit(aCallable).get();
Note: The Executors class includes a set of methods
that can convert some other common closure-like objects,
for example, PrivilegedAction to
Callable form so they can be submitted.
Submits a Runnable task for execution and returns a Future
representing that task.