public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

public interface ExecutorService extends Executor

     //啟動有序關(guān)閉，先前已經(jīng)執(zhí)行的的任務(wù)將會繼續(xù)執(zhí)行，但不會執(zhí)行新的任務(wù)。
    void shutdown();

     //嘗試停止所有主動執(zhí)行的任務(wù)，停止等待任務(wù)的處理，并返回正在等待執(zhí)行的任務(wù)列表。
    List<Runnable> shutdownNow();

     //如果這個Executor已被關(guān)閉，則返回 true 。 
    boolean isShutdown();

    //如果所有任務(wù)在關(guān)閉后完成，則返回true 。 請注意， isTerminated從不true ，除非shutdown或shutdownNow先被執(zhí)行。 
    boolean isTerminated();

    //阻止所有任務(wù)在關(guān)閉請求完成后執(zhí)行，或發(fā)生超時，或當(dāng)前線程中斷，以先到者為準(zhǔn)。 
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    //提交值返回任務(wù)以執(zhí)行，并返回代表任務(wù)待處理結(jié)果的Future。
    <T> Future<T> submit(Callable<T> task);

    //提交一個可運行的任務(wù)執(zhí)行，并返回一個表示該任務(wù)的Future。Future的get方法將在成功完成后返回給定的結(jié)果。
    <T> Future<T> submit(Runnable task, T result);

    提交一個可運行的任務(wù)執(zhí)行，并返回一個表示該任務(wù)的Future。Future的get方法將在成功完成后返回null。
    Future<?> submit(Runnable task);

    //執(zhí)行給定的任務(wù)，返回持有他們的狀態(tài)和結(jié)果的所有完成的Future列表。
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    //執(zhí)行給定的任務(wù)，返回在所有完成或超時到期時持有其狀態(tài)和結(jié)果的Future列表
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    //執(zhí)行給定的任務(wù)，返回一個成功完成的結(jié)果（即沒有拋出異常），如果有的話。 正?；虍惓Ｍ顺龊螅形赐瓿傻娜蝿?wù)將被取消。
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    //執(zhí)行給定的任務(wù)，返回一個已經(jīng)成功完成的結(jié)果（即，不拋出異常），如果有的話。
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

public interface ScheduledExecutorService extends ExecutorService

     /* 創(chuàng)建并執(zhí)行在給定延遲后啟用的單次操作。

	參數(shù)
	    command - 要執(zhí)行的任務(wù) 
	    delay - 從現(xiàn)在開始延遲執(zhí)行的時間 
	    unit - 延時參數(shù)的時間單位 
	結(jié)果
	    表示任務(wù)等待完成，并且它的ScheduledFuture get()方法將返回 null。
    */
    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);

    /* 創(chuàng)建并執(zhí)行在給定延遲后啟用的ScheduledFuture。
		參數(shù)類型
		    V - 可調(diào)用結(jié)果的類型 
		參數(shù)
		    callable - 執(zhí)行的功能 
		    delay - 從現(xiàn)在開始延遲執(zhí)行的時間 
		    unit - 延遲參數(shù)的時間單位 
		結(jié)果
		    一個可用于提取結(jié)果或取消的ScheduledFuture 
     */
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);

    /*在初始延遲之后周期性的執(zhí)行command。
     參數(shù)
	    command - 要執(zhí)行的任務(wù) 
	    initialDelay - 延遲第一次執(zhí)行的時間 
	    period - 連續(xù)執(zhí)行之間的時期 
	    unit - initialDelay和period參數(shù)的時間單位 
	結(jié)果
	    一個ScheduledFuture代表待完成的任務(wù)，其 get()方法將在取消時拋出異常 
    */
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

    /**
      創(chuàng)建并執(zhí)行在給定的初始延遲之后首先啟用的定期動作，隨后在一個執(zhí)行的終止和下一個執(zhí)行的開始之間給定的延遲。 如果任務(wù)的執(zhí)行遇到異常，則后續(xù)的執(zhí)行被抑制。 否則，任務(wù)將僅通過取消或終止執(zhí)行人終止。
		參數(shù)
		    command - 要執(zhí)行的任務(wù) 
		    initialDelay - 延遲第一次執(zhí)行的時間 
		    delay - 一個執(zhí)行終止與下一個執(zhí)行的開始之間的延遲 
		    unit - initialDelay和delay參數(shù)的時間單位 
		結(jié)果
		    一個ScheduledFuture代表待完成的任務(wù)，其 get()方法將在取消時拋出異常 
     */
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
/

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

/
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

/
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService