摘要：對(duì)于指的是線程池中正在運(yùn)行的線程。總結(jié)現(xiàn)在就可以知道，大致的線程池實(shí)現(xiàn)原理首先，各自存放線程和任務(wù)，其中，任務(wù)帶有阻塞。

文章主要來(lái)自：點(diǎn)這里 。這也是博主的博客，主要分享了自己接觸過(guò)的一些后端技術(shù)，有不對(duì)的地方希望可以提出。

我們都知道，所謂線程池，那么就是相當(dāng)于有一個(gè)池子，線程就放在這個(gè)池子中進(jìn)行重復(fù)利用，能夠減去了線程的創(chuàng)建和銷毀所帶來(lái)的代價(jià)。但是這樣并不能很好的解釋線程池的原理，下面從代碼的角度分析一下線程池的實(shí)現(xiàn)。

對(duì)于原理，在 Java 中，有幾個(gè)接口，類 值得我們關(guān)注：

Executor

ExecutorService

AbstractExecutorService

ThreadPoolExecutor

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

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

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，并且提供了一些其他的方法，比如說(shuō)：

shutdownNow ： 關(guān)閉線程池，返回放入了線程池，但是還沒開始執(zhí)行的線程。

submit ： 執(zhí)行的任務(wù) 允許擁有返回值。

invokeAll ： 運(yùn)行把任務(wù)放進(jìn)集合中，進(jìn)行批量的執(zhí)行，并且能有返回值

這三個(gè)方法也可以說(shuō)是這個(gè)接口重點(diǎn)擴(kuò)展的方法。

Ps：execute 和 submit 區(qū)別：

submit 有返回值，execute 沒有返回值。 所以說(shuō)可以根據(jù)任務(wù)有無(wú)返回值選擇對(duì)應(yīng)的方法。

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

AbstractExecutorService 是一個(gè)抽象類，主要完成了 對(duì) submit 方法，invokeAll 方法 的實(shí)現(xiàn)。 但是其實(shí)它的內(nèi)部還是調(diào)用了 execute 方法，例如：

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

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

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

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

對(duì)于 workers 變量，主要存在了線程對(duì)象 Worker，Worker 實(shí)現(xiàn)了 Runnable 接口。而對(duì)于 workQueue 變量，主要存放了需要執(zhí)行的任務(wù)。 這樣其實(shí)可以猜到， 整個(gè)線程池的實(shí)現(xiàn)原理應(yīng)該是 workQueue 中不斷的取出需要執(zhí)行的任務(wù)，放在 workers 中進(jìn)行處理。

另外，當(dāng)線程池中的線程用完了之后，多余的任務(wù)會(huì)等待，那么這個(gè)等待的過(guò)程是 怎么實(shí)現(xiàn)的呢？ 其實(shí)如果熟悉 BlockingQueue，那么就會(huì)馬上知道，是利用了 BlockingQueue 的take 方法進(jìn)行處理。

下面具體代碼分析：

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

首先，這里需要先理解兩個(gè)概念。我們?cè)趧?chuàng)建線程池的時(shí)候，通常會(huì)指定兩個(gè)變量，一個(gè)是maximumPoolSize，另外一個(gè)是 corePoolSize。

對(duì)于 maximumPoolSize：指的是 線程池中最多允許有多少個(gè)線程。

對(duì)于 corePoolSize： 指的是線程池中正在運(yùn)行的線程。

在 線程池中，有這樣的設(shè)定，我們加入一個(gè)任務(wù)進(jìn)行執(zhí)行，

如果現(xiàn)在線程池中正在運(yùn)行的線程數(shù)量大于 corePoolSize 指定的值而 小于maximumPoolSize 指定的值，那么就會(huì)創(chuàng)建一個(gè)線程對(duì)該任務(wù)進(jìn)行執(zhí)行，一旦一個(gè)線程被創(chuàng)建運(yùn)行。

如果線程池中的線程數(shù)量大于corePoolSize，那么這個(gè)任務(wù)執(zhí)行完畢后，該線程會(huì)被回收；如果 小于corePoolSize，那么該線程即使空閑，也不會(huì)被回收。下個(gè)任務(wù)過(guò)來(lái)，那么就使用這個(gè)空閑線程。

對(duì)于上述代碼，首先有：

if (workerCountOf(c) < corePoolSize)

也就是說(shuō)，判斷現(xiàn)在的線程數(shù)量是否小于corePoolSize，如果小于，那么就創(chuàng)建一個(gè)線程執(zhí)行該任務(wù)，也就是執(zhí)行

addWorker(command, true)

如果大于，那么就把該任務(wù)放進(jìn)隊(duì)列當(dāng)中，即

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

在這里可以看到一些關(guān)鍵代碼，例如 w = new Worker(firstTask)， 以及 workers.add(w); 從這里 我們就可以看到，創(chuàng)建 線程對(duì)象 并且加入到 線程 隊(duì)列中。但是，我們現(xiàn)在還沒有看到具體是怎么執(zhí)行任務(wù)的，繼續(xù)追蹤
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);
        }
        ......

對(duì)于 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);
                    }
                } 
                ......
    }

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

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

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

這里可以看到， 一個(gè) for 死循環(huán)，以及

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

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

這就是 線程如何等待執(zhí)行的。

現(xiàn)在就可以知道，大致的線程池實(shí)現(xiàn)原理：

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

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

然后，在 execute 方法中 進(jìn)行 addWorker(command，true)，也就是創(chuàng)建一個(gè)線程，把任務(wù)放進(jìn)去執(zhí)行；或者是直接把任務(wù)放入到任務(wù)隊(duì)列中。

接著 如果是 addWorker，那么就會(huì) new Worker(task) -》調(diào)用其中 run() 方法，在Worker 的run() 方法中，調(diào)用 runWorker(this); 方法 -》在該方法中就會(huì)具體執(zhí)行我們的任務(wù) task.run(); 同時(shí)這個(gè) runWorker方法相當(dāng)于是個(gè)死循環(huán)，正常情況下就會(huì)一直取出 任務(wù)隊(duì)列中的任務(wù)來(lái)執(zhí)行，這就保證了線程 不會(huì)銷毀。

所以，這也是為什么常說(shuō)的線程池可以避免線程的頻繁創(chuàng)建和 銷毀帶來(lái)的性能消耗。

寫出來(lái)，說(shuō)出來(lái)才知道對(duì)不對(duì)，知道不對(duì)才能改正，改正了才能成長(zhǎng)。

在技術(shù)方面，希望大家眼里都容不得沙子。如果有不對(duì)的地方或者需要改進(jìn)的地方希望可以指出，萬(wàn)分感謝。