Java多執行緒學習（八）執行緒池與Executor 框架

SnailClimb發表於2019-03-01

Java執行緒框架

Java面試通關手冊（Java學習指南，歡迎Star，會一直完善下去，歡迎建議和指導）：github.com/Snailclimb/…

歷史優質文章推薦：

Java併發程式設計指南專欄

分散式系統的經典基礎理論

可能是最漂亮的Spring事務管理詳解

面試中關於Java虛擬機器（jvm）的問題看這篇就夠了

本節思維導圖：

思維導圖原始檔+思維導圖軟體關注微信公眾號：“Java面試通關手冊” 回覆關鍵字：“Java多執行緒” 免費領取。

一使用執行緒池的好處

執行緒池提供了一種限制和管理資源（包括執行一個任務）。每個執行緒池還維護一些基本統計資訊，例如已完成任務的數量。這裡借用《Java併發程式設計的藝術》提到的來說一下使用執行緒池的好處：

降低資源消耗。通過重複利用已建立的執行緒降低執行緒建立和銷燬造成的消耗。
提高響應速度。當任務到達時，任務可以不需要的等到執行緒建立就能立即執行。
提高執行緒的可管理性。執行緒是稀缺資源，如果無限制的建立，不僅會消耗系統資源，還會降低系統的穩定性，使用執行緒池可以進行統一的分配，調優和監控。

二 Executor 框架

2.1 簡介

Executor 框架是Java5之後引進的，在Java 5之後，通過 Executor 來啟動執行緒比使用 Thread 的 start 方法更好，除了更易管理，效率更好（用執行緒池實現，節約開銷）外，還有關鍵的一點：有助於避免 this 逃逸問題。

補充：this逃逸是指在建構函式返回之前其他執行緒就持有該物件的引用. 呼叫尚未構造完全的物件的方法可能引發令人疑惑的錯誤。

2.2 Executor 框架結構(主要由三大部分組成)

1 任務。

執行任務需要實現的Runnable介面或Callable介面。 Runnable介面或Callable介面實現類都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor執行。

兩者的區別：

Runnable介面不會返回結果但是Callable介面可以返回結果。後面介紹Executors類的一些方法的時候會介紹到兩者的相互轉換。

2 任務的執行

如下圖所示，包括任務執行機制的核心介面Executor ，以及繼承自Executor 介面的ExecutorService介面。ScheduledThreadPoolExecutor和ThreadPoolExecutor這兩個關鍵類實現了ExecutorService介面。

注意： 通過檢視ScheduledThreadPoolExecutor原始碼我們發現ScheduledThreadPoolExecutor實際上是繼承了ThreadPoolExecutor並實現了ScheduledExecutorService ，而ScheduledExecutorService又實現了ExecutorService，正如我們下面給出的類關係圖顯示的一樣。

ThreadPoolExecutor類描述:

//AbstractExecutorService實現了ExecutorService介面
public class ThreadPoolExecutor extends AbstractExecutorService
複製程式碼

ScheduledThreadPoolExecutor類描述:

//ScheduledExecutorService實現了ExecutorService介面
public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService 
複製程式碼

3 非同步計算的結果

Future介面以及Future介面的實現類FutureTask類。當我們把Runnable介面或Callable介面的實現類提交（呼叫submit方法）給ThreadPoolExecutor或ScheduledThreadPoolExecutor時，會返回一個FutureTask物件。

我們以AbstractExecutorService介面中的一個submit方法為例子來看看原始碼：

    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
複製程式碼

上面方法呼叫的newTaskFor方法返回了一個FutureTask物件。

    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }
複製程式碼

2.3 Executor 框架的使用示意圖

主執行緒首先要建立實現Runnable或者Callable介面的任務物件。 備註： 工具類Executors可以實現Runnable物件和Callable物件之間的相互轉換。（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object resule））。
然後可以把建立完成的Runnable物件直接交給ExecutorService執行（ExecutorService.execute（Runnable command））；或者也可以把Runnable物件或Callable物件提交給ExecutorService執行（ExecutorService.submit（Runnable task）或ExecutorService.submit（Callable task））。

執行execute()方法和submit()方法的區別是什麼呢？ 1)execute()方法用於提交不需要返回值的任務，所以無法判斷任務是否被執行緒池執行成功與否； 2)submit()方法用於提交需要返回值的任務。執行緒池會返回一個future型別的物件，通過這個future物件可以判斷任務是否執行成功，並且可以通過future的get()方法來獲取返回值，get()方法會阻塞當前執行緒直到任務完成，而使用get（long timeout，TimeUnit unit）方法則會阻塞當前執行緒一段時間後立即返回，這時候有可能任務沒有執行完。

如果執行ExecutorService.submit（…），ExecutorService將返回一個實現Future介面的物件（我們剛剛也提到過了執行execute()方法和submit()方法的區別，到目前為止的JDK中，返回的是FutureTask物件）。由於FutureTask實現了Runnable，程式設計師也可以建立FutureTask，然後直接交給ExecutorService執行。
最後，主執行緒可以執行FutureTask.get()方法來等待任務執行完成。主執行緒也可以執行FutureTask.cancel（boolean mayInterruptIfRunning）來取消此任務的執行。

三 ThreadPoolExecutor詳解

執行緒池實現類ThreadPoolExecutor是Executor 框架最核心的類，先來看一下這個類中比較重要的四個屬性

3.1 ThreadPoolExecutor類的四個比較重要的屬性

3.2 ThreadPoolExecutor類中提供的四個構造方法

我們看最長的那個，其餘三個都是在這個構造方法的基礎上產生（給定某些預設引數的構造方法）

    /**
     * 用給定的初始引數建立一個新的ThreadPoolExecutor。

     * @param keepAliveTime 當執行緒池中的執行緒數量大於corePoolSize的時候，如果這時沒有新的任務提交，
     *核心執行緒外的執行緒不會立即銷燬，而是會等待，直到等待的時間超過了keepAliveTime；
     * @param unit  keepAliveTime引數的時間單位
     * @param workQueue 等待佇列，當任務提交時，如果執行緒池中的執行緒數量大於等於corePoolSize的時候，把該任務封裝成一個Worker物件放入等待佇列；
     * 
     * @param threadFactory 執行者建立新執行緒時使用的工廠
     * @param handler RejectedExecutionHandler型別的變數，表示執行緒池的飽和策略。
     * 如果阻塞佇列滿了並且沒有空閒的執行緒，這時如果繼續提交任務，就需要採取一種策略處理該任務。
     * 執行緒池提供了4種策略：
        1.AbortPolicy：直接丟擲異常，這是預設策略；
        2.CallerRunsPolicy：用呼叫者所在的執行緒來執行任務；
        3.DiscardOldestPolicy：丟棄阻塞佇列中靠最前的任務，並執行當前任務；
        4.DiscardPolicy：直接丟棄任務；
     */
    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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
複製程式碼

3.3 如何建立ThreadPoolExecutor

方式一：通過構造方法實現（官方API文件並不推薦，所以建議使用第二種方式）

方式二：通過Executor 框架的工具類Executors來實現我們可以建立三種型別的ThreadPoolExecutor：

FixedThreadPool
SingleThreadExecutor
CachedThreadPool

對應Executors工具類中的方法如圖所示：

3.4 FixedThreadPool詳解

FixedThreadPool被稱為可重用固定執行緒數的執行緒池。通過Executors類中的相關原始碼來看一下相關實現：

   /**
     * 建立一個可重用固定數量執行緒的執行緒池
	 *在任何時候至多有n個執行緒處於活動狀態
	 *如果在所有執行緒處於活動狀態時提交其他任務，則它們將在佇列中等待，
	 *直到執行緒可用。 如果任何執行緒在關閉之前的執行期間由於失敗而終止，
	 *如果需要執行後續任務，則一個新的執行緒將取代它。池中的執行緒將一直存在
	 *知道呼叫shutdown方法
     * @param nThreads 執行緒池中的執行緒數
     * @param threadFactory 建立新執行緒時使用的factory
     * @return 新建立的執行緒池
     * @throws NullPointerException 如果threadFactory為null
     * @throws IllegalArgumentException if {@code nThreads <= 0}
     */
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }
複製程式碼

另外還有一個FixedThreadPool的實現方法，和上面的類似，所以這裡不多做闡述：

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
複製程式碼

從上面原始碼可以看出新建立的FixedThreadPool的corePoolSize和maximumPoolSize都被設定為nThreads。 FixedThreadPool的execute()方法執行示意圖（該圖片來源：《Java併發程式設計的藝術》）：

上圖說明：

如果當前執行的執行緒數小於corePoolSize，則建立新的執行緒來執行任務；
當前執行的執行緒數等於corePoolSize後，將任務加入LinkedBlockingQueue；
執行緒執行完1中的任務後，會在迴圈中反覆從LinkedBlockingQueue中獲取任務來執行；

FixedThreadPool使用無界佇列 LinkedBlockingQueue（佇列的容量為Intger.MAX_VALUE）作為執行緒池的工作佇列會對執行緒池帶來如下影響：

當執行緒池中的執行緒數達到corePoolSize後，新任務將在無界佇列中等待，因此執行緒池中的執行緒數不會超過corePoolSize；
由於1，使用無界佇列時maximumPoolSize將是一個無效引數；
由於1和2，使用無界佇列時keepAliveTime將是一個無效引數；
執行中的FixedThreadPool（未執行shutdown()或shutdownNow()方法）不會拒絕任務

3.5 SingleThreadExecutor詳解

SingleThreadExecutor是使用單個worker執行緒的Executor。下面看看SingleThreadExecutor的實現：

   /**
     *建立使用單個worker執行緒執行無界佇列的Executor
	 *並使用提供的ThreadFactory在需要時建立新執行緒
     *
     * @param threadFactory 建立新執行緒時使用的factory
     *
     * @return 新建立的單執行緒Executor
     * @throws NullPointerException 如果ThreadFactory為空
     */
    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }
複製程式碼

   public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
複製程式碼

從上面原始碼可以看出新建立的SingleThreadExecutor的corePoolSize和maximumPoolSize都被設定為1.其他引數和FixedThreadPool相同。SingleThreadExecutor使用無界佇列LinkedBlockingQueue作為執行緒池的工作佇列（佇列的容量為Intger.MAX_VALUE）。SingleThreadExecutor使用無界佇列作為執行緒池的工作佇列會對執行緒池帶來的影響與FixedThreadPool相同。

SingleThreadExecutor的執行示意圖（該圖片來源：《Java併發程式設計的藝術》）：

上圖說明;

如果當前執行的執行緒數少於corePoolSize，則建立一個新的執行緒執行任務；
當前執行緒池中有一個執行的執行緒後，將任務加入LinkedBlockingQueue
執行緒執行完1中的任務後，會在迴圈中反覆從LinkedBlockingQueue中獲取任務來執行；

3.6 CachedThreadPool詳解

CachedThreadPool是一個會根據需要建立新執行緒的執行緒池。下面通過原始碼來看看 CachedThreadPool的實現：

    /**
     * 建立一個執行緒池，根據需要建立新執行緒，但會在先前構建的執行緒可用時重用它，
	 *並在需要時使用提供的ThreadFactory建立新執行緒。
     * @param threadFactory 建立新執行緒使用的factory
     * @return 新建立的執行緒池
     * @throws NullPointerException 如果threadFactory為空
     */
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
    }

複製程式碼

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
複製程式碼

CachedThreadPool的corePoolSize被設定為空（0），maximumPoolSize被設定為Integer.MAX.VALUE，即它是無界的，這也就意味著如果主執行緒提交任務的速度高於maximumPool中執行緒處理任務的速度時，CachedThreadPool會不斷建立新的執行緒。極端情況下，這樣會導致耗盡cpu和記憶體資源。

CachedThreadPool的execute()方法的執行示意圖（該圖片來源：《Java併發程式設計的藝術》）：

上圖說明：

首先執行SynchronousQueue.offer(Runnable task)。如果當前maximumPool中有閒執行緒正在執行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)，那麼主執行緒執行offer操作與空閒執行緒執行的poll操作配對成功，主執行緒把任務交給空閒執行緒執行，execute()方法執行完成，否則執行下面的步驟2；
當初始maximumPool為空，或者maximumPool中沒有空閒執行緒時，將沒有執行緒執行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。這種情況下，步驟1將失敗，此時CachedThreadPool會建立新執行緒執行任務，execute方法執行完成；

3.7 ThreadPoolExecutor使用示例

3.7.1 示例程式碼

首先建立一個Runnable介面的實現類（當然也可以是Callable介面，我們上面也說了兩者的區別是：Runnable介面不會返回結果但是Callable介面可以返回結果。後面介紹Executors類的一些方法的時候會介紹到兩者的相互轉換。）

import java.util.Date;

/**
 * 這是一個簡單的Runnable類，需要大約5秒鐘來執行其任務。
 */
public class WorkerThread implements Runnable {

    private String command;

    public WorkerThread(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
        processCommand();
        System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return this.command;
    }
}
複製程式碼

編寫測試程式，我們這裡以FixedThreadPool為例子

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
        //建立一個FixedThreadPool物件
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            //建立WorkerThread物件（WorkerThread類實現了Runnable 介面）
            Runnable worker = new WorkerThread("" + i);
            //執行Runnable
            executor.execute(worker);
        }
        //終止執行緒池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}
複製程式碼

輸出示例：

pool-1-thread-5 Start. Time = Thu May 31 10:22:52 CST 2018
pool-1-thread-3 Start. Time = Thu May 31 10:22:52 CST 2018
pool-1-thread-2 Start. Time = Thu May 31 10:22:52 CST 2018
pool-1-thread-4 Start. Time = Thu May 31 10:22:52 CST 2018
pool-1-thread-1 Start. Time = Thu May 31 10:22:52 CST 2018
pool-1-thread-4 End. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-1 End. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-2 End. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-5 End. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-3 End. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-5 Start. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-2 Start. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-1 Start. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-4 Start. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-3 Start. Time = Thu May 31 10:22:57 CST 2018
pool-1-thread-5 End. Time = Thu May 31 10:23:02 CST 2018
pool-1-thread-1 End. Time = Thu May 31 10:23:02 CST 2018
pool-1-thread-2 End. Time = Thu May 31 10:23:02 CST 2018
pool-1-thread-3 End. Time = Thu May 31 10:23:02 CST 2018
pool-1-thread-4 End. Time = Thu May 31 10:23:02 CST 2018
Finished all threads

複製程式碼

3.7.2 shutdown（）VS shutdownNow（）

shutdown（）方法表明關閉已在Executor上呼叫，因此不會再向DelayedPool新增任何其他任務（由ScheduledThreadPoolExecutor類在內部使用）。但是，已經在佇列中提交的任務將被允許完成。另一方面，shutdownNow（）方法試圖終止當前正在執行的任務，並停止處理排隊的任務並返回正在等待執行的List。 ####3.7.3 isTerminated() Vs isShutdown() isShutdown（）表示執行程式正在關閉，但並非所有任務都已完成執行。另一方面，isShutdown（）表示所有執行緒都已完成執行。

四 ScheduledThreadPoolExecutor詳解

4.1 簡介

ScheduledThreadPoolExecutor主要用來在給定的延遲後執行任務，或者定期執行任務。

ScheduledThreadPoolExecutor使用的任務佇列DelayQueue封裝了一個PriorityQueue，PriorityQueue會對佇列中的任務進行排序，執行所需時間短的放在前面先被執行(ScheduledFutureTask的time變數小的先執行)，如果執行所需時間相同則先提交的任務將被先執行(ScheduledFutureTask的squenceNumber變數小的先執行)。

ScheduledThreadPoolExecutor和Timer的比較：

Timer對系統時鐘的變化敏感，ScheduledThreadPoolExecutor不是；
Timer只有一個執行執行緒，因此長時間執行的任務可以延遲其他任務。 ScheduledThreadPoolExecutor可以配置任意數量的執行緒。此外，如果你想（通過提供ThreadFactory），你可以完全控制建立的執行緒;
在TimerTask中丟擲的執行時異常會殺死一個執行緒，從而導致Timer當機:-( ...即計劃任務將不再執行。ScheduledThreadExecutor不僅捕獲執行時異常，還允許您在需要時處理它們（通過重寫afterExecute方法 ThreadPoolExecutor）。丟擲異常的任務將被取消，但其他任務將繼續執行。

綜上，在JDK1.5之後，你沒有理由再使用Timer進行任務排程了。

備註： Quartz是一個由java編寫的任務排程庫，由OpenSymphony組織開源出來。在實際專案開發中使用Quartz的還是居多，比較推薦使用Quartz。因為Quartz理論上能夠同時對上萬個任務進行排程，擁有豐富的功能特性，包括任務排程、任務持久化、可叢集化、外掛等等。

4.2 ScheduledThreadPoolExecutor執行機制

ScheduledThreadPoolExecutor的執行主要分為兩大部分：

當呼叫ScheduledThreadPoolExecutor的 scheduleAtFixedRate() 方法或者scheduleWirhFixedDelay() 方法時，會向ScheduledThreadPoolExecutor的 DelayQueue 新增一個實現了 RunnableScheduledFutur 介面的 ScheduledFutureTask 。
執行緒池中的執行緒從DelayQueue中獲取ScheduledFutureTask，然後執行任務。

ScheduledThreadPoolExecutor為了實現週期性的執行任務，對ThreadPoolExecutor做了如下修改：

使用 DelayQueue 作為任務佇列；
獲取任務的方不同
執行週期任務後，增加了額外的處理

4.3 ScheduledThreadPoolExecutor執行週期任務的步驟

執行緒1從DelayQueue中獲取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任務是指ScheduledFutureTask的time大於等於當前系統的時間；
執行緒1執行這個ScheduledFutureTask；
執行緒1修改ScheduledFutureTask的time變數為下次將要被執行的時間；
執行緒1把這個修改time之後的ScheduledFutureTask放回DelayQueue中（DelayQueue.add())。

4.4 ScheduledThreadPoolExecutor使用示例

建立一個簡單的實現Runnable介面的類（我們上面的例子已經實現過）
測試程式使用ScheduledExecutorService和ScheduledThreadPoolExecutor實現的java排程。

/**
 * 使用ScheduledExecutorService和ScheduledThreadPoolExecutor實現的java排程程式示例程式。
 */
public class ScheduledThreadPoolDemo {

    public static void main(String[] args) throws InterruptedException {

        //建立一個ScheduledThreadPoolExecutor物件
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //計劃在某段時間後執行
        System.out.println("Current Time = "+new Date());
        for(int i=0; i<3; i++){
            Thread.sleep(1000);
            WorkerThread worker = new WorkerThread("do heavy processing");
            //建立並執行在給定延遲後啟用的單次操作。 
            scheduledThreadPool.schedule(worker, 10, TimeUnit.SECONDS);
        }

        //新增一些延遲讓排程程式產生一些執行緒
        Thread.sleep(30000);
        System.out.println("Current Time = "+new Date());
        //關閉執行緒池
        scheduledThreadPool.shutdown();
        while(!scheduledThreadPool.isTerminated()){
            //等待所有任務完成
        }
        System.out.println("Finished all threads");
    }

}
複製程式碼

執行結果：

Current Time = Wed May 30 17:11:16 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:11:27 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:11:28 CST 2018
pool-1-thread-3 Start. Time = Wed May 30 17:11:29 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:11:32 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:11:33 CST 2018
pool-1-thread-3 End. Time = Wed May 30 17:11:34 CST 2018
Current Time = Wed May 30 17:11:49 CST 2018
Finished all threads
複製程式碼

4.4.1 ScheduledExecutorService scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)方法

我們可以使用ScheduledExecutorService scheduleAtFixedRate方法來安排任務在初始延遲後執行，然後在給定的時間段內執行。

時間段是從池中第一個執行緒的開始，因此如果您將period指定為1秒並且執行緒執行5秒，那麼只要第一個工作執行緒完成執行，下一個執行緒就會開始執行。

for (int i = 0; i < 3; i++) {
	Thread.sleep(1000);
	WorkerThread worker = new WorkerThread("do heavy processing");
	// schedule task to execute at fixed rate
	scheduledThreadPool.scheduleAtFixedRate(worker, 0, 10,
	TimeUnit.SECONDS);
}
複製程式碼

輸出示例:

Current Time = Wed May 30 17:47:09 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:47:10 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:47:11 CST 2018
pool-1-thread-3 Start. Time = Wed May 30 17:47:12 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:47:15 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:47:16 CST 2018
pool-1-thread-3 End. Time = Wed May 30 17:47:17 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:47:20 CST 2018
pool-1-thread-4 Start. Time = Wed May 30 17:47:21 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:47:22 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:47:25 CST 2018
pool-1-thread-4 End. Time = Wed May 30 17:47:26 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:47:27 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:47:30 CST 2018
pool-1-thread-3 Start. Time = Wed May 30 17:47:31 CST 2018
pool-1-thread-5 Start. Time = Wed May 30 17:47:32 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:47:35 CST 2018
pool-1-thread-3 End. Time = Wed May 30 17:47:36 CST 2018
pool-1-thread-5 End. Time = Wed May 30 17:47:37 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:47:40 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:47:41 CST 2018
Current Time = Wed May 30 17:47:42 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:47:45 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:47:46 CST 2018
Finished all threads

Process finished with exit code 0

複製程式碼

4.4.2 ScheduledExecutorService scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)方法

ScheduledExecutorService scheduleWithFixedDelay方法可用於以初始延遲啟動週期性執行，然後以給定延遲執行。延遲時間是執行緒完成執行的時間。

for (int i = 0; i < 3; i++) {
	Thread.sleep(1000);
	WorkerThread worker = new WorkerThread("do heavy processing");
	scheduledThreadPool.scheduleWithFixedDelay(worker, 0, 1,
	TimeUnit.SECONDS);
}
複製程式碼

輸出示例：

Current Time = Wed May 30 17:58:09 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:58:10 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:58:11 CST 2018
pool-1-thread-3 Start. Time = Wed May 30 17:58:12 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:58:15 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:58:16 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:58:16 CST 2018
pool-1-thread-3 End. Time = Wed May 30 17:58:17 CST 2018
pool-1-thread-4 Start. Time = Wed May 30 17:58:17 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:58:18 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:58:21 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:58:22 CST 2018
pool-1-thread-4 End. Time = Wed May 30 17:58:22 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:58:23 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:58:23 CST 2018
pool-1-thread-4 Start. Time = Wed May 30 17:58:24 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:58:27 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:58:28 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:58:28 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:58:29 CST 2018
pool-1-thread-4 End. Time = Wed May 30 17:58:29 CST 2018
pool-1-thread-4 Start. Time = Wed May 30 17:58:30 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:58:33 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:58:34 CST 2018
pool-1-thread-1 Start. Time = Wed May 30 17:58:34 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:58:35 CST 2018
pool-1-thread-4 End. Time = Wed May 30 17:58:35 CST 2018
pool-1-thread-4 Start. Time = Wed May 30 17:58:36 CST 2018
pool-1-thread-1 End. Time = Wed May 30 17:58:39 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:58:40 CST 2018
pool-1-thread-5 Start. Time = Wed May 30 17:58:40 CST 2018
pool-1-thread-4 End. Time = Wed May 30 17:58:41 CST 2018
pool-1-thread-2 Start. Time = Wed May 30 17:58:41 CST 2018
Current Time = Wed May 30 17:58:42 CST 2018
pool-1-thread-5 End. Time = Wed May 30 17:58:45 CST 2018
pool-1-thread-2 End. Time = Wed May 30 17:58:46 CST 2018
Finished all threads
複製程式碼

4.4.3 scheduleWithFixedDelay() vs scheduleAtFixedRate()

scheduleAtFixedRate（...）將延遲視為兩個任務開始之間的差異（即定期呼叫） scheduleWithFixedDelay（...）將延遲視為一個任務結束與下一個任務開始之間的差異

scheduleAtFixedRate(): 建立並執行在給定的初始延遲之後，隨後以給定的時間段首先啟用的週期性動作; 那就是執行將在initialDelay之後開始，然後initialDelay+period ，然後是initialDelay + 2 * period ，等等。如果任務的執行遇到異常，則後續的執行被抑制。否則，任務將僅通過取消或終止執行人終止。如果任務執行時間比其週期長，則後續執行可能會遲到，但不會同時執行。 scheduleWithFixedDelay() : 建立並執行在給定的初始延遲之後首先啟用的定期動作，隨後在一個執行的終止和下一個執行的開始之間給定的延遲。如果任務的執行遇到異常，則後續的執行被抑制。否則，任務將僅通過取消或終止執行終止。

五各種執行緒池的適用場景介紹

FixedThreadPool： 適用於為了滿足資源管理需求，而需要限制當前執行緒數量的應用場景。它適用於負載比較重的伺服器；

SingleThreadExecutor： 適用於需要保證順序地執行各個任務並且在任意時間點，不會有多個執行緒是活動的應用場景。

CachedThreadPool： 適用於執行很多的短期非同步任務的小程式，或者是負載較輕的伺服器；

ScheduledThreadPoolExecutor： 適用於需要多個後臺執行週期任務，同時為了滿足資源管理需求而需要限制後臺執行緒的數量的應用場景，

SingleThreadScheduledExecutor： 適用於需要單個後臺執行緒執行週期任務，同時保證順序地執行各個任務的應用場景。

六總結

本節只是簡單的介紹了一下使用執行緒池的好處，然後花了大量篇幅介紹Executor 框架。詳細介紹了Executor 框架中ThreadPoolExecutor和ScheduledThreadPoolExecutor，並且通過例項詳細講解了ScheduledThreadPoolExecutor的使用。對於FutureTask 只是粗略帶過，因為篇幅問題，並沒有深究它的原理，後面的文章會進行補充。這一篇文章只是大概帶大家過一下執行緒池的基本概覽，深入講解的地方不是很多，後續會通過原始碼深入研究其中比較重要的一些知識點。

最後，就是這兩週要考試了，會抽點時間出來簡單應付一下學校考試了。然後，就是寫這篇多執行緒的文章廢了好多好多時間。一直不知從何寫起。

參考

《Java併發程式設計的藝術》

Java Scheduler ScheduledExecutorService ScheduledThreadPoolExecutor Example

java.util.concurrent.ScheduledThreadPoolExecutor Example

ThreadPoolExecutor – Java Thread Pool Example

我是Snailclimb,一個以架構師為5年之內目標的小小白。歡迎關注我的微信公眾號:"Java面試通關手冊"（一個有溫度的微信公眾號，期待與你共同進步~~~堅持原創，分享美文，分享各種Java學習資源)

最後，就是使用阿里雲伺服器一段時間後，感覺阿里雲真的很不錯，就申請做了阿里雲大使，然後這是我的優惠券地址.

Java執行緒池(Executor)
2017-08-28
Java執行緒
執行緒池和Executor框架
2019-03-07
執行緒框架
Java多執行緒之Executor框架和手寫簡易的執行緒池
2019-01-08
Java執行緒框架
執行緒池 Executor
2018-12-24
執行緒
Java多執行緒——執行緒池
2017-03-12
Java執行緒
java多執行緒9：執行緒池
2021-12-20
Java執行緒
Java多執行緒18：執行緒池
2015-10-06
Java執行緒
Java多執行緒學習（3）執行緒同步與執行緒通訊
2018-10-15
Java執行緒
Java 執行緒 Executor 框架詳解與使用
2017-05-28
Java執行緒框架
多執行緒【執行緒池】
2021-02-20
執行緒
Java 執行緒池學習
2012-08-01
Java執行緒
Java多執行緒-執行緒池的使用
2021-01-17
Java執行緒
【Java】【多執行緒】執行緒池簡述
2018-04-17
Java執行緒
java多執行緒系列之執行緒池
2017-10-26
Java執行緒
奈學：Executor執行緒池的概述
2020-08-27
執行緒
多執行緒知識梳理(5) 執行緒池四部曲之 Executor 框架
2017-12-21
執行緒框架
java多執行緒與併發 - 執行緒池詳解
2018-03-13
Java執行緒
C#多執行緒學習(四) 多執行緒的自動管理(執行緒池)
2016-06-14
C#執行緒
C# 多執行緒學習(4) ：多執行緒的自動管理(執行緒池)
2015-10-09
C#執行緒
Java多執行緒學習——執行緒通訊
2019-01-19
Java執行緒
Java多執行緒學習（2）執行緒控制
2018-10-14
Java執行緒
Java多執行緒學習（1）建立執行緒與執行緒的生命週期
2018-10-10
Java執行緒
Android程式框架：執行緒與執行緒池
2019-02-27
Android框架執行緒
Java多執行緒學習（一）Java多執行緒入門
2018-03-21
Java執行緒
併發07--執行緒池及Executor框架
2020-06-28
執行緒框架
#大學#Java多執行緒學習02（執行緒同步）
2019-01-07
Java執行緒
Java多執行緒學習
2020-11-20
Java執行緒
Java執行緒池二：執行緒池原理
2020-12-20
Java執行緒
java多執行緒：執行緒池原理、阻塞佇列
2020-10-08
Java執行緒佇列
深入淺出Java多執行緒(十二)：執行緒池
2024-03-13
Java執行緒
執行緒池學習
2019-03-19
執行緒
Java 多執行緒基礎（八）執行緒讓步
2020-06-19
Java執行緒
kuangshenshuo-多執行緒-執行緒池
2020-10-21
執行緒
JavaThread多執行緒執行緒池
2017-11-08
Javathread執行緒
Java多執行緒——執行緒
2017-03-16
Java執行緒
【java學習】ThreadPoolExecutor 執行緒池
2018-09-28
Javathread執行緒
java--執行緒池--建立執行緒池的幾種方式與執行緒池操作詳解
2021-07-13
Java執行緒
Android多執行緒之執行緒池
2018-10-07
Android執行緒