線程池系列--ExecutorService接口：關閉線程池

public interface     Executor {
        void execute(Runnable command); //1 無返回值;線程執行的task須要實現Runnable接口
}

public interface ExecutorService extends Executor {

    /**
     * Initiates an orderly shutdown in which previously submitted
     * tasks are executed, but no new tasks will be accepted.
     * Invocation has no additional effect if already shut down.
     */
    void shutdown(); // 2 關閉線程池資源。再也不接受新的任務，以前提交的任務等待執行結束再關閉。

    /**
     * Attempts to stop all actively executing tasks, halts the
     * processing of waiting tasks, and returns a list of the tasks
     * that were awaiting execution.
     */
    List<Runnable> shutdownNow(); //3 馬上關閉

    /**
     * Returns {@code true} if this executor has been shut down.
     */
    boolean isShutdown();

    boolean isTerminated();

    /**
     * Blocks until all tasks have completed execution after a shutdown
     * request, or the timeout occurs, or the current thread is
     * interrupted, whichever happens first.
     */
     //4 等待必定時間，若是還有未完成的任務，返回false；都完成了，返回true
    boolean awaitTermination(long timeout, TimeUnit unit) 
        throws InterruptedException;
     //5 提交一個任務，異步非阻塞
    <T> Future<T> submit(Callable<T> task);
   
    <T> Future<T> submit(Runnable task, T result);

        Future<?> submit(Runnable task);
      //6 提交多個任務，阻塞等待任務完成
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
        //7 提交多個任務，阻塞必定時間等待任務完成
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

 線程池關閉流程：

jdk的api文檔：

void shutdownAndAwaitTermination(ExecutorService pool) {
   pool.shutdown(); // Disable new tasks from being submitted
   try {
     // Wait a while for existing tasks to terminate
     if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
       pool.shutdownNow(); // Cancel currently executing tasks
       // Wait a while for tasks to respond to being cancelled
       if (!pool.awaitTermination(60, TimeUnit.SECONDS))
           System.err.println("Pool did not terminate");
     }
   } catch (InterruptedException ie) {
     // (Re-)Cancel if current thread also interrupted
     pool.shutdownNow();
     // Preserve interrupt status
     Thread.currentThread().interrupt();
   }
 }