1.計算機的基礎知識

位邏輯運算子:
&:
位與運算子，只有兩個運算元都是true，結果才是true，
|:
位或運算子，只有兩個運算元都是false，結果才是false，
~:
位非運算子：如果位為0，結果是1，如果位為1，結果是0.
^:
位異或運算：兩個數轉為二進制，然后從高位開始比較，如果相同則為0，不相同則為1，
位移運算:
無符號左移
無符號右移
:帶符號右移(沒有帶符號左移這種操作)
二進制:
二進制都是以補碼的形式表示的
正數的原碼，反碼，補碼都一樣;
要得到負數的補碼，必須先求負數的反碼，負數的反碼；負數的反碼按位1改成0，0改成1；負數的補碼等于反碼+1

分享一個，有很多干貨，包含netty，spring，執行緒，spring cloud等詳細講解，也有詳細的學習規劃圖，面試題整理等，我感覺在面試這塊講的非常清楚:獲取面試資料只需:點擊這里領取!!! 暗號：CSDN

2.ThreadPoolExecutor簡單示例

public class ThreadPoolExecutorTest {
?
    public static void main(String[] args) {
        BlockingQueue b = new ArrayBlockingQueue(100);
?
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 10, 500000, TimeUnit.SECONDS,
                b, new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
?
            }
        });
        threadPoolExecutor.execute(() -> {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(111111);
        });
?
        threadPoolExecutor.execute(() -> {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(2222222);
        });
?
    }
}

3.ThreadPoolExecutor屬性分析

public class ThreadPoolExecutor extends AbstractExecutorService {
?
    //用于保存執行緒運行狀態和當前執行緒池執行緒運行的數量
    //高3位用于代表執行緒的運行狀態,低29位代表執行緒池的執行緒最大數量
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    //32-3=29
    private static final int COUNT_BITS = Integer.SIZE - 3;
    //00011111111111111111111111111111，高3位為0，低29位為1，代表執行緒池的執行緒最大數量
    //參與運算用于得到執行緒的運行狀態和執行緒池執行緒的數量
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
    
    //執行緒池運行的狀態，后面單獨分析
    //執行緒池處于運行狀態，11100000000000000000000000000000
    private static final int RUNNING    = -1 << COUNT_BITS;
    //執行緒池處于shutdown狀態，00000000000000000000000000000000
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    //執行緒池處于結束狀態，00100000000000000000000000000000
    private static final int STOP       =  1 << COUNT_BITS;
    //執行緒池運行任務為空的時候的狀態，01000000000000000000000000000000
    private static final int TIDYING    =  2 << COUNT_BITS;
    //執行緒處于徹底終止的狀態，01100000000000000000000000000000
    private static final int TERMINATED =  3 << COUNT_BITS;
    
    //獲取執行緒池運行狀態，c代表ctl值
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    //獲取執行緒池作業執行緒數量，c代表ctl值
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    //獲取ctl值，rs代表執行緒的運行狀態，wc代表執行緒池作業執行緒數量,形成一個32位二進制數
    //高三位代表執行緒池運行狀態，低29位代表執行緒池作業執行緒數量
    private static int ctlOf(int rs, int wc) { return rs | wc; }
?
    //傳入ctl值和執行緒某個運行狀態，比較ctl值是否小于傳入的執行緒的某個運行狀態
    private static boolean runStateLessThan(int c, int s) {
        return c < s;
    }
?
    //傳入ctl值和執行緒運行狀態，比較ctl值是否大于傳入的執行緒的某個運行狀態
    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }
?
    //判斷執行緒運行狀態是否是運行狀態，因為RUNNING=-1是最小的狀態值
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }
?
    //通過CAS操作將作業執行緒數+1
    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }
?
    //通過CAS操作將作業執行緒數-1
    private boolean compareAndDecrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect - 1);
    }
?
    //do-while回圈可以強制讓作業執行緒數-1
    private void decrementWorkerCount() {
        do {} while (! compareAndDecrementWorkerCount(ctl.get()));
    }
?
    //執行緒池的作業佇列，在構造方法中初始化
    private final BlockingQueue<Runnable> workQueue;
    
    private final ReentrantLock mainLock = new ReentrantLock();
?
    //保存worker的池子
    private final HashSet<Worker> workers = new HashSet<Worker>();
?
    private final Condition termination = mainLock.newCondition();
?
    //記錄執行緒池生命周期中，執行緒池運行的執行緒的最大數量
    private int largestPoolSize;
?
    //執行緒池完成任務數量
    private long completedTaskCount;
?
    //創建執行緒工廠
    private volatile ThreadFactory threadFactory;
?
    //執行緒中斷策列
    private volatile RejectedExecutionHandler handler;
?
    //在指定時間單位下，執行緒存活時間
    private volatile long keepAliveTime;
?
    //核心執行緒數
    private volatile int corePoolSize;
?
    //最大執行緒數
    private volatile int maximumPoolSize;
?
    //執行緒池滿了后的中斷策列
    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
?
    private static final RuntimePermission shutdownPerm =
        new RuntimePermission("modifyThread");
?
    private final AccessControlContext acc;
    
    //當從作業佇列中取不到任務時的時候，是否需要回收核心執行緒
    private volatile boolean allowCoreThreadTimeOut;
    
}    

4.ThreadPoolExecutor構造方法分析

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.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

5.執行緒池創建執行緒順序分析

當我們執行execute方法提交一個執行緒的時候，首先會判斷當前執行緒池執行緒數是否超過核心執行緒數corePoolSize，若是沒有超過，則創建新執行緒，若是超過，則嘗試將Runnable提交到作業佇列workQueue中，

如果作業佇列workQueue沒有超過容量，則Runnable提交到作業佇列中，如果超過了workQueue的容量，則嘗試創建執行緒，如果此時創建的執行緒小于最大執行緒數maximumPoolSize，則創建執行緒，如果超過了maximumPoolSize，則執行拒絕策列，

6.ThreadPoolExecutor.execute方法分析

public void execute(Runnable command) {
    //如果runnable為空，拋出例外
    if (command == null)
        throw new NullPointerException();
    //獲取ctl值，該值高3位代表執行緒池運行狀態，低29位代表執行緒池當前運行執行緒數量
    int c = ctl.get();
    //CASE1:獲取執行緒池運行執行緒數量，如果小于核心執行緒數，則創建執行緒，addWorker傳入引數為core
    //也就是說，執行緒池不是一上來就把核心執行緒創建了，必須在提交runnable任務到執行緒池的時候才一個一個創建
    if (workerCountOf(c) < corePoolSize) {
        //addWorker是創建執行緒的核心方法，關鍵點在Worker類的構造方法和runWorker方法的while回圈
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    //CASE2:條件1不成立說明核心執行緒數已滿，將任務添加到阻塞佇列中，
    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);
    }
    //CASE3:條件1和2都不成立，說明核心執行緒已創建完全并且任務佇列已滿
    //呼叫addWorker創建非核心執行緒，如果回傳false，說明執行緒數達到最大執行緒數，執行拒絕策列
    else if (!addWorker(command, false))
        reject(command);
}

6.1.Worker類分析

每個執行緒的創建都離不開Worker類，該類完全包裝了執行緒運行的所需要的屬性，并提供了初始化執行緒和從阻塞佇列中獲取被阻塞的執行緒并執行的一系列方法，

觀察該類代碼發現，該類繼承了AbstractQueuedSynchronizer并實作了Runnable介面，在創建執行緒的時候，實際Thread類的構造方法包裝的就是Worker類自己(我們知道一般Runnable需要被傳入到Thread里面的，如:Thread t = new Thread(runnable), t.start()啟動執行緒)，

而從execute方法傳過來的Runnable實作只是被封裝到了firstTask中，創建出來的Thread在執行的時候，呼叫的start方法也只是啟動了該類的runWorker方法，而真正封裝我們執行邏輯的firstTask這個Runnable類在后續呼叫中也只是執行自己的run方法而已，并不再被Thread封裝，

worker為什么要繼承AbstractQueuedSynchronizer呢？

因為在runWork的方法內，在呼叫firstTask處理業務邏輯前，會給代碼加上獨占鎖，加這個獨占鎖的目的是什么呢？因為我們在呼叫shutDown方法的時候，并不會終止處于運行中的執行緒，shutDown方法會根據獨占鎖來判斷當前worker是否正在作業，

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    private static final long serialVersionUID = 6138294804551838833L;
?
    //需要創建的執行緒，該執行緒封裝的Runnable是自己
    final Thread thread;
?
    //execute傳入的Runnable，該runnable并不被Thread包裝，后續呼叫自己的run方法，
    Runnable firstTask;
?
    volatile long completedTasks;
?
    Worker(Runnable firstTask) {
        //設定執行緒池處于運行狀態
        setState(-1); 
        //封裝execute傳入進來的包含實際邏輯的Runnable
        this.firstTask = firstTask;
        //創建一個執行緒，這里注意，執行緒封裝的Runnable是自己
        //示例使用Executors.defaultThreadFactory()
        this.thread = getThreadFactory().newThread(this);
    }
    //被thread屬性封裝后呼叫start方法后，會自動啟動該run方法，執行后續邏輯
    //后續邏輯會呼叫firstTask.run()方法啟動實際業務邏輯
    public void run() {
        runWorker(this);
    }
?
    protected boolean isHeldExclusively() {
        return getState() != 0;
    }
?
    protected boolean tryAcquire(int unused) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }
?
    protected boolean tryRelease(int unused) {
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }
?
    public void lock()        { acquire(1); }
    public boolean tryLock()  { return tryAcquire(1); }
    public void unlock()      { release(1); }
    public boolean isLocked() { return isHeldExclusively(); }
?
    void interruptIfStarted() {
        Thread t;
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

6.2.addWorker方法分析

addWorker是創建執行緒的核心方法，一個worker代表一個執行緒，而workers這個全域變數可以代表執行緒池，只有向workers里面添加worker成功的時候，才能代表創建執行緒成功了，

addWorker在執行程序中，會根據執行緒池狀態和執行緒池數量判斷是否能創建執行緒，創建執行緒成功會將記錄執行緒池狀態和數量的ctl值+1，并將worker加入到workers里面，更新執行緒池生命周期內執行緒池執行緒的最大數量，然后啟動執行緒執行任務，

addWorker的core引數代表是否是在創建核心執行緒，core為true代表創建核心執行緒，false代表阻塞佇列已滿，創建非核心執行緒，

回傳值: true代表創建執行緒并啟動成功，false代表創建執行緒失敗，

什么時候回傳false呢？ CASE1.執行緒池狀態rs>SHUTDOWN；
CASE2.執行緒池狀態為SHUTDOWN的時候，阻塞佇列沒有任務了,為空;
CASE3.執行緒池狀態為SHUTDOWN的時候，execute提交的Runnable(被封裝到firstTask里面)不為空;
CASE4.如果是創建核心執行緒，此時已經超過核心執行緒數；如果是創建非核心執行緒，此時已經超過最大執行緒數;
CASE5.ThreadFactory創建執行緒為空,這里一般是我們自定義執行緒工廠的時候出的問題;

private boolean addWorker(Runnable firstTask, boolean core) {
    //retry代碼除了檢查是否能創建執行緒外，還負責將ctl值+1，如果不能創建執行緒，則回傳false;
    retry:
    for (;;) {
        //獲取當前ctl值
        int c = ctl.get();
        //獲取當前執行緒池運行狀態
        int rs = runStateOf(c);
        //CASE1.執行緒池狀態rs>SHUTDOWN；回傳false;
        //CASE2.執行緒池狀態為SHUTDOWN的時候，阻塞佇列沒有任務了,為空;
        //CASE3.執行緒池狀態為SHUTDOWN的時候，execute提交的Runnable(被封裝到firstTask里面)不為空;
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
?
        //回圈判斷是否能將ctl+1設定成功
        for (;;) {
            //獲取當前運行中的執行緒數量
            int wc = workerCountOf(c);
            //條件1:wc >= CAPACITY基本不可能，CAPACITY為理論上的最大執行緒數，一個5億級的數字
            //CASE4.根據core引數，如果是創建核心執行緒，此時已經超過核心執行緒數，則回傳false
            //如果是創建非核心執行緒，此時已經超過最大執行緒數，則回傳false
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //條件成立，說明給ctl修改+1成功了，代表給執行緒數+1設定成功了，可以退出回圈創建執行緒了
            //如果在執行這段代碼的時候，執行緒池狀態正巧被改了，這里也會失敗，因為ctl的高3位代表的是執行緒狀態

            if (compareAndIncrementWorkerCount(c))
                break retry;
            //如果上面設定執行緒數+1失敗，則實時獲取執行緒狀態并和當前的比較
            c = ctl.get();  
            //狀態被改變了跳到retry再次判斷是否允許創建執行緒
            if (runStateOf(c) != rs)
                continue retry;
        }
    }
    //代碼走到這里代表已經允許創建執行緒了
    
    //表示創建的worker是否已經啟動,啟動也代表執行緒創建成功了
    boolean workerStarted = false;
    //添加worker到worker佇列是否成功的狀態
    boolean workerAdded = false;
    //區域變數
    Worker w = null;
    try {
        //構建work物件
        w = new Worker(firstTask);
        //獲取worker的構造方法創建的執行緒
        final Thread t = w.thread;
        //這里加了這段判斷是為了防止自己實作的TreadFactory有bug導致創建執行緒失敗
        if (t != null) {
            //向works這個hashset里面添加works的時候，需要全域加鎖，以下代碼執行緒并不安全
            //該段代碼我的理解就是為了維護largestPoolSize這個值，記錄執行緒池生命周期中，
            //執行緒池運行的執行緒的最大數量
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                //獲取當前執行緒池狀態
                int rs = runStateOf(ctl.get());
                //檢查執行緒池狀態必須是RUNNING或者處于SHUTDOWN的時候，并沒有提交具體的任務
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    //防止人為定義執行緒工廠創建執行緒并啟動了start方法的情況
                    if (t.isAlive()) 
                        throw new IllegalThreadStateException();
                    //向執行緒池添加worker
                    workers.add(w);
                    //獲取執行緒池執行緒數量
                    int s = workers.size();
                    //如果執行緒池執行緒數量>記錄的值,更新執行緒池生命周期內最大執行緒記錄數
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    //表示向執行緒池中添加執行緒成功了
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                //啟動執行緒,該方法實際會啟動worker類的run方法，然后執行runWorker方法
                t.start();
                //設定執行緒啟動狀態為成功
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            //后面再分析
            addWorkerFailed(w);
    }
    return workerStarted;
}

6.3.runWorker方法分析

addWorker方法創建執行緒成功，Worker類的Thread會呼叫start方法啟動自己的run方法，因為Worker類實作了Runnable介面，run方法里面呼叫了runWorker方法，實際我們execute方法傳入的Runnable被封裝到了Worker類的firstTask屬性里面，然后在runWorker里面呼叫run方法啟動具體的邏輯，注意這里并沒用再用Thrad封裝Runnable了，執行緒啟動后，會一直運行While回圈，回圈第一次運行自己傳入的Runnable，第二次及之后則通過getTask方法從任務佇列種獲取具體的Runnable任務了，一旦While回圈內發生例外或者getTask回傳空，則會呼叫processWorkerExit執行執行緒銷毀邏輯，getTask方法獲取不到具體任務的執行緒都可被認為是空閑執行緒，

final void runWorker(Worker w) {
    //wt=w.thread
    Thread wt = Thread.currentThread();
    //execute實際傳入的包含業務邏輯的Runnable，該Runnable不再被Thread包裝，呼叫自己的run方法
    Runnable task = w.firstTask;
    //參考設定為null，幫助gc
    w.firstTask = null;
    //先呼叫unlock方法設定當前獨占執行緒為空，執行緒運行狀態為0
    w.unlock();
    //執行緒退出狀態，true代表執行緒因為例外退出了
    boolean completedAbruptly = true;
    try {
        //執行緒被創建并啟動后就一直執行while回圈，直到發生例外或者退出
        //條件1:task != null,執行緒初創task不為空
        //條件2:條件1不成立說明執行緒非初創并且核心執行緒數已滿，說明已經創建好執行緒，從佇列中取task任務
        while (task != null || (task = getTask()) != null) {
            //設定獨占鎖,因為shutDown方法呼叫的時候不會立刻終止運行中的執行緒,
            //會根據是否持有獨占鎖來判斷當前worker是否處于運行狀態
            w.lock();
            //執行緒池處于STOP/TIDYING/TERMINATION且當前執行緒沒有設定中斷狀態
            //給當前執行緒設一個中斷狀態
            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設定為空
                task = null;
                //每個worker完成任務數量+1
                w.completedTasks++;
                //釋放掉鎖，正常情況下會回到while回圈繼續執行getTask，發生例外會執行下面的finally
                //getTask為空也會退出while回圈
                w.unlock();
            }
        }
        //如果getTask()回傳空的時候，執行退出邏輯
        completedAbruptly = false;
    } finally {
        //執行緒退出邏輯
        //completedAbruptly=true因為例外退出
        //completedAbruptly=false正常退出
        processWorkerExit(w, completedAbruptly);
    }
}

6.4.getTask方法分析

當getTask回傳空的時候，執行緒可以執行銷毀邏輯了，

getTask什么時候回傳空？

1.執行緒池處于SHUTDOWN狀態,作業佇列為空的時候;
2.執行緒池處于STOP狀態以上的時候，將執行緒池執行緒數-1并回傳空;
3.當作業佇列為空的時候;
注意，執行緒池的allowCoreThreadTimeOut屬性會影響getTask方法，導致getTask方法一直阻塞在workQueue.take()這里的，這樣就不會銷毀執行緒，

1.allowCoreThreadTimeOut=true，使用非阻塞方法從佇列獲取任務
2.allowCoreThreadTimeOut=false，執行緒池執行緒數還未達到核心執行緒數上限，使用阻塞方法獲取任務，這樣就可以使得核心執行緒不會被銷毀，getTask方法一直阻塞等待獲取佇列種的任務，
3.allowCoreThreadTimeOut=false,執行緒池執行緒數達到核心執行緒數，使用非阻塞方法獲取任務

private Runnable getTask() {
    boolean timedOut = false; 
?
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
?
        //成立1:執行緒池處于SHUTDOWN狀態且作業佇列為空的時候
        //成立2:執行緒池處于STOP狀態以上的時候，將執行緒池執行緒數-1并回傳空
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
?
        //獲取執行緒池執行緒數
        int wc = workerCountOf(c);
?
        //1.allowCoreThreadTimeOut=true，使用非阻塞方法從佇列獲取任務
        //2.allowCoreThreadTimeOut=false，執行緒池執行緒數還未達到核心執行緒數，使用阻塞方法獲取任務，
        //3.allowCoreThreadTimeOut=false,執行緒池執行緒數達到核心執行緒數，使用非阻塞方法獲取任務
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
?
        //條件1-1:wc > maximumPoolSize,可能最大執行緒數設定的比核心執行緒數小,此時沒有空閑執行緒可以接手
        //條件1-2:timed && timedOut的timedOut在poll(keepAliveTime, TimeUnit.NANOSECONDS)
        //方法獲取超時的時候，回圈第二次執行的時候才可能導致條件為true
        //條件2:執行緒池還有其他執行緒，作業佇列為慷訓傳true
        //以上1和2條件成立了，任務回傳為空，
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            //嘗試將執行緒數-1，并不一定會成功，可能被其他執行緒改過，失敗則繼續回圈嘗試-1
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
?
?
        try {
            //當timed=true的時候，使用poll獲取超時候導致r=null的時候，timedOut=true,
            //再次執行回圈
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();//阻塞方式從佇列獲取，防止執行緒執行緒執行銷毀邏輯
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

6.5.processWorkerExit方法分析

該方法用于執行執行緒銷毀的邏輯，

1.加鎖，從workers佇列中移除一個worker，將執行緒池完成任務總數量+1, 釋放鎖;
2.判斷是否需要關閉執行緒池;
3.如果執行緒正常完成并退出，根據allowCoreThreadTimeOut判斷是否需要回收核心執行緒，
若allowCoreThreadTimeOut=true,只需要保證執行緒池最少有一個執行緒即可，也就是說超過1的空閑執行緒一定會被銷毀，
若allowCoreThreadTimeOut=false,在執行緒數未達到核心執行緒數上限的情況下，由于getTask方法的阻塞，不會執行執行緒銷毀的邏輯；當執行緒數達到核心執行緒數上限的情況，且佇列也達到上限數，這之后創建的任何執行緒在getTask方法獲取不到具體任務的情況下都會銷毀

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    //因為例外退出，執行緒運行數-1
    if (completedAbruptly) 
        decrementWorkerCount();
?
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //取出每個worker執行的任務數量，并匯總到全域的任務執行數量中
        completedTaskCount += w.completedTasks;
        //將worker從池中移除
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }
?
    //嘗試關閉執行緒池并處理空閑執行緒
    tryTerminate();
?
    //獲取執行緒ctl值
    int c = ctl.get();
    //如果執行緒池當前狀態小于STOP狀態，說明執行緒池處于RUNNING，SHUTDOWN狀態
    if (runStateLessThan(c, STOP)) {
        //如果執行緒池是正常退出回傳false走下面的流程
        if (!completedAbruptly) {
            //allowCoreThreadTimeOut表示是否允許核心執行緒銷毀
            //min表示執行緒池允許的最小執行緒數，最少為1
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            //條件1:min==0說明允許核心執行緒銷毀
            //條件2:作業佇列不為空
            if (min == 0 && ! workQueue.isEmpty())
                //設定執行緒池最小執行緒數
                min = 1;
            //如果當前執行緒池執行緒數大于min的值，回傳，這里不管min是核心執行緒數還是1
            //也就是說，超過核心執行緒的執行緒數在getTask方法從佇列取不到的時候一定會回收
            //而核心執行緒是否回識訓根據allowCoreThreadTimeOut屬性來判斷
            if (workerCountOf(c) >= min)
                return; 
        }
        //上面從workers池中洗掉了一個worker，這里添加進去一個空任務的worker
        //核心執行緒數=0的情況會執行到這里，會維持核心執行緒數最少為1
        addWorker(null, false);
    }
}

6.6.tryTerminate方法分析

嘗試關閉執行緒池方法并處理空閑執行緒，interruptIdleWorkers方法處理空閑執行緒，設定中斷狀態，每個執行緒退出都會單獨呼叫該方法，

final void tryTerminate() {
    //自旋
    for (;;) {
        //獲取執行緒ctl值
        int c = ctl.get();
        //條件1:執行緒池處于RUNNING狀態說明執行緒池當前正常,直接回傳
        //條件2:runStateAtLeast(c, TIDYING)說明已經有執行緒使得執行緒池由TIDYING -> TERMINATED狀態
        //轉換了，當前執行緒直接回傳
        //條件3:(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty())
        //說明執行緒池雖然處于SHUTDOWN狀態，但作業佇列不為空，得等佇列處理完再嘗試關閉執行緒池的邏輯，
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;
        //能走到這里兩種情況
        //1.執行緒池狀態>=STOP了
        //2.執行緒池狀態于SHUTDOWN狀態，但佇列為空了
        if (workerCountOf(c) != 0) {
            //回收空閑的執行緒，因為執行runworer方法的時候worker會加鎖，所以沒加鎖的都是空閑的
            interruptIdleWorkers(ONLY_ONE);
            return;
        }
?
        //workerCountOf(c) == 0 時，會來到這里，說明執行緒都已經銷毀了
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //設定執行緒池狀態為TIDYING狀態，
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    //鉤子方法，等用戶實作
                    terminated();
                } finally {
                    //鉤子方法設定執行緒池狀態為TERMINATED狀態
                    ctl.set(ctlOf(TERMINATED, 0));
                    //喚醒呼叫 awaitTermination() 方法的執行緒，
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
    }
}

6.7.interruptIdleWorkers方法分析

處理一個空閑執行緒方法，所有處于執行中的執行緒都會加鎖(w.lock())，上面我們提過，核心執行緒被take方法阻塞的時候，我們這里設定執行緒t.interrupt()， 會解除take的阻塞，

private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers) {
            Thread t = w.thread;
            //執行緒沒有中斷且嘗試加鎖成功，因為所有處于執行中的執行緒都會加鎖(w.lock())
            //未加鎖的說明處于空閑中了，
            if (!t.isInterrupted() && w.tryLock()) {
                try {
                    //設定執行緒中斷
                    t.interrupt();
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne)
                break;
        }
    } finally {
        mainLock.unlock();
    }
}

6.8.awaitTermination方法分析

該方法是判斷執行緒池狀態狀態是否是TERMINATED，如果是則直接回傳true，否則會await掛起當前執行緒指定的時間

public boolean awaitTermination(long timeout, TimeUnit unit)
    throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (;;) {
            if (runStateAtLeast(ctl.get(), TERMINATED))
                return true;
            if (nanos <= 0)
                return false;
            nanos = termination.awaitNanos(nanos);
        }
    } finally {
        mainLock.unlock();
    }
}
## 6.9.shutDown和shutDownNow方法分析

shutDown方法會優雅的關閉執行緒池，設定執行緒池狀態為SHUTDOWN，已經處于佇列中的任務會繼續等待執行完，

shutDownNow方法會立即關閉執行緒池，設定執行緒池狀態為STOP，

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    //獲取執行緒池全域鎖
    mainLock.lock();
    try {
        checkShutdownAccess();
        //設定執行緒池狀態為SHUTDOWN
        advanceRunState(SHUTDOWN);
        //中斷空閑執行緒
        interruptIdleWorkers();
        //空方法，子類可以擴展
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        //釋放執行緒池全域鎖
        mainLock.unlock();
    }
    tryTerminate();
}
public List<Runnable> shutdownNow() {
    //回傳值參考
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    //獲取執行緒池全域鎖
    mainLock.lock();
    try {
        checkShutdownAccess();
        //設定執行緒池狀態為STOP
        advanceRunState(STOP);
        //中斷執行緒池中所有執行緒
        interruptWorkers();
        //匯出未處理的task
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
?
    tryTerminate();
    //回傳當前任務佇列中 未處理的任務，
    return tasks;
}

#7.ThreadPoolExecutor拒絕策列

默認有以下4中拒絕策列，用戶也可以實作RejectedExecutionHandler介面自定義，

CallerRunsPolicy將任務交給呼叫者執行
AbortPolicy拋出例外
DiscardPolicy什么都不做，直接丟棄
DiscardOldestPolicy丟棄老的，執行新的
public static class CallerRunsPolicy implements RejectedExecutionHandler {
?
    public CallerRunsPolicy() { }
?
    //交給主執行緒執行
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}
?
public static class AbortPolicy implements RejectedExecutionHandler {
?
    public AbortPolicy() { }
?
    //中斷拒絕
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}
?
public static class DiscardPolicy implements RejectedExecutionHandler {
?
    public DiscardPolicy() { }
?
    //直接拋棄什么都不做
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}
?
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
?
    public DiscardOldestPolicy() { }
?
    //丟棄老的 ，執行新的
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}

8.擴展:改變執行緒池的初始化程序

如果我們想讓執行緒按核心執行緒，最大執行緒，最后再進佇列的方式初始化，應該怎么做？

public void execute(Runnable command) {
    //如果runnable為空，拋出例外
    if (command == null)
        throw new NullPointerException();
    //獲取ctl值，該值高3位代表執行緒池運行狀態，低29位代表執行緒池當前運行執行緒數量
    int c = ctl.get();
    //CASE1:獲取執行緒池運行執行緒數量，如果小于核心執行緒數，則創建執行緒，addWorker傳入引數為core
    //也就是說，執行緒池不是一上來就把核心執行緒創建了，必須在提交runnable任務到執行緒池的時候才一個一個創建
    if (workerCountOf(c) < corePoolSize) {
        //addWorker是創建執行緒的核心方法，關鍵點在Worker類的構造方法和runWorker方法的while回圈
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    //CASE2:條件1不成立說明核心執行緒數已滿，將任務添加到阻塞佇列中，
    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);
    }
    //CASE3:條件1和2都不成立，說明核心執行緒已創建完全并且任務佇列已滿
    //呼叫addWorker創建非核心執行緒，如果回傳false，說明執行緒數達到最大執行緒數，執行拒絕策列
    else if (!addWorker(command, false))
        reject(command);
}

我們在說execute方法初始化執行緒池程序中，CASE2:workQueue.offer(command)會將任務加入到佇列，所以，我們這里只需要自定義BlockingQueue，改造offer方法，在里面判斷，當執行緒池執行緒數還未達到最大執行緒數的時候回傳false即可，

Dubbo的EagerThreadPool自定義了一個BlockingQueue，在offer()方法中，如果當前執行緒池數量小于最大執行緒池時，直接回傳false，這里就達到了調節執行緒池執行順序的目的，

9.推薦

分享一個，有很多干貨，包含netty，spring，執行緒，spring cloud等詳細講解，也有詳細的學習規劃圖，面試題整理等，我感覺在面試這塊講的非常清楚:獲取面試資料只需:點擊這里領取!!! 暗號：CSDN