edu.emory.mathcs.backport.java.util.concurrent
public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService
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. If ScheduledThreadPoolExecutor is set {@code true} cancelled tasks are automatically removed from the work queue.
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 {@code corePoolSize} threads and an unbounded queue, adjustments to {@code maximumPoolSize} have no useful effect. Additionally, it is almost never a good idea to set {@code corePoolSize} to zero or use {@code allowCoreThreadTimeOut} because this may leave the pool without threads to handle tasks once they become eligible to run.
Extension notes: This class overrides the
execute
and
submit
methods to generate internal ScheduledFuture objects to
control per-task delays and scheduling. To preserve
functionality, any further overrides of these methods in
subclasses must invoke superclass versions, which effectively
disables additional task customization. However, this class
provides alternative protected extension method
{@code decorateTask} (one version each for {@code Runnable} and
{@code Callable}) that can be used to customize the concrete task
types used to execute commands entered via {@code execute},
{@code submit}, {@code schedule}, {@code scheduleAtFixedRate},
and {@code scheduleWithFixedDelay}. By default, a
{@code ScheduledThreadPoolExecutor} uses a task type extending
FutureTask. However, this may be modified or replaced using
subclasses of the form:
{@code public class CustomScheduledExecutor extends ScheduledThreadPoolExecutor { static class CustomTaskimplements RunnableScheduledFuture { ... } protected RunnableScheduledFuture decorateTask( Runnable r, RunnableScheduledFuture task) { return new CustomTask (r, task); } protected RunnableScheduledFuture decorateTask( Callable c, RunnableScheduledFuture task) { return new CustomTask (c, task); } // ... add constructors, etc. }}
Since: 1.5
Constructor Summary | |
---|---|
ScheduledThreadPoolExecutor(int corePoolSize)
Creates a new {@code ScheduledThreadPoolExecutor} with the
given core pool size.
| |
ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory)
Creates a new {@code ScheduledThreadPoolExecutor} with the
given initial parameters.
| |
ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler)
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
| |
ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler)
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
|
Method Summary | |
---|---|
protected RunnableScheduledFuture | decorateTask(Runnable runnable, RunnableScheduledFuture task)
Modifies or replaces the task used to execute a runnable.
|
protected RunnableScheduledFuture | decorateTask(Callable callable, RunnableScheduledFuture task)
Modifies or replaces the task used to execute a callable.
|
void | execute(Runnable command)
Executes {@code command} with zero required delay.
|
boolean | getContinueExistingPeriodicTasksAfterShutdownPolicy()
Gets the policy on whether to continue executing existing
periodic tasks even when this executor has been {@code shutdown}.
|
boolean | getExecuteExistingDelayedTasksAfterShutdownPolicy()
Gets the policy on whether to execute existing delayed
tasks even when this executor has been {@code shutdown}.
|
BlockingQueue | getQueue()
Returns the task queue used by this executor. |
boolean | getRemoveOnCancelPolicy()
Gets the policy on whether to cancellation of a a task should
remove it from the work queue.
|
ScheduledFuture | schedule(Runnable command, long delay, TimeUnit unit) |
ScheduledFuture | schedule(Callable 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)
Sets the policy on whether to continue executing existing
periodic tasks even when this executor has been {@code shutdown}.
|
void | setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)
Sets the policy on whether to execute existing delayed
tasks even when this executor has been {@code shutdown}.
|
void | setRemoveOnCancelPolicy(boolean value)
Sets the policy on whether to cancellation of a a task should
remove it from the work queue. |
void | shutdown()
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be accepted. |
List | 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.
|
Future | submit(Runnable task) |
Future | submit(Runnable task, Object result) |
Future | submit(Callable task) |
Parameters: corePoolSize the number of threads to keep in the pool, even if they are idle, unless {@code allowCoreThreadTimeOut} is set
Throws: IllegalArgumentException if {@code corePoolSize < 0}
Parameters: corePoolSize the number of threads to keep in the pool, even if they are idle, unless {@code allowCoreThreadTimeOut} is set threadFactory the factory to use when the executor creates a new thread
Throws: IllegalArgumentException if {@code corePoolSize < 0} NullPointerException if {@code threadFactory} is null
Parameters: corePoolSize the number of threads to keep in the pool, even if they are idle, unless {@code allowCoreThreadTimeOut} is set handler the handler to use when execution is blocked because the thread bounds and queue capacities are reached
Throws: IllegalArgumentException if {@code corePoolSize < 0} NullPointerException if {@code handler} is null
Parameters: corePoolSize the number of threads to keep in the pool, even if they are idle, unless {@code allowCoreThreadTimeOut} is set 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
Throws: IllegalArgumentException if {@code corePoolSize < 0} NullPointerException if {@code threadFactory} or {@code handler} is null
Parameters: runnable the submitted Runnable task the task created to execute the runnable
Returns: a task that can execute the runnable
Since: 1.6
Parameters: callable the submitted Callable task the task created to execute the callable
Returns: a task that can execute the callable
Since: 1.6
schedule(command, 0, anyUnit)
.
Note that inspections of the queue and of the list returned by
{@code shutdownNow} will access the zero-delayed
ScheduledFuture, not the {@code command} itself.
A consequence of the use of {@code ScheduledFuture} objects is
that afterExecute
is always
called with a null second {@code Throwable} argument, even if the
{@code command} terminated abruptly. Instead, the {@code Throwable}
thrown by such a task can be obtained via Future.
Throws: RejectedExecutionException at discretion of {@code RejectedExecutionHandler}, if the task cannot be accepted for execution because the executor has been shut down NullPointerException {@inheritDoc }
Returns: {@code true} if will continue after shutdown
See Also: ScheduledThreadPoolExecutor
Returns: {@code true} if will execute after shutdown
See Also: ScheduledThreadPoolExecutor
Returns: the task queue
Returns: {@code true} if cancelled tasks are removed from the queue.
Since: 1.7
See Also: ScheduledThreadPoolExecutor
Throws: RejectedExecutionException {@inheritDoc } NullPointerException {@inheritDoc }
Throws: RejectedExecutionException {@inheritDoc } NullPointerException {@inheritDoc }
Throws: RejectedExecutionException {@inheritDoc } NullPointerException {@inheritDoc } IllegalArgumentException {@inheritDoc }
Throws: RejectedExecutionException {@inheritDoc } NullPointerException {@inheritDoc } IllegalArgumentException {@inheritDoc }
Parameters: value if {@code true}, continue after shutdown, else don't.
See Also: ScheduledThreadPoolExecutor
Parameters: value if {@code true}, execute after shutdown, else don't.
See Also: ScheduledThreadPoolExecutor
Parameters: value if {@code true}, remove on cancellation, else don't.
Since: 1.7
See Also: ScheduledThreadPoolExecutor
Throws: SecurityException {@inheritDoc }
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.
Returns: list of tasks that never commenced execution. Each element of this list is a ScheduledFuture, including those tasks submitted using {@code execute}, which are for scheduling purposes used as the basis of a zero-delay {@code ScheduledFuture}.
Throws: SecurityException {@inheritDoc }
Throws: RejectedExecutionException {@inheritDoc } NullPointerException {@inheritDoc }
Throws: RejectedExecutionException {@inheritDoc } NullPointerException {@inheritDoc }
Throws: RejectedExecutionException {@inheritDoc } NullPointerException {@inheritDoc }