深入理解Java之執行緒池

海子發表於2016-04-06

在前面的文章中，我們使用執行緒的時候就去建立一個執行緒，這樣實現起來非常簡便，但是就會有一個問題：

如果併發的執行緒數量很多，並且每個執行緒都是執行一個時間很短的任務就結束了，這樣頻繁建立執行緒就會大大降低系統的效率，因為頻繁建立執行緒和銷燬執行緒需要時間。

那麼有沒有一種辦法使得執行緒可以複用，就是執行完一個任務，並不被銷燬，而是可以繼續執行其他的任務？

在Java中可以通過執行緒池來達到這樣的效果。今天我們就來詳細講解一下Java的執行緒池，首先我們從最核心的ThreadPoolExecutor類中的方法講起，然後再講述它的實現原理，接著給出了它的使用示例，最後討論了一下如何合理配置執行緒池的大小。

以下是本文的目錄大綱：

一.Java中的ThreadPoolExecutor類
二.深入剖析執行緒池實現原理
三.使用示例
四.如何合理配置執行緒池的大小

若有不正之處請多多諒解，並歡迎批評指正。

一.Java中的ThreadPoolExecutor類

java.uitl.concurrent.ThreadPoolExecutor類是執行緒池中最核心的一個類，因此如果要透徹地瞭解Java中的執行緒池，必須先了解這個類。下面我們來看一下ThreadPoolExecutor類的具體實現原始碼。

在ThreadPoolExecutor類中提供了四個構造方法：

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);

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

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}

從上面的程式碼可以得知，ThreadPoolExecutor繼承了AbstractExecutorService類，並提供了四個構造器，事實上，通過觀察每個構造器的原始碼具體實現，發現前面三個構造器都是呼叫的第四個構造器進行的初始化工作。

下面解釋下一下構造器中各個引數的含義：

corePoolSize：核心池的大小，這個引數跟後面講述的執行緒池的實現原理有非常大的關係。在建立了執行緒池後，預設情況下，執行緒池中並沒有任何執行緒，而是等待有任務到來才建立執行緒去執行任務，除非呼叫了prestartAllCoreThreads()或者prestartCoreThread()方法，從這2個方法的名字就可以看出，是預建立執行緒的意思，即在沒有任務到來之前就建立corePoolSize個執行緒或者一個執行緒。預設情況下，在建立了執行緒池後，執行緒池中的執行緒數為0，當有任務來之後，就會建立一個執行緒去執行任務，當執行緒池中的執行緒數目達到corePoolSize後，就會把到達的任務放到快取佇列當中；
maximumPoolSize：執行緒池最大執行緒數，這個引數也是一個非常重要的引數，它表示線上程池中最多能建立多少個執行緒；
keepAliveTime：表示執行緒沒有任務執行時最多保持多久時間會終止。預設情況下，只有當執行緒池中的執行緒數大於corePoolSize時，keepAliveTime才會起作用，直到執行緒池中的執行緒數不大於corePoolSize，即當執行緒池中的執行緒數大於corePoolSize時，如果一個執行緒空閒的時間達到keepAliveTime，則會終止，直到執行緒池中的執行緒數不超過corePoolSize。但是如果呼叫了allowCoreThreadTimeOut(boolean)方法，線上程池中的執行緒數不大於corePoolSize時，keepAliveTime引數也會起作用，直到執行緒池中的執行緒數為0；
unit：引數keepAliveTime的時間單位，有7種取值，在TimeUnit類中有7種靜態屬性：

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小時
TimeUnit.MINUTES;           //分鐘
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //納秒

workQueue：一個阻塞佇列，用來儲存等待執行的任務，這個引數的選擇也很重要，會對執行緒池的執行過程產生重大影響，一般來說，這裡的阻塞佇列有以下幾種選擇：

ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

ArrayBlockingQueue和PriorityBlockingQueue使用較少，一般使用LinkedBlockingQueue和Synchronous。執行緒池的排隊策略與BlockingQueue有關。

threadFactory：執行緒工廠，主要用來建立執行緒；
handler：表示當拒絕處理任務時的策略，有以下四種取值：

ThreadPoolExecutor.AbortPolicy:丟棄任務並丟擲RejectedExecutionException異常。 
ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不丟擲異常。 
ThreadPoolExecutor.DiscardOldestPolicy：丟棄佇列最前面的任務，然後重新嘗試執行任務（重複此過程）
ThreadPoolExecutor.CallerRunsPolicy：由呼叫執行緒處理該任務

具體引數的配置與執行緒池的關係將在下一節講述。

從上面給出的ThreadPoolExecutor類的程式碼可以知道，ThreadPoolExecutor繼承了AbstractExecutorService，我們來看一下AbstractExecutorService的實現：

public abstract class AbstractExecutorService implements ExecutorService {

    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { };
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { };
    public Future<?> submit(Runnable task) {};
    public <T> Future<T> submit(Runnable task, T result) { };
    public <T> Future<T> submit(Callable<T> task) { };
    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                            boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {
    };
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException {
    };
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                           long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
    };
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException {
    };
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                         long timeout, TimeUnit unit)
        throws InterruptedException {
    };
}

AbstractExecutorService是一個抽象類，它實現了ExecutorService介面。

我們接著看ExecutorService介面的實現：

public interface ExecutorService extends Executor {

    void shutdown();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    <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;
}

而ExecutorService又是繼承了Executor介面，我們看一下Executor介面的實現：

public interface Executor {
    void execute(Runnable command);
}

到這裡，大家應該明白了ThreadPoolExecutor、AbstractExecutorService、ExecutorService和Executor幾個之間的關係了。

Executor是一個頂層介面，在它裡面只宣告瞭一個方法execute(Runnable)，返回值為void，引數為Runnable型別，從字面意思可以理解，就是用來執行傳進去的任務的；

然後ExecutorService介面繼承了Executor介面，並宣告瞭一些方法：submit、invokeAll、invokeAny以及shutDown等；

抽象類AbstractExecutorService實現了ExecutorService介面，基本實現了ExecutorService中宣告的所有方法；

然後ThreadPoolExecutor繼承了類AbstractExecutorService。

在ThreadPoolExecutor類中有幾個非常重要的方法：

execute()
submit()
shutdown()
shutdownNow()

execute()方法實際上是Executor中宣告的方法，在ThreadPoolExecutor進行了具體的實現，這個方法是ThreadPoolExecutor的核心方法，通過這個方法可以向執行緒池提交一個任務，交由執行緒池去執行。

submit()方法是在ExecutorService中宣告的方法，在AbstractExecutorService就已經有了具體的實現，在ThreadPoolExecutor中並沒有對其進行重寫，這個方法也是用來向執行緒池提交任務的，但是它和execute()方法不同，它能夠返回任務執行的結果，去看submit()方法的實現，會發現它實際上還是呼叫的execute()方法，只不過它利用了Future來獲取任務執行結果（Future相關內容將在下一篇講述）。

shutdown()和shutdownNow()是用來關閉執行緒池的。

還有很多其他的方法：

比如：getQueue() 、getPoolSize() 、getActiveCount()、getCompletedTaskCount()等獲取與執行緒池相關屬性的方法，有興趣的朋友可以自行查閱API。

二.深入剖析執行緒池實現原理

在上一節我們從巨集觀上介紹了ThreadPoolExecutor，下面我們來深入解析一下執行緒池的具體實現原理，將從下面幾個方面講解：

1.執行緒池狀態
2.任務的執行
3.執行緒池中的執行緒初始化
4.任務快取佇列及排隊策略
5.任務拒絕策略
6.執行緒池的關閉
7.執行緒池容量的動態調整

1.執行緒池狀態

在ThreadPoolExecutor中定義了一個Volatile變數，另外定義了幾個static final變數表示執行緒池的各個狀態：

volatile int runState;
static final int RUNNING    = 0;
static final int SHUTDOWN   = 1;
static final int STOP       = 2;
static final int TERMINATED = 3;

runState表示當前執行緒池的狀態，它是一個volatile變數用來保證執行緒之間的可見性；

下面的幾個static final變數表示runState可能的幾個取值。

當建立執行緒池後，初始時，執行緒池處於RUNNING狀態；

如果呼叫了shutdown()方法，則執行緒池處於SHUTDOWN狀態，此時執行緒池不能夠接受新的任務，它會等待所有任務執行完畢；

如果呼叫了shutdownNow()方法，則執行緒池處於STOP狀態，此時執行緒池不能接受新的任務，並且會去嘗試終止正在執行的任務；

當執行緒池處於SHUTDOWN或STOP狀態，並且所有工作執行緒已經銷燬，任務快取佇列已經清空或執行結束後，執行緒池被設定為TERMINATED狀態。

2.任務的執行

在瞭解將任務提交給執行緒池到任務執行完畢整個過程之前，我們先來看一下ThreadPoolExecutor類中其他的一些比較重要成員變數：

private final BlockingQueue<Runnable> workQueue;              //任務快取佇列，用來存放等待執行的任務
private final ReentrantLock mainLock = new ReentrantLock();   //執行緒池的主要狀態鎖，對執行緒池狀態（比如執行緒池大小
                                                              //、runState等）的改變都要使用這個鎖
private final HashSet<Worker> workers = new HashSet<Worker>();  //用來存放工作集

private volatile long  keepAliveTime;    //執行緒存活時間   
private volatile boolean allowCoreThreadTimeOut;   //是否允許為核心執行緒設定存活時間
private volatile int   corePoolSize;     //核心池的大小（即執行緒池中的執行緒數目大於這個引數時，提交的任務會被放進任務快取佇列）
private volatile int   maximumPoolSize;   //執行緒池最大能容忍的執行緒數

private volatile int   poolSize;       //執行緒池中當前的執行緒數

private volatile RejectedExecutionHandler handler; //任務拒絕策略

private volatile ThreadFactory threadFactory;   //執行緒工廠，用來建立執行緒

private int largestPoolSize;   //用來記錄執行緒池中曾經出現過的最大執行緒數

private long completedTaskCount;   //用來記錄已經執行完畢的任務個數

每個變數的作用都已經標明出來了，這裡要重點解釋一下corePoolSize、maximumPoolSize、largestPoolSize三個變數。

corePoolSize在很多地方被翻譯成核心池大小，其實我的理解這個就是執行緒池的大小。舉個簡單的例子：

假如有一個工廠，工廠裡面有10個工人，每個工人同時只能做一件任務。

因此只要當10個工人中有工人是空閒的，來了任務就分配給空閒的工人做；

當10個工人都有任務在做時，如果還來了任務，就把任務進行排隊等待；

如果說新任務數目增長的速度遠遠大於工人做任務的速度，那麼此時工廠主管可能會想補救措施，比如重新招4個臨時工人進來；

然後就將任務也分配給這4個臨時工人做；

如果說著14個工人做任務的速度還是不夠，此時工廠主管可能就要考慮不再接收新的任務或者拋棄前面的一些任務了。

當這14個工人當中有人空閒時，而新任務增長的速度又比較緩慢，工廠主管可能就考慮辭掉4個臨時工了，只保持原來的10個工人，畢竟請額外的工人是要花錢的。

這個例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。

也就是說corePoolSize就是執行緒池大小，maximumPoolSize在我看來是執行緒池的一種補救措施，即任務量突然過大時的一種補救措施。

不過為了方便理解，在本文後面還是將corePoolSize翻譯成核心池大小。

largestPoolSize只是一個用來起記錄作用的變數，用來記錄執行緒池中曾經有過的最大執行緒數目，跟執行緒池的容量沒有任何關係。

下面我們進入正題，看一下任務從提交到最終執行完畢經歷了哪些過程。

在ThreadPoolExecutor類中，最核心的任務提交方法是execute()方法，雖然通過submit也可以提交任務，但是實際上submit方法裡面最終呼叫的還是execute()方法，所以我們只需要研究execute()方法的實現原理即可：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
        if (runState == RUNNING && workQueue.offer(command)) {
            if (runState != RUNNING || poolSize == 0)
                ensureQueuedTaskHandled(command);
        }
        else if (!addIfUnderMaximumPoolSize(command))
            reject(command); // is shutdown or saturated
    }
}

上面的程式碼可能看起來不是那麼容易理解，下面我們一句一句解釋：

首先，判斷提交的任務command是否為null，若是null，則丟擲空指標異常；

接著是這句，這句要好好理解一下：

if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))

由於是或條件運算子，所以先計算前半部分的值，如果執行緒池中當前執行緒數不小於核心池大小，那麼就會直接進入下面的if語句塊了。

如果執行緒池中當前執行緒數小於核心池大小，則接著執行後半部分，也就是執行：

addIfUnderCorePoolSize(command)

如果執行完addIfUnderCorePoolSize這個方法返回false，則繼續執行下面的if語句塊，否則整個方法就直接執行完畢了。

如果執行完addIfUnderCorePoolSize這個方法返回false，然後接著判斷：

if (runState == RUNNING && workQueue.offer(command))

如果當前執行緒池處於RUNNING狀態，則將任務放入任務快取佇列；如果當前執行緒池不處於RUNNING狀態或者任務放入快取佇列失敗，則執行：

addIfUnderMaximumPoolSize(command)

如果執行addIfUnderMaximumPoolSize方法失敗，則執行reject()方法進行任務拒絕處理。

回到前面：

if (runState == RUNNING && workQueue.offer(command))

這句的執行，如果說當前執行緒池處於RUNNING狀態且將任務放入任務快取佇列成功，則繼續進行判斷：

if (runState != RUNNING || poolSize == 0)

這句判斷是為了防止在將此任務新增進任務快取佇列的同時其他執行緒突然呼叫shutdown或者shutdownNow方法關閉了執行緒池的一種應急措施。如果是這樣就執行：

ensureQueuedTaskHandled(command)

進行應急處理，從名字可以看出是保證新增到任務快取佇列中的任務得到處理。

我們接著看2個關鍵方法的實現：addIfUnderCorePoolSize和addIfUnderMaximumPoolSize：

private boolean addIfUnderCorePoolSize(Runnable firstTask) {
    Thread t = null;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (poolSize < corePoolSize && runState == RUNNING)
            t = addThread(firstTask);        //建立執行緒去執行firstTask任務   
        } finally {
        mainLock.unlock();
    }
    if (t == null)
        return false;
    t.start();
    return true;
}

這個是addIfUnderCorePoolSize方法的具體實現，從名字可以看出它的意圖就是當低於核心吃大小時執行的方法。下面看其具體實現，首先獲取到鎖，因為這地方涉及到執行緒池狀態的變化，先通過if語句判斷當前執行緒池中的執行緒數目是否小於核心池大小，有朋友也許會有疑問：前面在execute()方法中不是已經判斷過了嗎，只有執行緒池當前執行緒數目小於核心池大小才會執行addIfUnderCorePoolSize方法的，為何這地方還要繼續判斷？原因很簡單，前面的判斷過程中並沒有加鎖，因此可能在execute方法判斷的時候poolSize小於corePoolSize，而判斷完之後，在其他執行緒中又向執行緒池提交了任務，就可能導致poolSize不小於corePoolSize了，所以需要在這個地方繼續判斷。然後接著判斷執行緒池的狀態是否為RUNNING，原因也很簡單，因為有可能在其他執行緒中呼叫了shutdown或者shutdownNow方法。然後就是執行

t = addThread(firstTask);

這個方法也非常關鍵，傳進去的引數為提交的任務，返回值為Thread型別。然後接著在下面判斷t是否為空，為空則表明建立執行緒失敗（即poolSize>=corePoolSize或者runState不等於RUNNING），否則呼叫t.start()方法啟動執行緒。

我們來看一下addThread方法的實現：

private Thread addThread(Runnable firstTask) {
    Worker w = new Worker(firstTask);
    Thread t = threadFactory.newThread(w);  //建立一個執行緒，執行任務   
    if (t != null) {
        w.thread = t;            //將建立的執行緒的引用賦值為w的成員變數       
        workers.add(w);
        int nt = ++poolSize;     //當前執行緒數加1       
        if (nt > largestPoolSize)
            largestPoolSize = nt;
    }
    return t;
}

在addThread方法中，首先用提交的任務建立了一個Worker物件，然後呼叫執行緒工廠threadFactory建立了一個新的執行緒t，然後將執行緒t的引用賦值給了Worker物件的成員變數thread，接著通過workers.add(w)將Worker物件新增到工作集當中。

下面我們看一下Worker類的實現：

private final class Worker implements Runnable {
    private final ReentrantLock runLock = new ReentrantLock();
    private Runnable firstTask;
    volatile long completedTasks;
    Thread thread;
    Worker(Runnable firstTask) {
        this.firstTask = firstTask;
    }
    boolean isActive() {
        return runLock.isLocked();
    }
    void interruptIfIdle() {
        final ReentrantLock runLock = this.runLock;
        if (runLock.tryLock()) {
            try {
        if (thread != Thread.currentThread())
        thread.interrupt();
            } finally {
                runLock.unlock();
            }
        }
    }
    void interruptNow() {
        thread.interrupt();
    }

    private void runTask(Runnable task) {
        final ReentrantLock runLock = this.runLock;
        runLock.lock();
        try {
            if (runState < STOP &&
                Thread.interrupted() &&
                runState >= STOP)
            boolean ran = false;
            beforeExecute(thread, task);   //beforeExecute方法是ThreadPoolExecutor類的一個方法，沒有具體實現，使用者可以根據
            //自己需要過載這個方法和後面的afterExecute方法來進行一些統計資訊，比如某個任務的執行時間等           
            try {
                task.run();
                ran = true;
                afterExecute(task, null);
                ++completedTasks;
            } catch (RuntimeException ex) {
                if (!ran)
                    afterExecute(task, ex);
                throw ex;
            }
        } finally {
            runLock.unlock();
        }
    }

    public void run() {
        try {
            Runnable task = firstTask;
            firstTask = null;
            while (task != null || (task = getTask()) != null) {
                runTask(task);
                task = null;
            }
        } finally {
            workerDone(this);   //當任務佇列中沒有任務時，進行清理工作       
        }
    }
}

它實際上實現了Runnable介面，因此上面的Thread t = threadFactory.newThread(w);效果跟下面這句的效果基本一樣：

Thread t = new Thread(w);

相當於傳進去了一個Runnable任務，線上程t中執行這個Runnable。

既然Worker實現了Runnable介面，那麼自然最核心的方法便是run()方法了：

public void run() {
    try {
        Runnable task = firstTask;
        firstTask = null;
        while (task != null || (task = getTask()) != null) {
            runTask(task);
            task = null;
        }
    } finally {
        workerDone(this);
    }
}

從run方法的實現可以看出，它首先執行的是通過構造器傳進來的任務firstTask，在呼叫runTask()執行完firstTask之後，在while迴圈裡面不斷通過getTask()去取新的任務來執行，那麼去哪裡取呢？自然是從任務快取佇列裡面去取，getTask是ThreadPoolExecutor類中的方法，並不是Worker類中的方法，下面是getTask方法的實現：

Runnable getTask() {
    for (;;) {
        try {
            int state = runState;
            if (state > SHUTDOWN)
                return null;
            Runnable r;
            if (state == SHUTDOWN)  // Help drain queue
                r = workQueue.poll();
            else if (poolSize > corePoolSize || allowCoreThreadTimeOut) //如果執行緒數大於核心池大小或者允許為核心池執行緒設定空閒時間，
                //則通過poll取任務，若等待一定的時間取不到任務，則返回null
                r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
            else
                r = workQueue.take();
            if (r != null)
                return r;
            if (workerCanExit()) {    //如果沒取到任務，即r為null，則判斷當前的worker是否可以退出
                if (runState >= SHUTDOWN) // Wake up others
                    interruptIdleWorkers();   //中斷處於空閒狀態的worker
                return null;
            }
            // Else retry
        } catch (InterruptedException ie) {
            // On interruption, re-check runState
        }
    }
}

在getTask中，先判斷當前執行緒池狀態，如果runState大於SHUTDOWN（即為STOP或者TERMINATED），則直接返回null。

如果runState為SHUTDOWN或者RUNNING，則從任務快取佇列取任務。

如果當前執行緒池的執行緒數大於核心池大小corePoolSize或者允許為核心池中的執行緒設定空閒存活時間，則呼叫poll(time,timeUnit)來取任務，這個方法會等待一定的時間，如果取不到任務就返回null。

然後判斷取到的任務r是否為null，為null則通過呼叫workerCanExit()方法來判斷當前worker是否可以退出，我們看一下workerCanExit()的實現：

private boolean workerCanExit() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    boolean canExit;
    //如果runState大於等於STOP，或者任務快取佇列為空了
    //或者  允許為核心池執行緒設定空閒存活時間並且執行緒池中的執行緒數目大於1
    try {
        canExit = runState >= STOP ||
            workQueue.isEmpty() ||
            (allowCoreThreadTimeOut &&
             poolSize > Math.max(1, corePoolSize));
    } finally {
        mainLock.unlock();
    }
    return canExit;
}

也就是說如果執行緒池處於STOP狀態、或者任務佇列已為空或者允許為核心池執行緒設定空閒存活時間並且執行緒數大於1時，允許worker退出。如果允許worker退出，則呼叫interruptIdleWorkers()中斷處於空閒狀態的worker，我們看一下interruptIdleWorkers()的實現：

void interruptIdleWorkers() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers)  //實際上呼叫的是worker的interruptIfIdle()方法
            w.interruptIfIdle();
    } finally {
        mainLock.unlock();
    }
}

從實現可以看出，它實際上呼叫的是worker的interruptIfIdle()方法，在worker的interruptIfIdle()方法中：

void interruptIfIdle() {
    final ReentrantLock runLock = this.runLock;
    if (runLock.tryLock()) {    //注意這裡，是呼叫tryLock()來獲取鎖的，因為如果當前worker正在執行任務，鎖已經被獲取了，是無法獲取到鎖的
                                //如果成功獲取了鎖，說明當前worker處於空閒狀態
        try {
    if (thread != Thread.currentThread())  
    thread.interrupt();
        } finally {
            runLock.unlock();
        }
    }
}

這裡有一個非常巧妙的設計方式，假如我們來設計執行緒池，可能會有一個任務分派執行緒，當發現有執行緒空閒時，就從任務快取佇列中取一個任務交給空閒執行緒執行。但是在這裡，並沒有採用這樣的方式，因為這樣會要額外地對任務分派執行緒進行管理，無形地會增加難度和複雜度，這裡直接讓執行完任務的執行緒去任務快取佇列裡面取任務來執行。

我們再看addIfUnderMaximumPoolSize方法的實現，這個方法的實現思想和addIfUnderCorePoolSize方法的實現思想非常相似，唯一的區別在於addIfUnderMaximumPoolSize方法是線上程池中的執行緒數達到了核心池大小並且往任務佇列中新增任務失敗的情況下執行的：

private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
    Thread t = null;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (poolSize < maximumPoolSize && runState == RUNNING)
            t = addThread(firstTask);
    } finally {
        mainLock.unlock();
    }
    if (t == null)
        return false;
    t.start();
    return true;
}

看到沒有，其實它和addIfUnderCorePoolSize方法的實現基本一模一樣，只是if語句判斷條件中的poolSize < maximumPoolSize不同而已。

到這裡，大部分朋友應該對任務提交給執行緒池之後到被執行的整個過程有了一個基本的瞭解，下面總結一下：

1）首先，要清楚corePoolSize和maximumPoolSize的含義；

2）其次，要知道Worker是用來起到什麼作用的；

3）要知道任務提交給執行緒池之後的處理策略，這裡總結一下主要有4點：

如果當前執行緒池中的執行緒數目小於corePoolSize，則每來一個任務，就會建立一個執行緒去執行這個任務；
如果當前執行緒池中的執行緒數目>=corePoolSize，則每來一個任務，會嘗試將其新增到任務快取佇列當中，若新增成功，則該任務會等待空閒執行緒將其取出去執行；若新增失敗（一般來說是任務快取佇列已滿），則會嘗試建立新的執行緒去執行這個任務；
如果當前執行緒池中的執行緒數目達到maximumPoolSize，則會採取任務拒絕策略進行處理；
如果執行緒池中的執行緒數量大於 corePoolSize時，如果某執行緒空閒時間超過keepAliveTime，執行緒將被終止，直至執行緒池中的執行緒數目不大於corePoolSize；如果允許為核心池中的執行緒設定存活時間，那麼核心池中的執行緒空閒時間超過keepAliveTime，執行緒也會被終止。

3.執行緒池中的執行緒初始化

預設情況下，建立執行緒池之後，執行緒池中是沒有執行緒的，需要提交任務之後才會建立執行緒。

在實際中如果需要執行緒池建立之後立即建立執行緒，可以通過以下兩個方法辦到：

prestartCoreThread()：初始化一個核心執行緒；
prestartAllCoreThreads()：初始化所有核心執行緒

下面是這2個方法的實現：

public boolean prestartCoreThread() {
    return addIfUnderCorePoolSize(null); //注意傳進去的引數是null
}

public int prestartAllCoreThreads() {
    int n = 0;
    while (addIfUnderCorePoolSize(null))//注意傳進去的引數是null
        ++n;
    return n;
}

注意上面傳進去的引數是null，根據第2小節的分析可知如果傳進去的引數為null，則最後執行執行緒會阻塞在getTask方法中的

r = workQueue.take();

即等待任務佇列中有任務。

4.任務快取佇列及排隊策略

在前面我們多次提到了任務快取佇列，即workQueue，它用來存放等待執行的任務。

workQueue的型別為BlockingQueue<Runnable>，通常可以取下面三種型別：

1）ArrayBlockingQueue：基於陣列的先進先出佇列，此佇列建立時必須指定大小；

2）LinkedBlockingQueue：基於連結串列的先進先出佇列，如果建立時沒有指定此佇列大小，則預設為Integer.MAX_VALUE；

3）synchronousQueue：這個佇列比較特殊，它不會儲存提交的任務，而是將直接新建一個執行緒來執行新來的任務。

5.任務拒絕策略

當執行緒池的任務快取佇列已滿並且執行緒池中的執行緒數目達到maximumPoolSize，如果還有任務到來就會採取任務拒絕策略，通常有以下四種策略：

ThreadPoolExecutor.AbortPolicy:丟棄任務並丟擲RejectedExecutionException異常。
ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不丟擲異常。
ThreadPoolExecutor.DiscardOldestPolicy：丟棄佇列最前面的任務，然後重新嘗試執行任務（重複此過程）
ThreadPoolExecutor.CallerRunsPolicy：由呼叫執行緒處理該任務

6.執行緒池的關閉

ThreadPoolExecutor提供了兩個方法，用於執行緒池的關閉，分別是shutdown()和shutdownNow()，其中：

shutdown()：不會立即終止執行緒池，而是要等所有任務快取佇列中的任務都執行完後才終止，但再也不會接受新的任務
shutdownNow()：立即終止執行緒池，並嘗試打斷正在執行的任務，並且清空任務快取佇列，返回尚未執行的任務

7.執行緒池容量的動態調整

ThreadPoolExecutor提供了動態調整執行緒池容量大小的方法：setCorePoolSize()和setMaximumPoolSize()，

setCorePoolSize：設定核心池大小
setMaximumPoolSize：設定執行緒池最大能建立的執行緒數目大小

當上述引數從小變大時，ThreadPoolExecutor進行執行緒賦值，還可能立即建立新的執行緒來執行任務。

三.使用示例

前面我們討論了關於執行緒池的實現原理，這一節我們來看一下它的具體使用：

public class Test {
     public static void main(String[] args) {   
         ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                 new ArrayBlockingQueue<Runnable>(5));

         for(int i=0;i<15;i++){
             MyTask myTask = new MyTask(i);
             executor.execute(myTask);
             System.out.println("執行緒池中執行緒數目："+executor.getPoolSize()+"，佇列中等待執行的任務數目："+
             executor.getQueue().size()+"，已執行玩別的任務數目："+executor.getCompletedTaskCount());
         }
         executor.shutdown();
     }
}

class MyTask implements Runnable {
    private int taskNum;

    public MyTask(int num) {
        this.taskNum = num;
    }

    @Override
    public void run() {
        System.out.println("正在執行task "+taskNum);
        try {
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task "+taskNum+"執行完畢");
    }
}

執行結果：

正在執行task 0
執行緒池中執行緒數目：1，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
執行緒池中執行緒數目：2，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 1
執行緒池中執行緒數目：3，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 2
執行緒池中執行緒數目：4，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 3
執行緒池中執行緒數目：5，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 4
執行緒池中執行緒數目：5，佇列中等待執行的任務數目：1，已執行玩別的任務數目：0
執行緒池中執行緒數目：5，佇列中等待執行的任務數目：2，已執行玩別的任務數目：0
執行緒池中執行緒數目：5，佇列中等待執行的任務數目：3，已執行玩別的任務數目：0
執行緒池中執行緒數目：5，佇列中等待執行的任務數目：4，已執行玩別的任務數目：0
執行緒池中執行緒數目：5，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
執行緒池中執行緒數目：6，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 10
執行緒池中執行緒數目：7，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 11
執行緒池中執行緒數目：8，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 12
執行緒池中執行緒數目：9，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 13
執行緒池中執行緒數目：10，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 14
task 3執行完畢
task 0執行完畢
task 2執行完畢
task 1執行完畢
正在執行task 8
正在執行task 7
正在執行task 6
正在執行task 5
task 4執行完畢
task 10執行完畢
task 11執行完畢
task 13執行完畢
task 12執行完畢
正在執行task 9
task 14執行完畢
task 8執行完畢
task 5執行完畢
task 7執行完畢
task 6執行完畢
task 9執行完畢

從執行結果可以看出，當執行緒池中執行緒的數目大於5時，便將任務放入任務快取佇列裡面，當任務快取佇列滿了之後，便建立新的執行緒。如果上面程式中，將for迴圈中改成執行20個任務，就會丟擲任務拒絕異常了。

不過在java doc中，並不提倡我們直接使用ThreadPoolExecutor，而是使用Executors類中提供的幾個靜態方法來建立執行緒池：

Executors.newCachedThreadPool();        //建立一個緩衝池，緩衝池容量大小為Integer.MAX_VALUE
Executors.newSingleThreadExecutor();   //建立容量為1的緩衝池
Executors.newFixedThreadPool(int);    //建立固定容量大小的緩衝池

下面是這三個靜態方法的具體實現：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

從它們的具體實現來看，它們實際上也是呼叫了ThreadPoolExecutor，只不過引數都已配置好了。

newFixedThreadPool建立的執行緒池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue；

newSingleThreadExecutor將corePoolSize和maximumPoolSize都設定為1，也使用的LinkedBlockingQueue；

newCachedThreadPool將corePoolSize設定為0，將maximumPoolSize設定為Integer.MAX_VALUE，使用的SynchronousQueue，也就是說來了任務就建立執行緒執行，當執行緒空閒超過60秒，就銷燬執行緒。

實際中，如果Executors提供的三個靜態方法能滿足要求，就儘量使用它提供的三個方法，因為自己去手動配置ThreadPoolExecutor的引數有點麻煩，要根據實際任務的型別和數量來進行配置。

另外，如果ThreadPoolExecutor達不到要求，可以自己繼承ThreadPoolExecutor類進行重寫。

四.如何合理配置執行緒池的大小

本節來討論一個比較重要的話題：如何合理配置執行緒池大小，僅供參考。

一般需要根據任務的型別來配置執行緒池大小：

如果是CPU密集型任務，就需要儘量壓榨CPU，參考值可以設為 N_CPU+1

如果是IO密集型任務，參考值可以設定為2*N_CPU

當然，這只是一個參考值，具體的設定還需要根據實際情況進行調整，比如可以先將執行緒池大小設定為參考值，再觀察任務執行情況和系統負載、資源利用率來進行適當調整。

參考資料：

http://ifeve.com/java-threadpool/
http://blog.163.com/among_1985/blog/static/275005232012618849266/
http://developer.51cto.com/art/201203/321885.htm
http://blog.csdn.net/java2000_wl/article/details/22097059
http://blog.csdn.net/cutesource/article/details/6061229
http://blog.csdn.net/xieyuooo/article/details/8718741
《JDK API 1.6》

深入Java原始碼理解執行緒池原理
2019-03-01
Java原始碼執行緒
Android執行緒篇(四)深入理解Java執行緒池（二）
2017-12-21
Android執行緒Java
Android執行緒篇(三)深入理解Java執行緒池（一）
2017-12-21
Android執行緒Java
Java核心（二）深入理解執行緒池ThreadPool
2018-11-19
Java執行緒thread
深入淺出 Java 執行緒池
2016-08-19
Java執行緒
Java併發程式設計——深入理解執行緒池
2020-09-25
Java程式設計執行緒
深入淺出Java多執行緒(十二)：執行緒池
2024-03-13
Java執行緒
java多執行緒系列之執行緒池
2017-10-26
Java執行緒
深入理解執行緒池原理篇
2019-03-13
執行緒
死磕 java執行緒系列之執行緒池深入解析——普通任務執行流程
2019-11-03
Java執行緒
深入理解Java多執行緒與併發框（第⑪篇）——執行緒池引數
2020-03-31
Java執行緒
死磕 java執行緒系列之執行緒池深入解析——未來任務執行流程
2019-11-04
Java執行緒
Java8執行緒池理解（二）
2017-09-11
Java執行緒
深入理解JVM（③）執行緒與Java的執行緒
2020-07-11
JVM執行緒Java
Java執行緒池二：執行緒池原理
2020-12-20
Java執行緒
深入淺出Java執行緒池：使用篇
2021-01-31
Java執行緒
深入淺出Java執行緒池ThreadPoolExecutor
2018-03-16
Java執行緒thread
Java執行緒池之ThreadPoolExecutor
2018-12-19
Java執行緒thread
執行緒和執行緒池的理解與java簡單例子
2016-11-23
執行緒Java單例
Java多執行緒——執行緒池
2017-03-12
Java執行緒
Java執行緒池
2020-09-23
Java執行緒
java 執行緒池
2018-06-22
Java執行緒
深入淺出Java執行緒池：原始碼篇
2021-02-06
Java執行緒原始碼
Java同步之執行緒池詳解
2021-09-02
Java執行緒
java執行緒池趣味事：這不是執行緒池
2021-02-20
Java執行緒
Java併發之執行緒池系列 (1) 讓多執行緒不再坑爹的執行緒池
2019-03-31
Java執行緒
java多執行緒9：執行緒池
2021-12-20
Java執行緒
Java多執行緒18：執行緒池
2015-10-06
Java執行緒
漫畫理解執行緒池
2018-01-15
執行緒
二. 執行緒管理之執行緒池
2019-01-08
執行緒
Java併發之執行緒池系列 (2) 使用ThreadPoolExecutor構造執行緒池
2019-04-01
Java執行緒thread
深入學習執行緒池原理
2019-05-20
執行緒
搞懂Java執行緒池
2019-04-20
Java執行緒
Java Executors(執行緒池)
2017-03-16
Java執行緒
Java執行緒池(Executor)
2017-08-28
Java執行緒
Java多執行緒-執行緒池的使用
2021-01-17
Java執行緒
Java執行緒池一：執行緒基礎
2020-11-29
Java執行緒
【Java】【多執行緒】執行緒池簡述
2018-04-17
Java執行緒