先看一下線程池的基礎架構圖：

1. Executor
   Executor，任務的執行者，線程池框架中幾乎所有類都直接或者間接實現Executor接口，它是線程池框架的基礎。Executor提供了一種將“任務提交”與“任務執行”分離開來的機制，它僅提供了一個Execute()方法用來執行已經提交的Runnable任務。
   

   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);
   }

2. ExecutorService
   ExecutorService，繼承Executor，它是“執行者服務”接口，它是為"執行者接口Executor"服務而存在的。準確的地說，ExecutorService提供了“將任務提交給執行者的接口(submit方法)”，“讓執行者執行任務(invokeAll, invokeAny方法)”的接口等等。
   

   public
    
    interface ExecutorService extends Executor {
   /**
   * 啟動一次順序關閉，執行以前提交的任務，但不接受新任務
   */
   void shutdown();
   
   /**
   * 試圖停止所有正在執行的活動任務，暫停處理正在等待的任務，並返回等待執行的任務列表
   */
   List<Runnable> shutdownNow();
   
   /**
   * 如果此執行程序已關閉，則返回 true。
   */
   boolean isShutdown();
   
   /**
   * 如果關閉後所有任務都已完成，則返回 true
   */
   boolean isTerminated();
   
   /**
   * 請求關閉、發生超時或者當前線程中斷，無論哪一個首先發生之後，都將導致阻塞，直到所有任務完成執行
    
   */
   boolean awaitTermination(long timeout, TimeUnit unit)
   throws InterruptedException;
   
   /**
   * 提交一個返回值的任務用於執行，返回一個表示任務的未決結果的 Future
   */
   <T> Future<T> submit(Callable<T> task);
   
   /**
   * 提交一個 Runnable 任務用於執行，並返回一個表示該任務的 Future
   */
   <T> Future<T> submit(Runnable task, T result);
   
   /**
   * 提交一個 Runnable 任務用於執行，並返回一個表示該任務的 Future
   */
   Future<?> submit(Runnable task);
   
   /**
   * 執行給定的任務，當所有任務完成時，返回保持任務狀態和結果的 Future 列表
   */
   <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
   throws InterruptedException;
   
   /**
   * 執行給定的任務，當所有任務完成或超時期滿時（無論哪個首先發生），返回保持任務狀態和結果的 Future 列表
   */
   <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;}

3. AbstractExecutorService
   抽象類，實現ExecutorService接口，為其提供默認實現。
   AbstractExecutorService除了實現ExecutorService接口外，還提供了newTaskFor()方法返回一個RunnableFuture，在運行的時候，它將調用底層可調用任務，作為 Future 任務，它將生成可調用的結果作為其結果，並為底層任務提供取消操作。
4. ScheduleExecutorService
   繼承ExcutorService，是一個“延遲”和“定期執行”的ExecutorService，提供了一些方法安排任務按照給定的條件延時執行或者周期性執行。
   

   // 創建並執行在給定延遲後啟用的 ScheduledFuture。
   <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
   
   // 創建並執行在給定延遲後啟用的一次性操作。
   ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
   
   // 創建並執行一個在給定初始延遲後首次啟用的定期操作，後續操作具有給定的周期；
   //也就是將在 initialDelay 後開始執行，然後在 initialDelay+period 後執行，接著在 initialDelay + 2 * period 後執行，依此類推。
   ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
   
   // 創建並執行一個在給定初始延遲後首次啟用的定期操作，隨後，在每一次執行終止和下一次執行開始之間都存在給定的延遲。
   ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

5. ThreadPoolExecutor
   ThreadPoolExecutor是AbstractExecutorService的默認實現，也是Executors工廠類的底層實現，提供了四個重載的自定義線程池參數的構造方法，提供了提交任務和中止線程池的執行方法，也提供了查看線程池運行狀態的監控方法。
   ThreadPoolExecutor的具體分析將在另一篇博客具體闡述，在此只簡單介紹三個方法：

6.     //實現Executor的execute方法
       //1.如果線程池當前線程數小於corePoolSize，則調用addWorker創建新線程執行任務，成功返回true，失敗執行步驟2
       //2.如果線程池處於RUNNING狀態，則嘗試加入阻塞隊列，如果加入阻塞隊列成功，則嘗試進行Double Check，確保線程可以被執行，如果加入失敗，則執行步驟3
       //3.如果線程池不是RUNNING狀態或者加入阻塞隊列失敗，則嘗試創建新線程直到maxPoolSize，如果失敗，則調用reject()方法執行對應的拒絕策略
       public void execute(Runnable var1) {
           if (var1 == null) {
               throw new NullPointerException();
           } else {
               int var2 = this.ctl.get();
               if (workerCountOf(var2) < this.corePoolSize) {
                   if (this.addWorker(var1, true)) {
                       return;
                   }
   
                   var2 = this.ctl.get();
               }
   
               if (isRunning(var2) && this.workQueue.offer(var1)) {
                   int var3 = this.ctl.get();
                   if (!isRunning(var3) && this.remove(var1)) {
                       this.reject(var1);
                   } else if (workerCountOf(var3) == 0) {
                       this.addWorker((Runnable)null, false);
                   }
               } else if (!this.addWorker(var1, false)) {
                   this.reject(var1);
               }
   
           }
       }
   
       //按過去執行已提交任務的順序發起一個有序的關閉，但是不接受新任務
       public void shutdown() {
           ...
       }
   
       //嘗試停止所有的活動執行任務、暫停等待任務的處理，並返回等待執行的任務列表
       public List<Runnable> shutdownNow() {
           ...
       }

7. ScheduledThreadPoolExecutor
   ScheduledThreadPoolExecutor繼承ThreadPoolExecutor並且實現ScheduledExecutorService接口，相當於提供了“延遲”和“周期執行”功能的ThreadPoolExecutor。
8. Executors
   靜態工廠類，提供了Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 、Callable 等類的靜態工廠方法，通過這些工廠方法我們可以得到相對應的對象。
   （1）創建並返回設置有常用配置字符串的 ExecutorService 的方法。 （2）創建並返回設置有常用配置字符串的 ScheduledExecutorService 的方法。 （3）創建並返回“包裝的”ExecutorService 方法，它通過使特定於實現的方法不可訪問來禁用重新配置。 （4）創建並返回 ThreadFactory 的方法，它可將新創建的線程設置為已知的狀態。 （5）創建並返回非閉包形式的 Callable 的方法，這樣可將其用於需要 Callable 的執行方法中。

J.U.C之線程池