本文旨在弄清楚 線程和任務(wù) 在java線程池里的處理邏輯

更詳細(xì)的源碼解析參考： https://javadoop.com/2017/09/05/java-thread-pool/

ThreadPoolExecutor 的 addWorker 方法的上半部分

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null &&
                                ! workQueue.isEmpty()))
            return false;
        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }
    // .......
}

這里首先獲取線程池的運(yùn)行狀態(tài)的值（32位 int ，高3位為狀態(tài)，后29位為線程的數(shù)量），一共有五種狀態(tài)，大于等于SHUTDOWN的都是非RUNNING態(tài)，第一個(gè)判斷，判斷的是兩種情況：

1. 大于等于 SHUTDOWN 狀態(tài)且 firstTask != null
2. 大于等于 SHUTDOWN 狀態(tài)且 workQueue 為空

當(dāng)這兩條件之一滿足的時(shí)候，表明addWorker失敗了，為什么是這樣的設(shè)定，我們需要看關(guān)于SHUTDOWN的定義，SHUTDOWN 表明線程池不接受任務(wù)但線程池里的任務(wù)繼續(xù)執(zhí)行。當(dāng)線程池關(guān)閉且 firstTask == null 且 workQueue 不為空的時(shí)候，還是可以添加任務(wù)的，為什么呢，往調(diào)用這個(gè)方法的地方看：

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        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); // 這里，如果線程池還是running并且當(dāng)前的線程數(shù)為0時(shí)，強(qiáng)行將firstTask置為null，開(kāi)啟新線程
        }
        else if (!addWorker(command, false))// 如果提交失敗，會(huì)新建個(gè)線程來(lái)執(zhí)行這個(gè)任務(wù)
            reject(command);
    }

這里先埋個(gè)伏筆，往后看。第二個(gè)for循環(huán)：這里就是判斷工作線程的數(shù)量是否超出規(guī)定的容量和多線程情況下的修改值判斷（CAS 很重要）。

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 {
            // Recheck while holding lock.
            // Back out on ThreadFactory failure or if
            // shut down before lock acquired.
            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;
            }
        } finally {
            mainLock.unlock();
        }
        if (workerAdded) {
            t.start();
            workerStarted = true;
        }
    }
} finally {
    if (! workerStarted)
        addWorkerFailed(w);
}
return workerStarted;

這里面代碼還是很簡(jiǎn)單的，就是做了啟動(dòng)任務(wù)的工作。我們繼續(xù)看runWorker方法，它才是真正執(zhí)行的方法

 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 pool is stopping, ensure thread is interrupted;
             // if not, ensure thread is not interrupted.  This
             // requires a recheck in second case to deal with
             // shutdownNow race while clearing interrupt
             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);
                 }
             } finally {
                 task = null;
                 w.completedTasks++;
                 w.unlock();
             }
         }
         completedAbruptly = false;
     } finally {
         processWorkerExit(w, completedAbruptly);
     }
 }

這里主要看那個(gè)判斷，就是判斷當(dāng)線程池的狀態(tài)為中斷，那么當(dāng)前執(zhí)行方法的線程也因該中斷，結(jié)束。剩下的代碼跟進(jìn)去看源碼就行了，這里回到本文的主旨上，java線程池任務(wù)和線程的關(guān)系：

1. 當(dāng)線程數(shù)小于 corePoolSize 時(shí)，來(lái)個(gè)任務(wù)開(kāi)一個(gè)線程。
2. 如果當(dāng)前線程數(shù)已經(jīng)達(dá)到 corePoolSize，那么將提交的任務(wù)添加到隊(duì)列中，等待線程池中的線程去隊(duì)列中取任務(wù)；
3. 如果隊(duì)列已滿，那么創(chuàng)建新的線程來(lái)執(zhí)行任務(wù)，需要保證池中的線程數(shù)不會(huì)超過(guò) maximumPoolSize，如果此時(shí)線程數(shù)超過(guò)了 maximumPoolSize，那么執(zhí)行拒絕策略。