ScheduledExecutorService

public interface ScheduledExecutorService extends ExecutorService

1. 一個 ExecutorService，可安排在給定的延遲後執行或定期執行的命令。
2. schedule 方法使用各種延遲建立任務，並返回一個可用於取消或檢查執行的任務物件。
3. scheduleAtFixedRate 和 scheduleWithFixedDelay 方法建立並執行某些在取消前一直定期執行的任務。
4. 用 Executor.execute(java.lang.Runnable) 和 ExecutorService 的 submit 方法所提交的命令，通過所請求的 0 延遲進行安排。schedule 方法中允許出現 0 和負數延遲（但不是週期），並將這些視為一種立即執行的請求。

方法摘要

ScheduledFuture<？> schedule(Runnable command, long delay, TimeUnit unit)

建立並執行在給定延遲後啟用的 ScheduledFuture。

ScheduledFuture schedule(Callable callable, 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)

建立並執行一個在給定初始延遲後首次啟用的定期操作，隨後，在每一次執行終止和下一次執行開始之間都存在給定的延遲。

ScheduledThreadPoolExecutor

public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService

1. 可另行安排在給定的延遲後執行命令，或者定期執行命令。
2. 需要多個輔助執行緒時，或者要求 ThreadPoolExecutor 具有額外的靈活性或功能時，此類要優於 Timer。
3. 一旦啟用已延遲的任務就執行它，但是有關何時啟用，啟用後何時執行則沒有任何實時保證。按照提交的先進先出 (FIFO) 順序來啟用那些被安排在同一執行時間的任務。
4. 此類重寫 AbstractExecutorService 的 submit 方法，以生成內部物件控制每個任務的延遲和排程。

構造方法

ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler) 

可以自定義corePoolSize、threadFactory、handler。
corePoolSize - 池中所儲存的執行緒數（包括空閒執行緒）
threadFactory - 執行程式建立新執行緒時使用的工廠，預設DefaultThreadFactory。
handler - 由於超出執行緒範圍和佇列容量而使執行被阻塞時所使用的處理程式，預設ThreadPoolExecutor.AbortPolicy。

ScheduledThreadPoolExecutor較ThreadPoolExecutor佇列的區別是：前者只能使用DelayedWorkQueue，後者可自定義BlockingQueue。

方法實現

Future submit(XX)

提交一個 Runnable 任務用於執行，並返回一個表示該任務的 Future。

    // Override AbstractExecutorService methods

    public Future<?> submit(Runnable task) {
        return schedule(task, 0, TimeUnit.NANOSECONDS);
    }

    public <T> Future<T> submit(Runnable task, T result) {
        return schedule(Executors.callable(task, result),
                        0, TimeUnit.NANOSECONDS);
    }

    public <T> Future<T> submit(Callable<T> task) {
        return schedule(task, 0, TimeUnit.NANOSECONDS);
    }

void execute(Runnable command)

使用所要求的零延遲執行命令。

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        schedule(command, 0, TimeUnit.NANOSECONDS);
    }

從原始碼看出，submit和execute方法均由schedule(task, 0, TimeUnit.NANOSECONDS)來實現。

shutdown

在以前已提交任務的執行中發起一個有序的關閉，但是不接受新任務。

    public void shutdown() {
        cancelUnwantedTasks();
        super.shutdown();
    }

   /**
     * Cancels and clears the queue of all tasks that should not be run
     * due to shutdown policy.
     */
    private void cancelUnwantedTasks() {
        boolean keepDelayed = getExecuteExistingDelayedTasksAfterShutdownPolicy();
        boolean keepPeriodic = getContinueExistingPeriodicTasksAfterShutdownPolicy();
        if (!keepDelayed && !keepPeriodic)
            super.getQueue().clear();
        else if (keepDelayed || keepPeriodic) {
            Object[] entries = super.getQueue().toArray();
            for (int i = 0; i < entries.length; ++i) {
                Object e = entries[i];
                if (e instanceof RunnableScheduledFuture) {
                    RunnableScheduledFuture<?> t = (RunnableScheduledFuture<?>)e;
                    if (t.isPeriodic()? !keepPeriodic : !keepDelayed)
                        t.cancel(false);
                }
            }
            entries = null;
            purge();
        }
    }

由原始碼看出，取消執行緒是利用Future.cancel特性，shutdown是呼叫的父類ThreadPoolExecutor.shutdown方法。

shutdownNow

嘗試停止所有正在執行的任務、暫停等待任務的處理，並返回等待執行的任務列表。

    public List<Runnable> shutdownNow() {
        return super.shutdownNow();//ThreadPoolExecutor.shutdownNow
    }

ScheduledFuture<？> schedule(Runnable command, long delay, TimeUnit unit)

    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay,
                                       TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        RunnableScheduledFuture<?> t = decorateTask(command,
            new ScheduledFutureTask<Void>(command, null,
                                          triggerTime(delay, unit)));

        delayedExecute(t);
        return t;
    }

schedule(Callable callable, long delay, TimeUnit unit)與其實現基本相同。
宣告RunnableScheduledFuture由其內部類ScheduledFutureTask實現。
延遲執行的核心實現

    private void delayedExecute(Runnable command) {
        if (isShutdown()) {
            reject(command);//執行緒已關閉
            return;
        }
        if (getPoolSize() < getCorePoolSize())//執行的執行緒小於核心執行緒，開啟新的執行緒
            prestartCoreThread();
        super.getQueue().add(command);
    }

DelayedWorkQueue是ScheduledThreadPoolExecutor內部類，佇列的核心基於無界阻塞佇列DelayQueue實現。

private static class DelayedWorkQueue extends AbstractCollection<Runnable> implements BlockingQueue<Runnable> {
        private final DelayQueue<RunnableScheduledFuture> dq =      new  DelayQueue<RunnableScheduledFuture>();
}

scheduleAtFixedRate

給定初始延遲後首次啟用的定期操作後，以initialDelay + N * period固定週期執行任務(N>=0)。

scheduleWithFixedDelay

給定初始延遲後首次啟用的定期操作後，每一次執行終止和下一次執行開始之間都存在給定的延遲delay。

通俗地理解scheduleAtFixedRate到了時間就自動執行，scheduleWithFixedDelay是每一次任務執行完成後，延遲delay時間，再執行一個任務。
第一種情況若任務執行時間長，任務有可能並行，而第二種只能序列。

ScheduledThreadPoolExecutor繼承ThreadPoolExecutor，只用了核心執行緒池，其任務佇列是採用了內部類DelayedWorkQueue實現， 任務實體由內部類ScheduledFutureTask實現，其實現compareTo方法，達到內部自然排序，具有延遲或定期執行任務的特性。