特別感謝：慕課網jimin老師的《Java併發程式設計與高併發解決方案》課程，以下知識點多數來自老師的課程內容。
jimin老師課程地址：Java併發程式設計與高併發解決方案

new Thread的弊端

• 每次new Thread 新建物件，效能差
• 執行緒缺乏統一管理，可能無限制的新建執行緒，相互競爭，可能佔用過多的系統資源導致宕機或者OOM（out of memory 記憶體溢位），這種問題的原因不是因為單純的new一個Thread，而是可能因為程式的bug或者設計上的缺陷導致不斷new Thread造成的。
• 缺少更多功能，如更多執行、定期執行、執行緒中斷。

執行緒池的好處

• 重用存在的執行緒，減少物件建立、消亡的開銷，效能好
• 可有效控制最大併發執行緒數，提高系統資源利用率，同時可以避免過多資源競爭，避免阻塞。
• 提供定時執行、定期執行、單執行緒、併發數控制等功能。

執行緒池類圖

線上程池的類圖中，我們最常使用的是最下邊的Executors,用它來建立執行緒池使用執行緒。那麼在上邊的類圖中，包含了一個Executor框架，它是一個根據一組執行策略的呼叫排程執行和控制非同步任務的框架，目的是提供一種將任務提交與任務如何執行分離開的機制。它包含了三個executor介面：

• Executor:執行新任務的簡單介面
• ExecutorService：擴充套件了Executor，添加了用來管理執行器生命週期和任務生命週期的方法
• ScheduleExcutorService：擴充套件了ExecutorService，支援Future和定期執行任務

執行緒池核心類-ThreadPoolExecutor

引數說明：ThreadPoolExecutor一共有七個引數，這七個引數配合起來，構成了執行緒池強大的功能。

• corePoolSize：核心執行緒數量
• maximumPoolSize：執行緒最大執行緒數
• workQueue：阻塞佇列，儲存等待執行的任務，很重要，會對執行緒池執行過程產生重大影響

當我們提交一個新的任務到執行緒池，執行緒池會根據當前池中正在執行的執行緒數量來決定該任務的處理方式。處理方式有三種：
1、直接切換（SynchronusQueue）
2、無界佇列（LinkedBlockingQueue）能夠建立的最大執行緒數為corePoolSize,這時maximumPoolSize就不會起作用了。當執行緒池中所有的核心執行緒都是執行狀態的時候，新的任務提交就會放入等待佇列中。
3、有界佇列（ArrayBlockingQueue）最大maximumPoolSize，能夠降低資源消耗，但是這種方式使得執行緒池對執行緒排程變的更困難。因為執行緒池與佇列容量都是有限的。所以想讓執行緒池的吞吐率和處理任務達到一個合理的範圍，又想使我們的執行緒排程相對簡單，並且還儘可能降低資源的消耗，我們就需要合理的限制這兩個數量
分配技巧： [如果想降低資源的消耗包括降低cpu使用率、作業系統資源的消耗、上下文切換的開銷等等，可以設定一個較大的佇列容量和較小的執行緒池容量，這樣會降低執行緒池的吞吐量。如果我們提交的任務經常發生阻塞，我們可以調整maximumPoolSize。如果我們的佇列容量較小，我們需要把執行緒池大小設定的大一些，這樣cpu的使用率相對來說會高一些。但是如果執行緒池的容量設定的過大，提高任務的數量過多的時候，併發量會增加，那麼執行緒之間的排程就是一個需要考慮的問題。這樣反而可能會降低處理任務的吞吐量。]

• keepAliveTime：執行緒沒有任務執行時最多保持多久時間終止（當執行緒中的執行緒數量大於corePoolSize的時候，如果這時沒有新的任務提交核心執行緒外的執行緒不會立即銷燬，而是等待，直到超過keepAliveTime）
• unit：keepAliveTime的時間單位
• threadFactory：執行緒工廠，用來建立執行緒，有一個預設的工場來建立執行緒，這樣新創建出來的執行緒有相同的優先順序，是非守護執行緒、設定好了名稱）
• rejectHandler：當拒絕處理任務時(阻塞佇列滿)的策略（AbortPolicy預設策略直接丟擲異常、CallerRunsPolicy用呼叫者所在的執行緒執行任務、DiscardOldestPolicy丟棄佇列中最靠前的任務並執行當前任務、DiscardPolicy直接丟棄當前任務）
  

corePoolSize、maximumPoolSize、workQueue 三者關係：如果執行的執行緒數小於corePoolSize的時候，直接建立新執行緒來處理任務。即使執行緒池中的其他執行緒是空閒的。如果執行中的執行緒數大於corePoolSize且小於maximumPoolSize時，那麼只有當workQueue滿的時候才建立新的執行緒去處理任務。如果corePoolSize與maximumPoolSize是相同的，那麼建立的執行緒池大小是固定的。這時有新任務提交，當workQueue未滿時，就把請求放入workQueue中。等待空執行緒從workQueue取出任務。如果workQueue此時也滿了，那麼就使用另外的拒絕策略引數去執行拒絕策略。

初始化方法：由七個引數組合成四個初始化方法

其他方法：

執行緒池生命週期：

• running：能接受新提交的任務，也能處理阻塞佇列中的任務
• shutdown：不能處理新的任務，但是能繼續處理阻塞佇列中任務
• stop：不能接收新的任務，也不處理佇列中的任務
• tidying：如果所有的任務都已經終止了，這時有效執行緒數為0
• terminated：最終狀態

使用Executor建立執行緒池

使用Executor可以建立四種執行緒池：分別對應上邊提到的四種執行緒池初始化方法

• 1、Executors.newCachedThreadPool
  建立一個可快取的執行緒池，如果執行緒池的長度超過了處理的需要，可以靈活回收空閒執行緒。如果沒有可回收的就新建執行緒。

//原始碼：
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

//使用方法：
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 10; i++) {
        final int index = i;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                log.info("task:{}", index);
            }
        });
    }
    executorService.shutdown();
}

值得注意的一點是，newCachedThreadPool的返回值是ExecutorService型別，該型別只包含基礎的執行緒池方法，但卻不包含執行緒監控相關方法，因此在使用返回值為ExecutorService的執行緒池型別建立新執行緒時要考慮到具體情況。

• 2、newFixedThreadPool
  定長執行緒池，可以執行緒現成的最大併發數，超出在佇列等待

//原始碼：
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

//使用方法：
public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(3);
    for (int i = 0; i < 10; i++) {
        final int index = i;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                log.info("task:{}", index);
            }
        });
    }
    executorService.shutdown();
}

• 3、newSingleThreadExecutor
  單執行緒化的執行緒池，用唯一的一個共用執行緒執行任務，保證所有任務按指定順序執行（FIFO、優先順序…）

//原始碼
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

//使用方法：
public static void main(String[] args) {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    for (int i = 0; i < 10; i++) {
        final int index = i;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                log.info("task:{}", index);
            }
        });
    }
    executorService.shutdown();
}

• 4、newScheduledThreadPool
  定長執行緒池，支援定時和週期任務執行

//原始碼：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,//此處super指的是ThreadPoolExecutor
          new DelayedWorkQueue());
}

//基礎使用方法：
public static void main(String[] args) {
    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
    executorService.schedule(new Runnable() {
        @Override
        public void run() {
            log.warn("schedule run");
        }
    }, 3, TimeUnit.SECONDS);//延遲3秒執行
    executorService.shutdown();
}

ScheduledExecutorService提供了三種方法可以使用：

scheduleAtFixedRate：以指定的速率執行任務
scheduleWithFixedDelay：以指定的延遲執行任務
舉例：

executorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        log.warn("schedule run");
    }
}, 1, 3, TimeUnit.SECONDS);//延遲一秒後每隔3秒執行

小擴充套件：延遲執行任務的操作，java中還有Timer類同樣可以實現

Timer timer = new Timer();
timer.schedule(new TimerTask() {
    @Override
    public void run() {
        log.warn("timer run");
    }
}, new Date(), 5 * 1000);