// ctl，原子變量，存儲狀態(tài)和線程數(shù)量，初始化運行狀態(tài)+0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 靜態(tài)常量，表示線程數(shù)量存放的位數(shù)29=32-3
private static final int COUNT_BITS = Integer.SIZE - 3;
// 線程數(shù)量最大的容量，低 COUNT_BITS 位所能表達的最大數(shù)值，000 11111111111111111111 => 5億多
private static final int CAPACITY  = (1 << COUNT_BITS) - 1;

// 111 000000000000000000，轉(zhuǎn)換成整數(shù)后其實就是一個【負數(shù)】
private static final int RUNNING    = -1 << COUNT_BITS;
// 000 000000000000000000
private static final int SHUTDOWN   =  0 << COUNT_BITS;
// 001 000000000000000000
private static final int STOP       =  1 << COUNT_BITS;
// 010 000000000000000000
private static final int TIDYING    =  2 << COUNT_BITS;
// 011 000000000000000000
private static final int TERMINATED =  3 << COUNT_BITS;

// ~CAPACITY = ~000 11111111111111111111 = 111 000000000000000000000（取反）
// &運算符，和1&是它本身，和0&就是0,就可以獲得高位值。
private static int runStateOf(int c)     { return c & ~CAPACITY; }

// CAPACITY = 000 11111111111111111111
// &運算符，和1&是它本身，和0&就是0,就可以獲得低29位
private static int workerCountOf(int c)  { return c & CAPACITY; }

// rs 表示線程池狀態(tài)，wc 表示當前線程池中 worker（線程）數(shù)量，相與以后就是合并后的狀態(tài)
private static int ctlOf(int rs, int wc) { return rs | wc; }

// 比較當前線程池 ctl 所表示的狀態(tài)，是否小于某個狀態(tài) s
private static boolean runStateLessThan(int c, int s) { return c < s; }
// 比較當前線程池 ctl 所表示的狀態(tài)，是否大于等于某個狀態(tài)s
private static boolean runStateAtLeast(int c, int s) { return c >= s; }
// 小于 SHUTDOWN 的一定是 RUNNING，SHUTDOWN == 0
private static boolean isRunning(int c) { return c < SHUTDOWN; }

// 使用 CAS 方式 讓 ctl 值 +1 ，成功返回 true, 失敗返回 false
private boolean compareAndIncrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect + 1);
}
// 使用 CAS 方式 讓 ctl 值 -1 ，成功返回 true, 失敗返回 false
private boolean compareAndDecrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect - 1);
}
// 將 ctl 值減一，do while 循環(huán)會一直重試，直到成功為止
private void decrementWorkerCount() {
    do {} while (!compareAndDecrementWorkerCount(ctl.get()));
}

// 線程池用于保存任務(wù)并將任務(wù)傳遞給工作線程的隊列
private final BlockingQueue<Runnable> workQueue;

// 增加減少 worker 或者時修改線程池運行狀態(tài)需要持有 mainLock
private final ReentrantLock mainLock = new ReentrantLock();

private final HashSet<Worker> workers = new HashSet<Worker>();

// 核心線程數(shù)量
private volatile int corePoolSize;
// 線程池最大線程數(shù)量
private volatile int maximumPoolSize;	
// 空閑線程存活時間
private volatile long keepAliveTime;	
// 創(chuàng)建線程時使用的線程工廠，默認是 DefaultThreadFactory
private volatile ThreadFactory threadFactory;	
// 【超過核心線程提交任務(wù)就放入 阻塞隊列】
private final BlockingQueue<Runnable> workQueue;
// 拒絕策略
private volatile RejectedExecutionHandler handler;	

// 記錄線程池生命周期內(nèi)線程數(shù)最大值
private int largestPoolSize;	
// 記錄線程池所完成任務(wù)總數(shù)，當某個 worker 退出時將完成的任務(wù)累加到該屬性
private long completedTaskCount;	

//  ThreadPoolExecutor#execute
public void execute(Runnable command) {
        // 如果任務(wù)為空，直接拋空指針
        if (command == null)
            throw new NullPointerException();
        // 獲取ctl的值，其中高3位是狀態(tài)信息，低3位是線程數(shù)量
        int c = ctl.get();
        // workerCountOf獲取當前線程的數(shù)量
        // 當前線程數(shù)量小于核心線程數(shù)，調(diào)用addWorker創(chuàng)建一個工作線程
        if (workerCountOf(c) < corePoolSize) {
            // 調(diào)用addWorker方法創(chuàng)建工作線程，直接執(zhí)行任務(wù)。如果成功的話，直接結(jié)束方法。
            if (addWorker(command, true))
                return;
            // 由于并發(fā)等原因，addWorker添加失敗，會走到這里，再次獲取ctl的值
            c = ctl.get();
        }
    	// 如果線程池是運行狀態(tài)的話，就把任務(wù)加入到隊列中
        if (isRunning(c) && workQueue.offer(command)) {
            // 雙重檢查，因為從上次檢查到進入此方法，線程池可能已成為SHUTDOWN狀態(tài)
            int recheck = ctl.get();
            // 如果發(fā)現(xiàn)線程池不是運行狀態(tài)的話，那就移除這個任務(wù)
            if (!isRunning(recheck) && remove(command))
                // 任務(wù)出隊成功，走拒絕策略
                reject(command);
             // 執(zhí)行到這說明線程池是 running 狀態(tài)，獲取線程池中的線程數(shù)量，判斷是否是 0
             // 【擔保機制】，保證線程池在 running 狀態(tài)下，最起碼得有一個線程在工作
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        // 走到這里說明線程不是運行狀態(tài)，或者就是隊列滿了，offer返回false
        // 再次調(diào)用addWoker創(chuàng)建新的線程，如果不成功(一般是超過了線程池最大線程數(shù)量),執(zhí)行拒絕策略
        else if (!addWorker(command, false))
            // 執(zhí)行拒絕策略
            reject(command);
    }

//  ThreadPoolExecutor#addWorker
// core == true 表示采用核心線程數(shù)量限制，false 表示采用 maximumPoolSize
private boolean addWorker(Runnable firstTask, boolean core) {
     // 自旋【判斷當前線程池狀態(tài)是否允許創(chuàng)建線程】，允許就設(shè)置線程數(shù)量 + 1
    retry:
    for (;;) {
         // 獲取 ctl 的值
        int c = ctl.get();
        // 獲取當前線程池運行狀態(tài)
        int rs = runStateOf(c);

         // 判斷當前線程池狀態(tài)【是否允許添加線程】
        
       // 如果線程池狀態(tài)大于SHUTDOWN 或者是SHUTDOWN狀態(tài)，隊列是空了的話，都不允許創(chuàng)建新的線程
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            // false，沒有創(chuàng)建線程
            return false;
        // 再次自旋
        for (;;) {
            // 獲取線程池中線程數(shù)量
            int wc = workerCountOf(c);
            // 如果線程數(shù)量超過閾值的話，返回false
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
          // 記錄線程數(shù)量已經(jīng)加 1，類比于申請到了一塊令牌，條件失敗說明其他線程修改了數(shù)量
            if (compareAndIncrementWorkerCount(c))
                // 申請成功，跳出了 retry 這個 for 自旋
                break retry;
             // CAS 失敗，沒有成功的申請到令牌
            c = ctl.get(); 
            // 判斷當前線程池狀態(tài)是否發(fā)生過變化，被其他線程修改了，可能其他線程調(diào)用了 shutdown() 方法
            if (runStateOf(c) != rs)
                // 重新回到retry的執(zhí)行點
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    // 下面開始真正創(chuàng)建線程了
    // 運行標記，表示創(chuàng)建的 worker 是否已經(jīng)啟動，false未啟動  true啟動
    boolean workerStarted = false;
    // 添加標記，表示創(chuàng)建的 worker 是否添加到池子中了，默認false未添加，true是添加。
    boolean workerAdded = false;
    Worker w = null;
    try {
        //【創(chuàng)建 Worker，底層通過線程工廠 newThread 方法創(chuàng)建執(zhí)行線程，指定了首先執(zhí)行的任務(wù)】
        w = new Worker(firstTask);
        // 將新創(chuàng)建的 worker 節(jié)點中的線程賦值給 t
        final Thread t = w.thread;
        // 這里的判斷為了防止 程序員自定義的 ThreadFactory 實現(xiàn)類有 bug，創(chuàng)造不出線程
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            // 加互斥鎖，要添加 worker 了
            mainLock.lock();
            try {
                 // 獲取最新線程池運行狀態(tài)
                int rs = runStateOf(ctl.get());
            	// 判斷線程池是否為RUNNING狀態(tài)，不是再【判斷當前是否為SHUTDOWN狀態(tài)且firstTask為空，特殊情況】
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                     // 當線程start后，線程isAlive會返回true，這里還沒開始啟動線程，如果被啟動了就需要報錯
                    if (t.isAlive()) 
                        throw new IllegalThreadStateException();
                    //將新建的 Worker 添加到線程池中
                    workers.add(w);
                    int s = workers.size();
                    // 當前池中的線程數(shù)量是一個新高，更新 largestPoolSize
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                     // 添加標記置為 true
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
             // 添加成功就【啟動線程執(zhí)行任務(wù)】
            if (workerAdded) {
                // 啟動線程
                t.start();
                // 運行標記置為 true
                workerStarted = true;
            }
        }
    } finally {
        // 線程啟動失敗
        if (! workerStarted)
            // 清理工作，比如從線程池中移除。
            addWorkerFailed(w);
    }
    return workerStarted;
}

private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    // 持有線程池全局鎖，因為操作的是線程池相關(guān)的東西
    mainLock.lock();
    try {
        //條件成立需要將 worker 在 workers 中清理出去。
        if (w != null)
            workers.remove(w);
        // 將線程池計數(shù) -1，相當于歸還令牌。
        decrementWorkerCount();
        // 嘗試停止線程池
        tryTerminate();
    } finally {
        //釋放線程池全局鎖。
        mainLock.unlock();
    }
}

private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
	// worker 內(nèi)部封裝的工作線程
    final Thread thread;		
    // worker 第一個執(zhí)行的任務(wù)，普通的 Runnable 實現(xiàn)類或者是 FutureTask
    Runnable firstTask;	
    // 記錄當前 worker 所完成任務(wù)數(shù)量
    volatile long completedTasks;	
    
    // 構(gòu)造方法
    Worker(Runnable firstTask) {
        // 設(shè)置AQS獨占模式為初始化中狀態(tài)，這個狀態(tài)不能被搶占鎖
       	setState(-1);
        // firstTask不為空時，當worker啟動后，內(nèi)部線程會優(yōu)先執(zhí)行firstTask，執(zhí)行完后會到queue中去獲取下個任務(wù)
        this.firstTask = firstTask;
        // 使用線程工廠創(chuàng)建一個線程，并且【將當前worker指定為Runnable】，所以thread啟動時會調(diào)用 worker.run()
        this.thread = getThreadFactory().newThread(this);
    }
    // 不可重入鎖，重寫了AQS中的方法
    protected boolean tryAcquire(int unused) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

 protected boolean tryRelease(int unused) {
        setExclusiveOwnerThread(null);
        // 設(shè)置state為0，開始搶鎖
        setState(0);
        return true;
    }
}

// Worker#run
public void run() {
    // 調(diào)用自身的runWoker方法
    runWorker(this);
}

// Worker#runWorker
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    // 獲取 worker 的 firstTask
    Runnable task = w.firstTask;
    // 引用置空，【防止復(fù)用該線程時重復(fù)執(zhí)行該任務(wù)】
    w.firstTask = null;
	// 初始化 worker 時設(shè)置 state = -1，表示不允許搶占鎖
    // 這里需要設(shè)置 state = 0 和 exclusiveOwnerThread = null，開始獨占模式搶鎖
    w.unlock(); 
   // true 表示發(fā)生異常退出，false 表示正常退出。
    boolean completedAbruptly = true;
    try {
        // firstTask 不是 null 就直接運行，否則去 queue 中獲取任務(wù)
        while (task != null || (task = getTask()) != null) {
            // worker 加鎖，shutdown 時會判斷當前 worker 狀態(tài)，【根據(jù)獨占鎖狀態(tài)判斷是否空閑】
            w.lock();
            // 說明線程池狀態(tài)大于 STOP，目前處于 STOP/TIDYING/TERMINATION，此時給線程一個中斷信號
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                // 線程不是處于中斷的情況
                !wt.isInterrupted())
                 // 中斷線程，設(shè)置線程的中斷標志位為 true
                wt.interrupt();
            try {
                // 任務(wù)執(zhí)行前的回調(diào)，空實現(xiàn)，可以在子類中自定義
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    // 真正執(zhí)行任務(wù)
                    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 {
                     // 鉤子方法，【任務(wù)執(zhí)行的后置處理】
                    afterExecute(task, thrown);
                }
            } finally {
                // 將局部變量task置為null，代表任務(wù)執(zhí)行完成
                task = null;
                // 更新worker完成任務(wù)數(shù)量
                w.completedTasks++;
                // 解鎖
                w.unlock();
            }
        }
         // getTask()方法返回null時會走到這里，表示queue為空并且線程空閑超過保活時間，【當前線程執(zhí)行退出邏輯】
        completedAbruptly = false;
    } finally {
        // 正常退出 completedAbruptly = false
       	// 異常退出 completedAbruptly = true，【從 task.run() 內(nèi)部拋出異常】時，跳到這一行
        processWorkerExit(w, completedAbruptly);
    }
}

private Runnable getTask() {
     // 超時標記，表示當前線程獲取任務(wù)是否超時，true 表示已超時
    boolean timedOut = false; 

    for (;;) {
        int c = ctl.get();
         // 獲取線程池當前運行狀態(tài)
        int rs = runStateOf(c);

        // 如果發(fā)現(xiàn)線程池被關(guān)閉了，直接返回null
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            // 使用 CAS 自旋的方式讓 ctl 值 -1
            decrementWorkerCount();
            return null;
        }

        // 獲取線程池中的線程數(shù)量
        int wc = workerCountOf(c);

        //timed用來判斷當前線程是否超過一定時間沒有獲取任務(wù)就進行銷毀回收，true是需要，false不需要， 有兩種情況
        //1. allowCoreThreadTimeOut為true代表允許回收核心線程，那就無所謂了，全部線程都執(zhí)行超時回收
        //2. 線程數(shù)量大于核心線程數(shù)，當前線程認為是非核心線程
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        // 同時滿足下面1和2條件下，說明線程要回收，直接返回null
        // 1. 如果線程數(shù)量超過最大線程數(shù) 或者 上面的timed和超時時間timedOut都為true
        if ((wc > maximumPoolSize || (timed && timedOut))
            // 2.如果線程數(shù)量大于1并且隊列時空的情況
            && (wc > 1 || workQueue.isEmpty())) {
            // 使用 CAS 機制將 ctl 值 -1 ,減 1 成功的線程，返回 null，代表可以退出
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            // 從隊列中獲取任務(wù)，有下面兩種方法
            // timed為true, 調(diào)用超時方法poll獲取任務(wù)
            // timed為false,調(diào)用阻塞方法take獲取
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            獲取任務(wù)為 null 說明超時了，將超時標記設(shè)置為 true，進入下一次循環(huán)，就可以銷毀這個線程了
            timedOut = true;
        } catch (InterruptedException retry) {
             // 阻塞線程被打斷后超時標記置為 false，【說明被打斷不算超時】，要繼續(xù)獲取，直到超時或者獲取到任務(wù)
            // 如果線程池 SHUTDOWN 狀態(tài)下的打斷，會在循環(huán)獲取任務(wù)前判斷，返回 null
            timedOut = false;
        }
    }
}

// 正常退出 completedAbruptly = false，異常退出為 true
private void processWorkerExit(Worker w, boolean completedAbruptly) {
    // 條件成立代表當前 worker 是發(fā)生異常退出的，task 任務(wù)執(zhí)行過程中向上拋出異常了
    if (completedAbruptly) 
        // 從異常時到這里 ctl 一直沒有 -1，需要在這里 -1
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    // 加鎖
    mainLock.lock();
    try {
        // 將當前 worker 完成的 task 數(shù)量，匯總到線程池的 completedTaskCount
        completedTaskCount += w.completedTasks;
		// 將 worker 從線程池中移除
        workers.remove(w);
    } finally {
        mainLock.unlock();	// 解鎖
    }
	// 嘗試停止線程池，喚醒下一個線程
    tryTerminate();

    int c = ctl.get();
    // 線程池不是停止狀態(tài)就應(yīng)該有線程運行【擔保機制】
    if (runStateLessThan(c, STOP)) {
        // 正常退出的邏輯，是對空閑線程回收，不是執(zhí)行出錯
        if (!completedAbruptly) {
            // 根據(jù)是否回收核心線程確定【線程池中的線程數(shù)量最小值】
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            // 最小值為 0，但是線程隊列不為空，需要一個線程來完成任務(wù)擔保機制
            if (min == 0 && !workQueue.isEmpty())
                min = 1;
            // 線程池中的線程數(shù)量大于最小值可以直接返回
            if (workerCountOf(c) >= min)
                return;
        }
        // 執(zhí)行 task 時發(fā)生異常，有個線程因為異常終止了，需要添加
        // 或者線程池中的數(shù)量小于最小值，這里要創(chuàng)建一個新 worker 加進線程池
        addWorker(null, false);
    }
}