//（高3位）表示線程池狀態(tài)，（低29位）表示線程池中線程的個數(shù)；
// 默認(rèn)狀態(tài)是RUNNING，線程池中線程個數(shù)為0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

//表示具體平臺下Integer的二進(jìn)制位數(shù)-3后的剩余位數(shù)表示的數(shù)才是線程的個數(shù);
//其中Integer.SIZE=32,-3之后的低29位表示的就是線程的個數(shù)了
private static final int COUNT_BITS = Integer.SIZE - 3;

//線程最大個數(shù)（低29位）00011111111111111111111111111111（1<<29-1）
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

//線程池狀態(tài)（高3位表示線程池狀態(tài)）
//111 00000000000000000000000000000
private static final int RUNNING    = -1 << COUNT_BITS;

//000 00000000000000000000000000000
private static final int SHUTDOWN   =  0 << COUNT_BITS;

//001 00000000000000000000000000000
private static final int STOP       =  1 << COUNT_BITS;

//010 00000000000000000000000000000
private static final int TIDYING    =  2 << COUNT_BITS;

//011 00000000000000000000000000000
private static final int TERMINATED =  3 << COUNT_BITS;

//獲取高3位（運(yùn)行狀態(tài)）==> c & 11100000000000000000000000000000
private static int runStateOf(int c)     { return c & ~CAPACITY; }

//獲取低29位（線程個數(shù)）==> c &  00011111111111111111111111111111
private static int workerCountOf(int c)  { return c & CAPACITY; }

//計算原子變量ctl新值（運(yùn)行狀態(tài)和線程個數(shù)）
private static int ctlOf(int rs, int wc) { return rs | wc; }

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

//獨(dú)占鎖，用來控制新增工作線程Worker操作的原子性
private final ReentrantLock mainLock = new ReentrantLock();

//工作線程集合，Worker繼承了AQS接口和Runnable接口，是具體處理任務(wù)的線程對象
//Worker實(shí)現(xiàn)AQS，并自己實(shí)現(xiàn)了簡單不可重入獨(dú)占鎖，其中state=0表示當(dāng)前鎖未被獲取狀態(tài)，state=1表示鎖被獲取，
//state=-1表示W(wǎng)ork創(chuàng)建時候的默認(rèn)狀態(tài)，創(chuàng)建時候設(shè)置state=-1是為了防止runWorker方法運(yùn)行前被中斷
private final HashSet<Worker> workers = new HashSet<Worker>();

//termination是該鎖對應(yīng)的條件隊列，在線程調(diào)用awaitTermination時候用來存放阻塞的線程
private final Condition termination = mainLock.newCondition();

public void execute(Runnable command) {
    //（1）首先檢查任務(wù)是否為null，為null拋出異常，否則進(jìn)行下面的步驟
    if (command == null)
        throw new NullPointerException();
    //（2）ctl值中包含了當(dāng)前線程池的狀態(tài)和線程池中的線程數(shù)量
    int c = ctl.get();
    //（3）workerCountOf方法是獲取低29位，即獲取當(dāng)前線程池中的線程個數(shù)，如果小于corePoolSize，就開啟新的線程運(yùn)行
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    //（4）如果線程池處理RUNNING狀態(tài)，就添加任務(wù)到阻塞隊列中
    if (isRunning(c) && workQueue.offer(command)) {
        //（4-1）二次檢查，獲取ctl值
        int recheck = ctl.get();
        //（4-2）如果當(dāng)前線程池不是出于RUNNING狀態(tài)，就從隊列中刪除任務(wù)，并執(zhí)行拒絕策略
        if (! isRunning(recheck) && remove(command))
            reject(command);
        //（4-3）否則，如果線程池為空，就添加一個線程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    //（5）如果隊列滿，則新增線程，如果新增線程失敗，就執(zhí)行拒絕策略
    else if (!addWorker(command, false))
        reject(command);
}

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

        //(6)檢查隊列是否只在必要時候?yàn)榭?
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        //(7)使用CAS增加線程個數(shù)
        for (;;) {
            //根據(jù)ctl值獲得當(dāng)前線程池中的線程數(shù)量
            int wc = workerCountOf(c);
            //(7-1)如果線程數(shù)量超出限制，返回false
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //(7-2)CAS增加線程數(shù)量，同時只有一個線程可以成功
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // 重新讀取ctl值
            //(7-3)CAS失敗了，需要查看當(dāng)前線程池狀態(tài)是否發(fā)生變化，如果發(fā)生變化需要跳轉(zhuǎn)到外層循環(huán)嘗試重新獲取線程池狀態(tài)，否則內(nèi)層循環(huán)重新進(jìn)行CAS增加線程數(shù)量
            if (runStateOf(c) != rs)
                continue retry;
        }
    }

    //(8)執(zhí)行到這里說明CAS增加新線程個數(shù)成功了，我們需要開始創(chuàng)建新的工作線程Worker
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        //(8-1)創(chuàng)建新的worker
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            //(8-2)加獨(dú)占鎖，保證workers的同步，可能線程池中的多個線程調(diào)用了線程池的execute方法
            mainLock.lock();
            try {
                // (8-3)重新檢查線程池狀態(tài)，以免在獲取鎖之前調(diào)用shutdown方法改變線程池狀態(tài)
                int rs = runStateOf(ctl.get());

                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    //(8-4)添加新任務(wù)
                    workers.add(w);
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            //(8-6)添加新任務(wù)成功之后，啟動任務(wù)
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    //獲取鎖
    mainLock.lock();
    try {
      //如果worker不為null
      if (w != null)
          //workers移除worker
          workers.remove(w);
      //通過CAS操作，workerCount-1
      decrementWorkerCount();
      tryTerminate();
    } finally {
      //釋放鎖
      mainLock.unlock();
    }
}

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{

    /** 使用線程工廠創(chuàng)建的線程，執(zhí)行任務(wù) */
    final Thread thread;
    /** 初始化執(zhí)行任務(wù) */
    Runnable firstTask;
    /** 計數(shù) */
    volatile long completedTasks;

    /**
     * 給出初始firstTask，線程創(chuàng)建工廠創(chuàng)建新的線程
     */
    Worker(Runnable firstTask) {
        setState(-1); // 防止在調(diào)用runWorker之前被中斷
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this); //使用threadFactory創(chuàng)建線程
    }

    /** run方法實(shí)際上執(zhí)行的是runWorker方法  */
    public void run() {
        runWorker(this);
    }

    // 關(guān)于同步狀態(tài)（鎖）
    //
    // 同步狀態(tài)state=0表示鎖未被獲取
    // 同步狀態(tài)state=1表示鎖被獲取

    protected boolean isHeldExclusively() {
        return getState() != 0;
    }

    //下面都是重寫AQS的方法，Worker為自定義的同步組件
    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) {
            }
        }
    }
}

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // 這個時候調(diào)用unlock方法，將state置為0，就可以被中斷了
    boolean completedAbruptly = true;
    try {
        //(10)如果當(dāng)前任務(wù)為null，或者從任務(wù)隊列中獲取到的任務(wù)為null，就跳轉(zhuǎn)到(11)處執(zhí)行清理工作
        while (task != null || (task = getTask()) != null) {
            //task不為null，就需要線程執(zhí)行任務(wù)，這個時候，需要獲取工作線程內(nèi)部持有的獨(dú)占鎖
            w.lock();
            /**如果線程池已被停止(STOP)(至少大于STOP狀態(tài))，要確保線程都被中斷
             * 如果狀態(tài)不對，檢查當(dāng)前線程是否中斷并清除中斷狀態(tài)，并且再次檢查線程池狀態(tài)是否大于STOP
             * 如果上述滿足，檢查該對象是否處于中斷狀態(tài)，不清除中斷標(biāo)記
             */
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                //中斷該對象
                wt.interrupt();
            try {
                //執(zhí)行任務(wù)之前要做的事情
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    task.run(); //執(zhí)行任務(wù)
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    //執(zhí)行任務(wù)之后的方法
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                //更新當(dāng)前已完成任務(wù)數(shù)量
                w.completedTasks++;
                //釋放鎖
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        //執(zhí)行清理工作：處理并退出當(dāng)前worker
        processWorkerExit(w, completedAbruptly);
    }
}

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    /*
    *completedAbruptly:是由runWorker傳過來的參數(shù)，表示是否突然完成的意思
    *當(dāng)在就是在執(zhí)行任務(wù)過程當(dāng)中出現(xiàn)異常，就會突然完成，傳true
    *
    *如果是突然完成，需要通過CAS操作，更新workerCount(-1操作)
    *不是突然完成，則不需要-1，因?yàn)間etTask方法當(dāng)中已經(jīng)-1(getTask方法中執(zhí)行了decrementWorkerCount()方法)
    */
    if (completedAbruptly)
        decrementWorkerCount();
    //(1-1)在統(tǒng)計完成任務(wù)個數(shù)之前加上全局鎖，然后統(tǒng)計線程池中完成的任務(wù)個數(shù)并更新全局計數(shù)器，并從工作集中刪除當(dāng)前worker
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock(); //獲得全局鎖
    try {
        completedTaskCount += w.completedTasks; //更新已完成的任務(wù)數(shù)量
        workers.remove(w); //將完成該任務(wù)的線程worker從工作線程集合中移除
    } finally {
        mainLock.unlock(); //釋放鎖
    }
    /**(1-2)
     * 這一個方法調(diào)用完成了下面的事情：
     * 判斷如果當(dāng)前線程池狀態(tài)是SHUTDOWN并且工作隊列為空，
     * 或者當(dāng)前線程池狀態(tài)是STOP并且當(dāng)前線程池里面沒有活動線程，
     * 則設(shè)置當(dāng)前線程池狀態(tài)為TERMINATED，如果設(shè)置成了TERMINATED狀態(tài)，
     * 還需要調(diào)用條件變量termination的signAll方法激活所有因?yàn)檎{(diào)用線程池的awaitTermination方法而被阻塞的線程
     */
    tryTerminate();

    //（1-3）如果當(dāng)前線程池中線程數(shù)小于核心線程，則增加核心線程數(shù)
    int c = ctl.get();
    //判斷當(dāng)前線程池的狀態(tài)是否小于STOP（RUNNING或者SHUTDOWN）
    if (runStateLessThan(c, STOP)) {
        //如果任務(wù)忽然完成，執(zhí)行后續(xù)的代碼
        if (!completedAbruptly) {
            //allowCoreThreadTimeOut表示是否允許核心線程超時，默認(rèn)為false
            //min這里當(dāng)默認(rèn)為allowCoreThreadTimeOut默認(rèn)為false的時候，min置為coorPoolSize
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            //這里說明：如果允許核心線程超時，那么allowCoreThreadTimeOut可為true，那么min值為0，不需要維護(hù)核心線程了
            //如果min為0并且任務(wù)隊列不為空
            if (min == 0 && ! workQueue.isEmpty())
                min = 1; //這里表示如果min為0，且隊列不為空，那么至少需要一個核心線程存活來保證任務(wù)的執(zhí)行
            //如果工作線程數(shù)大于min,表示當(dāng)前線程數(shù)滿足，直接返回
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        addWorker(null, false);
    }
}

final void tryTerminate() {
    for (;;) {
        //獲取線程池狀態(tài)
        int c = ctl.get();
        //如果線程池狀態(tài)為RUNNING
        //或者狀態(tài)大于TIDYING
        //或者狀態(tài)==SHUTDOWN并未任務(wù)隊列不為空
        //直接返回，不能調(diào)用terminated方法
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;
        //如果線程池中工作線程數(shù)不為0，需要中斷線程
        if (workerCountOf(c) != 0) { // Eligible to terminate
            interruptIdleWorkers(ONLY_ONE);
            return;
        }
        //獲得線程池的全局鎖
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //通過CAS操作，將線程池狀態(tài)設(shè)置為TIDYING
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { //private static int ctlOf(int rs, int wc) { return rs | wc; }
                try {
                    //調(diào)用terminated方法
                    terminated();
                } finally {
                    //最終將線程狀態(tài)設(shè)置為TERMINATED
                    ctl.set(ctlOf(TERMINATED, 0));
                    //調(diào)用條件變量termination的signaAll方法喚醒所有因?yàn)?
                    //調(diào)用線程池的awaitTermination方法而被阻塞的線程
                    //private final Condition termination = mainLock.newCondition();
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

public void shutdown() {
    //獲得線程池的全局鎖
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //進(jìn)行權(quán)限檢查
        checkShutdownAccess();

        //設(shè)置當(dāng)前線程池的狀態(tài)的SHUTDOWN，如果線程池狀態(tài)已經(jīng)是該狀態(tài)就會直接返回，下面我們會分析這個方法的源碼
        advanceRunState(SHUTDOWN);

        //設(shè)置中斷 標(biāo)志
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    //嘗試將狀態(tài)變?yōu)門ERMINATED，上面已經(jīng)分析過該方法的源碼
    tryTerminate();
}

private void advanceRunState(int targetState) {
    for (;;) {
        //下面的方法執(zhí)行的就是：
        //首先獲取線程的ctl值，然后判斷當(dāng)前線程池的狀態(tài)如果已經(jīng)是SHUTDOWN，那么if條件第一個為真就直接返回
        //如果不是SHUTDOWN狀態(tài)，就需要CAS的設(shè)置當(dāng)前狀態(tài)為SHUTDOWN
        int c = ctl.get();
        if (runStateAtLeast(c, targetState) ||
            //private static int ctlOf(int rs, int wc) { return rs | wc; }
            ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
            break;
    }
}

private void interruptIdleWorkers() {
    interruptIdleWorkers(false);
}
private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers) {
            Thread t = w.thread;
            //如果工作線程沒有被中斷，并且沒有正在運(yùn)行設(shè)置中斷標(biāo)志
            if (!t.isInterrupted() && w.tryLock()) {
                try {
                    //需要中斷當(dāng)前線程
                    t.interrupt();
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne)
                break;
        }
    } finally {
        mainLock.unlock();
    }
}

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess(); //還是進(jìn)行權(quán)限檢查
        advanceRunState(STOP); //設(shè)置線程池狀態(tài)臺STOP
        interruptWorkers(); //中斷所有線程
        tasks = drainQueue(); //將任務(wù)隊列中的任務(wù)移動到task中
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks; //返回tasks
}

private void interruptWorkers() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers) //不需要判斷當(dāng)前線程是否在執(zhí)行任務(wù)（即不需要調(diào)用w.tryLock方法），中斷所有線程
            w.interruptIfStarted();
    } finally {
        mainLock.unlock();
    }
}

//調(diào)用該方法之后，會阻塞調(diào)用者線程，直到線程池狀態(tài)為TERMINATED狀態(tài)才會返回，或者等到超時時間到之后會返回
public boolean awaitTermination(long timeout, TimeUnit unit)
    throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //阻塞當(dāng)前線程，（獲取了Worker自己的鎖），那么當(dāng)前線程就不會再執(zhí)行任務(wù)（因?yàn)楂@取不到鎖）
        for (;;) {
            //當(dāng)前線程池狀態(tài)為TERMINATED狀態(tài)，會返回true
            if (runStateAtLeast(ctl.get(), TERMINATED))
                return true;
            //超時時間到返回false
            if (nanos <= 0)
                return false;
            nanos = termination.awaitNanos(nanos);
        }
    } finally {
        mainLock.unlock();
    }
}