ScheduledThreadPoolExecutor (Java Platform SE 8 )

java.lang.Object
- java.util.concurrent.AbstractExecutorService
- - java.util.concurrent.ThreadPoolExecutor
  - - java.util.concurrent.ScheduledThreadPoolExecutor

All Implemented Interfaces:

Executor ， ExecutorService ， ScheduledExecutorService
```
public class ScheduledThreadPoolExecutor
extends ThreadPoolExecutor
implements ScheduledExecutorService
```
A ThreadPoolExecutor可另外调度在给定延迟之后运行的命令，或定期执行。该类优选的是Timer需要多个工作线程时，或当附加灵活性或能力ThreadPoolExecutor需要（这此类扩展）。
延迟任务执行时间早于启用，但没有任何实时保证，在启用后，他们将开始。计划执行完全相同执行时间的任务将以先进先出（FIFO）的提交顺序启用。

提交的任务在运行之前被取消，执行被抑制。默认情况下，这样一个取消的任务在工作队列中不会自动删除，直到其延迟过去。虽然这样可以进一步检查和监控，但也可能导致取消任务的无限制保留。为避免这种情况，请将setRemoveOnCancelPolicy(boolean)设置为true ，这将导致任务在取消时立即从工作队列中删除。

通过scheduleAtFixedRate或scheduleWithFixedDelay的任务的scheduleWithFixedDelay执行不重叠。虽然不同的执行可以通过不同的线程来执行，先前执行的效果happen-before那些随后的那些的。

虽然这个类继承自ThreadPoolExecutor ，但是一些继承的调优方法对它没有用。特别是因为它作为使用corePoolSize线程和无限队列的固定大小的池，对maximumPoolSize没有任何有用的效果。此外，将corePoolSize设置为零或使用allowCoreThreadTimeOut几乎不是一个好主意，因为这可能会使池没有线程来处理任务，只要它们有资格运行。

扩展笔记：此类覆盖execute和submit方法以生成内部ScheduledFuture对象来控制每个任务的延迟和调度。为了保护功能，子类中这些方法的任何进一步覆盖都必须调用超类版本，这有效地禁用其他任务自定义。然而，此类提供替代保护扩展方法decorateTask （每一个用于一个版本Runnable和Callable ），其可以被用于定制用于执行经由输入的命令的具体任务类型execute ， submit ， schedule ， scheduleAtFixedRate和scheduleWithFixedDelay 。默认情况下， ScheduledThreadPoolExecutor使用扩展为FutureTask的任务类型。但是，可以使用以下形式的子类修改或替换：
```
   public class CustomScheduledExecutor extends ScheduledThreadPoolExecutor { static class CustomTask<V> implements RunnableScheduledFuture<V> { ... } protected <V> RunnableScheduledFuture<V> decorateTask( Runnable r, RunnableScheduledFuture<V> task) { return new CustomTask<V>(r, task); } protected <V> RunnableScheduledFuture<V> decorateTask( Callable<V> c, RunnableScheduledFuture<V> task) { return new CustomTask<V>(c, task); } // ... add constructors, etc. } 
```
从以下版本开始：

1.5

Nested Class Summary
- Nested classes/interfaces inherited from class java.util.concurrent.ThreadPoolExecutor
  ThreadPoolExecutor.AbortPolicy, ThreadPoolExecutor.CallerRunsPolicy, ThreadPoolExecutor.DiscardOldestPolicy, ThreadPoolExecutor.DiscardPolicy

构造方法摘要

构造方法
Constructor and Description
`ScheduledThreadPoolExecutor(int corePoolSize)` 创建一个新的 `ScheduledThreadPoolExecutor`与给定的核心池大小。
`ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler)` 使用给定的初始参数创建一个新的ScheduledThreadPoolExecutor。
`ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory)` 创建一个新的 `ScheduledThreadPoolExecutor`与给定的初始参数。
`ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler)` 使用给定的初始参数创建一个新的ScheduledThreadPoolExecutor。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`protected <V> RunnableScheduledFuture<V>`	`decorateTask(Callable<V> callable, RunnableScheduledFuture<V> task)` 修改或替换用于执行可调用的任务。
`protected <V> RunnableScheduledFuture<V>`	`decorateTask(Runnable runnable, RunnableScheduledFuture<V> task)` 修改或替换用于执行runnable的任务。
`void`	`execute(Runnable command)` 执行 `command`零要求延迟。
`boolean`	`getContinueExistingPeriodicTasksAfterShutdownPolicy()` 获得关于是否继续执行现有定期任务的策略，即使该执行者已经是 `shutdown` 。
`boolean`	`getExecuteExistingDelayedTasksAfterShutdownPolicy()` 获得有关是否执行现有延迟任务的政策，即使这个执行者已经是 `shutdown` 。
`BlockingQueue<Runnable>`	`getQueue()` 返回此执行程序使用的任务队列。
`boolean`	`getRemoveOnCancelPolicy()` 获取关于在取消时是否应立即将已取消任务从工作队列中删除的策略。
`<V> ScheduledFuture<V>`	`schedule(Callable<V> callable, long delay, TimeUnit unit)` 创建并执行在给定延迟后启用的ScheduledFuture。
`ScheduledFuture<?>`	`schedule(Runnable command, long delay, TimeUnit unit)` 创建并执行在给定延迟后启用的单次操作。
`ScheduledFuture<?>`	`scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)` 创建并执行在给定的初始延迟之后，随后以给定的时间段首先启用的周期性动作; 那就是执行将在`initialDelay`之后开始，然后`initialDelay+period` ，然后是`initialDelay + 2 * period`等等。
`ScheduledFuture<?>`	`scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)` 创建并执行在给定的初始延迟之后首先启用的定期动作，随后在一个执行的终止和下一个执行的开始之间给定的延迟。
`void`	`setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value)` 设置关于是否继续执行现有周期性任务的策略，即使该执行者已经是 `shutdown` 。
`void`	`setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)` 设置关于是否执行现有延迟任务的策略，即使该执行者已经是 `shutdown` 。
`void`	`setRemoveOnCancelPolicy(boolean value)` 设置取消时取消任务是否应立即从工作队列中删除的策略。
`void`	`shutdown()` 启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
`List<Runnable>`	`shutdownNow()` 尝试停止所有主动执行的任务，停止等待任务的处理，并返回正在等待执行的任务列表。
`<T> Future<T>`	`submit(Callable<T> task)` 提交值返回任务以执行，并返回代表任务待处理结果的Future。
`Future<?>`	`submit(Runnable task)` 提交一个可运行的任务执行，并返回一个表示该任务的未来。
`<T> Future<T>`	`submit(Runnable task, T result)` 提交一个可运行的任务执行，并返回一个表示该任务的未来。

Methods inherited from class java.util.concurrent.AbstractExecutorService
invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.concurrent.ExecutorService
awaitTermination, invokeAll, invokeAll, invokeAny, invokeAny, isShutdown, isTerminated

- 构造方法详细信息
  - ScheduledThreadPoolExecutor
```
public ScheduledThreadPoolExecutor(int corePoolSize)
```
    创建一个新的 ScheduledThreadPoolExecutor与给定的核心池大小。
    
    参数
    
    corePoolSize - 要保留在池中的线程数，即使它们处于空闲状态，除非设置了 allowCoreThreadTimeOut
    
    异常
    
    IllegalArgumentException - 如果 corePoolSize < 0
  - ScheduledThreadPoolExecutor
```
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory)
```
    创建一个新 ScheduledThreadPoolExecutor给定的初始参数。
    
    参数
    
    corePoolSize - 要保留在池中的线程数，即使它们处于空闲状态，除非设置了 allowCoreThreadTimeOut
    
    threadFactory - 当执行者创建新线程时使用的工厂
    
    异常
    
    IllegalArgumentException - 如果 corePoolSize < 0
    
    NullPointerException - 如果 threadFactory为空
  - ScheduledThreadPoolExecutor
```
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   RejectedExecutionHandler handler)
```
    使用给定的初始参数创建一个新的ScheduledThreadPoolExecutor。
    
    参数
    
    corePoolSize - 要保留在池中的线程数，即使它们处于空闲状态，除非设置了 allowCoreThreadTimeOut
    
    handler - 执行被阻止时使用的处理程序，因为达到线程限制和队列容量
    
    异常
    
    IllegalArgumentException - 如果 corePoolSize < 0
    
    NullPointerException - 如果 handler为空
  - ScheduledThreadPoolExecutor
```
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory,
                                   RejectedExecutionHandler handler)
```
    使用给定的初始参数创建一个新的ScheduledThreadPoolExecutor。
    
    参数
    
    corePoolSize - 保留在池中的线程数，即使它们处于空闲状态，除非设置了 allowCoreThreadTimeOut
    
    threadFactory - 执行程序创建新线程时使用的工厂
    
    handler - 执行被阻止时使用的处理程序，因为达到线程限制和队列容量
    
    异常
    
    IllegalArgumentException - 如果 corePoolSize < 0
    
    NullPointerException - 如果 threadFactory或 handler为空
- 方法详细信息
  - decorateTask
```
protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable,
                                                      RunnableScheduledFuture<V> task)
```
    修改或替换用于执行runnable的任务。此方法可用于覆盖用于管理内部任务的具体类。默认实现只是返回给定的任务。
    
    参数类型
    
    V - 任务的结果类型
    
    参数
    
    runnable - 提交的Runnable
    
    task - 创建以执行runnable的任务
    
    结果
    
    一个可以执行runnable的任务
    
    从以下版本开始：
    
    1.6
  - decorateTask
```
protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable,
                                                      RunnableScheduledFuture<V> task)
```
    修改或替换用于执行可调用的任务。此方法可用于覆盖用于管理内部任务的具体类。默认实现只是返回给定的任务。
    
    参数类型
    
    V - 任务结果的类型
    
    参数
    
    callable - 提交的Callable
    
    task - 创建用于执行可调用的任务
    
    结果
    
    一个可以执行可调用的任务
    
    从以下版本开始：
    
    1.6
  - schedule
```
public ScheduledFuture<?> schedule(Runnable command,
                                   long delay,
                                   TimeUnit unit)
```
    说明从界面： ScheduledExecutorService复制
    
    创建并执行在给定延迟后启用的单次操作。
    
    Specified by:
    
    schedule在界面 ScheduledExecutorService
    
    参数
    
    command - 要执行的任务
    
    delay - 从现在开始延迟执行的时间
    
    unit - 延迟参数的时间单位
    
    结果
    
    表示任务等待完成，并且其的ScheduledFuture get()方法将返回 null完成后
    
    异常
    
    RejectedExecutionException - 如果任务无法安排执行
    
    NullPointerException - 如果命令为空
  - schedule
```
public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                       long delay,
                                       TimeUnit unit)
```
    说明从界面： ScheduledExecutorService复制
    
    创建并执行在给定延迟后启用的ScheduledFuture。
    
    Specified by:
    
    schedule在界面 ScheduledExecutorService
    
    参数类型
    
    V - 可调用结果的类型
    
    参数
    
    callable - 执行的功能
    
    delay - 从现在开始延迟执行的时间
    
    unit - 延迟参数的时间单位
    
    结果
    
    一个可用于提取结果或取消的ScheduledFuture
    
    异常
    
    RejectedExecutionException - 如果任务无法安排执行
    
    NullPointerException - 如果callable为null
  - scheduleAtFixedRate
```
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                              long initialDelay,
                                              long period,
                                              TimeUnit unit)
```
    说明从界面： ScheduledExecutorService复制
    
    创建并执行在给定的初始延迟之后，随后以给定的时间段首先启用的周期性动作; 那就是执行将在initialDelay之后开始，然后initialDelay+period ，然后是initialDelay + 2 * period ，等等。如果任务的执行遇到异常，则后续的执行被抑制。否则，任务将仅通过取消或终止执行人终止。如果任务执行时间比其周期长，则后续执行可能会迟到，但不会同时执行。
    
    Specified by:
    
    scheduleAtFixedRate在界面 ScheduledExecutorService
    
    参数
    
    command - 要执行的任务
    
    initialDelay - 延迟第一次执行的时间
    
    period - 连续执行之间的时期
    
    unit - initialDelay和period参数的时间单位
    
    结果
    
    一个ScheduledFuture代表待完成的任务，其 get()方法将在取消时抛出异常
    
    异常
    
    RejectedExecutionException - 如果任务无法安排执行
    
    NullPointerException - 如果命令为空
    
    IllegalArgumentException - 如果期间小于或等于零
  - scheduleWithFixedDelay
```
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                 long initialDelay,
                                                 long delay,
                                                 TimeUnit unit)
```
    说明从界面： ScheduledExecutorService复制
    
    创建并执行在给定的初始延迟之后首先启用的定期动作，随后在一个执行的终止和下一个执行的开始之间给定的延迟。如果任务的执行遇到异常，则后续的执行被抑制。否则，任务将仅通过取消或终止执行人终止。
    
    Specified by:
    
    scheduleWithFixedDelay在界面 ScheduledExecutorService
    
    参数
    
    command - 要执行的任务
    
    initialDelay - 延迟第一次执行的时间
    
    delay - 一个执行终止和下一个执行的开始之间的延迟
    
    unit - initialDelay和delay参数的时间单位
    
    结果
    
    一个ScheduledFuture代表待完成的任务，其 get()方法将在取消时抛出异常
    
    异常
    
    RejectedExecutionException - 如果该任务无法安排执行
    
    NullPointerException - 如果命令为空
    
    IllegalArgumentException - 如果延迟小于或等于零
  - execute
```
public void execute(Runnable command)
```
    执行command零要求延迟。这具有相当于schedule(command, 0, anyUnit)的效果。请注意，对shutdownNow返回的队列和列表的shutdownNow将访问零延迟的ScheduledFuture ，而不是command本身。
    使用的后果ScheduledFuture对象是afterExecute总是调用空第二Throwable说法，即使command突然终止。相反，这样一个任务抛出的Throwable可以通过Future.get()获得。
    
    Specified by:
    
    execute在接口 Executor
    
    重写：
    
    execute在 ThreadPoolExecutor
    
    参数
    
    command - 要执行的任务
    
    异常
    
    RejectedExecutionException - 由RejectedExecutionHandler RejectedExecutionHandler ，如果由于执行程序已被关闭，任务不能被接受执行
    
    NullPointerException - 如果 command为空
  - submit
```
public Future<?> submit(Runnable task)
```
    说明从界面： ExecutorService复制
    
    提交一个可运行的任务执行，并返回一个表示该任务的未来。未来的get方法将返回null 成功完成时。
    
    Specified by:
    
    submit在界面 ExecutorService
    
    重写：
    
    submit在 AbstractExecutorService
    
    参数
    
    task - 提交的任务
    
    结果
    
    一个未来的代表，待完成任务
    
    异常
    
    RejectedExecutionException - 如果任务无法安排执行
    
    NullPointerException - 如果任务为空
  - submit
```
public <T> Future<T> submit(Runnable task,
                            T result)
```
    说明从界面： ExecutorService复制
    
    提交一个可运行的任务执行，并返回一个表示该任务的未来。未来的get方法将在成功完成后返回给定的结果。
    
    Specified by:
    
    submit在界面 ExecutorService
    
    重写：
    
    submit在类别 AbstractExecutorService
    
    参数类型
    
    T - 结果的类型
    
    参数
    
    task - 提交的任务
    
    result - 结果返回
    
    结果
    
    一个未来的代表，待完成任务
    
    异常
    
    RejectedExecutionException - 如果任务无法安排执行
    
    NullPointerException - 如果任务为空
  - submit
```
public <T> Future<T> submit(Callable<T> task)
```
    说明从界面： ExecutorService复制
    
    提交值返回任务以执行，并返回代表任务待处理结果的Future。未来的get方法将在成功完成后返回任务的结果。
    如果您想立即阻止等待任务，您可以使用result = exec.submit(aCallable).get();格式的result = exec.submit(aCallable).get();
    
    注意： Executors类包含一组方法，可以将一些其他常见的类似闭包的对象（例如PrivilegedAction）转换为Callable形式，以便它们可以提交。
    
    Specified by:
    
    submit在界面 ExecutorService
    
    重写：
    
    submit在类别 AbstractExecutorService
    
    参数类型
    
    T - 任务结果的类型
    
    参数
    
    task - 提交的任务
    
    结果
    
    一个未来的代表，待完成任务
    
    异常
    
    RejectedExecutionException - 如果任务无法安排执行
    
    NullPointerException - 如果任务为空
  - setContinueExistingPeriodicTasksAfterShutdownPolicy
```
public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value)
```
    设置关于是否继续执行现有周期性任务的策略，即使该执行者已经是shutdown 。在这种情况下，这些任务只能在shutdownNow或者在已经关闭后将策略设置为false后终止。此值默认为false 。
    
    参数
    
    value - 如果 true ，关机后继续，否则不要
    
    另请参见：
    
    getContinueExistingPeriodicTasksAfterShutdownPolicy()
  - getContinueExistingPeriodicTasksAfterShutdownPolicy
```
public boolean getContinueExistingPeriodicTasksAfterShutdownPolicy()
```
    获得关于是否继续执行现有周期性任务的策略，即使该执行者已经是shutdown 。在这种情况下，这些任务只能在shutdownNow或者在已经关闭后将策略设置为false才会终止。此值默认为false 。
    
    结果
    
    true如果将在关机后继续
    
    另请参见：
    
    setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean)
  - setExecuteExistingDelayedTasksAfterShutdownPolicy
```
public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)
```
    设置即使执行者已经执行现有延迟任务的策略是shutdown 。在这种情况下，这些任务只能在shutdownNow ，或者在已经关闭后将策略设置为false后。此值默认为true 。
    
    参数
    
    value - 如果 true ，在关机后执行，否则不要
    
    另请参见：
    
    getExecuteExistingDelayedTasksAfterShutdownPolicy()
  - getExecuteExistingDelayedTasksAfterShutdownPolicy
```
public boolean getExecuteExistingDelayedTasksAfterShutdownPolicy()
```
    获取关于是否执行现有延迟任务的策略，即使该执行者已经是shutdown 。在这种情况下，这些任务只能在shutdownNow ，或者在已经关闭后将策略设置为false后才能false 。此值默认为true 。
    
    结果
    
    true如果在关机后执行
    
    另请参见：
    
    setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean)
  - setRemoveOnCancelPolicy
```
public void setRemoveOnCancelPolicy(boolean value)
```
    设置取消时取消任务是否应立即从工作队列中删除的策略。此值默认为false 。
    
    参数
    
    value - 如果 true ，取消取消，否则不要
    
    从以下版本开始：
    
    1.7
    
    另请参见：
    
    getRemoveOnCancelPolicy()
  - getRemoveOnCancelPolicy
```
public boolean getRemoveOnCancelPolicy()
```
    获取关于在取消时是否应立即将已取消任务从工作队列中删除的策略。此值默认为false 。
    
    结果
    
    true如果取消任务立即从队列中删除
    
    从以下版本开始：
    
    1.7
    
    另请参见：
    
    setRemoveOnCancelPolicy(boolean)
  - shutdown
```
public void shutdown()
```
    启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。如果已经关闭，调用没有额外的作用。
    此方法不等待以前提交的任务完成执行。使用awaitTermination来做到这一点。
    
    如果ExecuteExistingDelayedTasksAfterShutdownPolicy已设置为false ，则其延迟尚未过去的现有延迟任务将被取消。除了ContinueExistingPeriodicTasksAfterShutdownPolicy已经设置true ，未来执行的定期任务将被取消。
    
    Specified by:
    
    shutdown在界面 ExecutorService
    
    重写：
    
    shutdown在类别 ThreadPoolExecutor
    
    异常
    
    SecurityException - 如果安全管理器存在并关闭此ExecutorService可能会操纵调用者不允许修改的线程，因为它不会保留88453974019588 ("modifyThread")或安全管理器的checkAccess方法拒绝访问。
  - shutdownNow
```
public List<Runnable> shutdownNow()
```
    尝试停止所有主动执行的任务，停止等待任务的处理，并返回正在等待执行的任务列表。
    此方法不等待主动执行的任务终止。使用awaitTermination做到这一点。
    
    除了努力尝试停止处理积极执行任务之外，没有任何保证。此实现通过取消任务Thread.interrupt() ，让未能响应中断任何任务可能永远不会终止。
    
    Specified by:
    
    shutdownNow在界面 ExecutorService
    
    重写：
    
    shutdownNow在类别 ThreadPoolExecutor
    
    结果
    
    从未开始执行的任务列表。此列表中的每个元素是一个ScheduledFuture ，包括使用提交这些任务execute ，这对于用作零延迟的基础上调度目的ScheduledFuture 。
    
    异常
    
    SecurityException - 如果安全管理器存在并且关闭此ExecutorService可能会操纵调用者不允许修改的线程，因为它不保留RuntimePermission ("modifyThread")或安全管理器的checkAccess方法拒绝访问。
  - getQueue
```
public BlockingQueue<Runnable> getQueue()
```
    返回此执行程序使用的任务队列。该队列的每个元素都是ScheduledFuture ，其中包括使用execute提交的任务，这些任务用于作为零延迟的基础的调度目的ScheduledFuture 。这个队列的迭代不能按照它们执行的顺序遍历任务。
    
    重写：
    
    getQueue在类别 ThreadPoolExecutor
    
    结果
    
    the task queue

Class ScheduledThreadPoolExecutor

Nested Class Summary

Nested classes/interfaces inherited from class java.util.concurrent.ThreadPoolExecutor

构造方法摘要

方法摘要

Methods inherited from class java.util.concurrent.ThreadPoolExecutor

Methods inherited from class java.util.concurrent.AbstractExecutorService

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.ExecutorService

构造方法详细信息

ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor

方法详细信息

decorateTask

decorateTask

schedule

schedule

scheduleAtFixedRate

scheduleWithFixedDelay

execute

submit

submit

submit

setContinueExistingPeriodicTasksAfterShutdownPolicy

getContinueExistingPeriodicTasksAfterShutdownPolicy

setExecuteExistingDelayedTasksAfterShutdownPolicy

getExecuteExistingDelayedTasksAfterShutdownPolicy

setRemoveOnCancelPolicy

getRemoveOnCancelPolicy

shutdown

shutdownNow

getQueue