摘要：對于指的是線程池中正在運行的線程。總結現在就可以知道，大致的線程池實現原理首先，各自存放線程和任務，其中，任務帶有阻塞。

文章主要來自：點這里 。這也是博主的博客，主要分享了自己接觸過的一些后端技術，有不對的地方希望可以提出。

我們都知道，所謂線程池，那么就是相當于有一個池子，線程就放在這個池子中進行重復利用，能夠減去了線程的創建和銷毀所帶來的代價。但是這樣并不能很好的解釋線程池的原理，下面從代碼的角度分析一下線程池的實現。

對于原理，在 Java 中，有幾個接口，類 值得我們關注：

Executor

ExecutorService

AbstractExecutorService

ThreadPoolExecutor

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

Executor 接口只有一個 方法，execute，并且需要 傳入一個 Runnable 類型的參數。那么它的作用自然是 具體的執行參數傳入的任務。

public interface ExecutorService extends Executor {

    void shutdown();

    List shutdownNow();

    boolean isShutdown();

     Future submit(Callable task);

     Future submit(Runnable task, T result);

    Future submit(Runnable task);
    
     List> invokeAll(Collection> tasks)
        throws InterruptedException;
    ......
}

ExecutorService 接口繼承了 Executor，并且提供了一些其他的方法，比如說：

shutdownNow ： 關閉線程池，返回放入了線程池，但是還沒開始執行的線程。

submit ： 執行的任務 允許擁有返回值。

invokeAll ： 運行把任務放進集合中，進行批量的執行，并且能有返回值

這三個方法也可以說是這個接口重點擴展的方法。

Ps：execute 和 submit 區別：

submit 有返回值，execute 沒有返回值。 所以說可以根據任務有無返回值選擇對應的方法。

submit 方便異常的處理。 如果任務可能會拋出異常，而且希望外面的調用者能夠感知這些異常，那么就需要調用 submit 方法，通過捕獲 Future.get 拋出的異常。

AbstractExecutorService 是一個抽象類，主要完成了 對 submit 方法，invokeAll 方法 的實現。 但是其實它的內部還是調用了 execute 方法，例如：

public Future submit(Runnable task) {
    if (task == null) throw new NullPointerException();
        RunnableFuture ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

ThreadPoolExecutor 繼承了 AbstractExecutorService，并且實現了最重要的 execute 方法，是我們主要需要研究的類。另外，整個線程池是如何實現的呢？

在該類中，有兩個成員變量 非常的重要：

private final HashSet workers = new HashSet();
private final BlockingQueue workQueue;

對于 workers 變量，主要存在了線程對象 Worker，Worker 實現了 Runnable 接口。而對于 workQueue 變量，主要存放了需要執行的任務。 這樣其實可以猜到， 整個線程池的實現原理應該是 workQueue 中不斷的取出需要執行的任務，放在 workers 中進行處理。

另外，當線程池中的線程用完了之后，多余的任務會等待，那么這個等待的過程是 怎么實現的呢？ 其實如果熟悉 BlockingQueue，那么就會馬上知道，是利用了 BlockingQueue 的take 方法進行處理。

下面具體代碼分析：

   public void execute(Runnable command) {
        ......
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        ......
    }

首先，這里需要先理解兩個概念。我們在創建線程池的時候，通常會指定兩個變量，一個是maximumPoolSize，另外一個是 corePoolSize。

對于 maximumPoolSize：指的是 線程池中最多允許有多少個線程。

對于 corePoolSize： 指的是線程池中正在運行的線程。

在 線程池中，有這樣的設定，我們加入一個任務進行執行，

如果現在線程池中正在運行的線程數量大于 corePoolSize 指定的值而 小于maximumPoolSize 指定的值，那么就會創建一個線程對該任務進行執行，一旦一個線程被創建運行。

如果線程池中的線程數量大于corePoolSize，那么這個任務執行完畢后，該線程會被回收；如果 小于corePoolSize，那么該線程即使空閑，也不會被回收。下個任務過來，那么就使用這個空閑線程。

對于上述代碼，首先有：

if (workerCountOf(c) < corePoolSize)

也就是說，判斷現在的線程數量是否小于corePoolSize，如果小于，那么就創建一個線程執行該任務，也就是執行

addWorker(command, true)

如果大于，那么就把該任務放進隊列當中，即

workQueue.offer(command)

那么，addWorker 是干什么的呢？

private boolean addWorker(Runnable firstTask, boolean core) {    
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                int rs = runStateOf(ctl.get());

                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
             ......
    }

在這里可以看到一些關鍵代碼，例如 w = new Worker(firstTask)， 以及 workers.add(w); 從這里 我們就可以看到，創建 線程對象 并且加入到 線程 隊列中。但是，我們現在還沒有看到具體是怎么執行任務的，繼續追蹤
w = new Worker(firstTask)，如下代碼：

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        ......
        
        final Thread thread;
        
        Runnable firstTask;
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
        public void run() {
            runWorker(this);
        }
        ......

對于 runWorker 方法：

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } 
                ......
    }

在這段代碼中，就有很多關鍵的信息，比如說，Runnable task = w.firstTask;如果為空，那么就 執行 task = getTask()，如果不為空，那么就 進行 task.run(); 調用其方法，這里也就是具體的執行的任務。

現在知道了是怎么樣執行具體的任務，那么假如任務的數量 大于 線程池的數量，那么是怎么實現等待的呢，這里就需要看到getTask() 的具體實現了，如下：

private Runnable getTask() {
        for (;;) {
           ......
            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

這里可以看到， 一個 for 死循環，以及

Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();

而 workQueue 是 BlockingQueue 類型，也就是帶有阻塞的功能。

這就是 線程如何等待執行的。

現在就可以知道，大致的線程池實現原理：

首先，各自存放線程和任務，其中，任務帶有阻塞。

private final HashSet workers = new HashSet();
private final BlockingQueue workQueue;

然后，在 execute 方法中 進行 addWorker(command，true)，也就是創建一個線程，把任務放進去執行；或者是直接把任務放入到任務隊列中。

接著 如果是 addWorker，那么就會 new Worker(task) -》調用其中 run() 方法，在Worker 的run() 方法中，調用 runWorker(this); 方法 -》在該方法中就會具體執行我們的任務 task.run(); 同時這個 runWorker方法相當于是個死循環，正常情況下就會一直取出 任務隊列中的任務來執行，這就保證了線程 不會銷毀。

所以，這也是為什么常說的線程池可以避免線程的頻繁創建和 銷毀帶來的性能消耗。

寫出來，說出來才知道對不對，知道不對才能改正，改正了才能成長。

在技術方面，希望大家眼里都容不得沙子。如果有不對的地方或者需要改進的地方希望可以指出，萬分感謝。