// 七個參數(shù)的構造函數(shù)
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

static class DefaultThreadFactory implements ThreadFactory {
    // 省略屬性
    // 構造函數(shù)
    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
        Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
            poolNumber.getAndIncrement() +
            "-thread-";
    }

    // 省略
}

// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

// JDK 1.8 
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();   
    int c = ctl.get();
    // 1.當前線程數(shù)小于corePoolSize,則調用addWorker創(chuàng)建核心線程執(zhí)行任務
    if (workerCountOf(c) < corePoolSize) {
       if (addWorker(command, true))
           return;
       c = ctl.get();
    }
    // 2.如果不小于corePoolSize，則將任務添加到workQueue隊列。
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 2.1 如果isRunning返回false(狀態(tài)檢查)，則remove這個任務，然后執(zhí)行拒絕策略。
        if (! isRunning(recheck) && remove(command))
            reject(command);
            // 2.2 線程池處于running狀態(tài)，但是沒有線程，則創(chuàng)建線程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 3.如果放入workQueue失敗，則創(chuàng)建非核心線程執(zhí)行任務，
    // 如果這時創(chuàng)建非核心線程失敗(當前線程總數(shù)不小于maximumPoolSize時)，就會執(zhí)行拒絕策略。
    else if (!addWorker(command, false))
         reject(command);
}

// 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 ||
                // 1.如果core是ture,證明需要創(chuàng)建的線程為核心線程，則先判斷當前線程是否大于核心線程
                // 如果core是false,證明需要創(chuàng)建的是非核心線程，則先判斷當前線程數(shù)是否大于總線程數(shù)
                // 如果不小于，則返回false
                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
        }
    }

    // ThreadPoolExecutor.addWorker方法源碼下半部分
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        // 1.創(chuàng)建一個worker對象
        w = new Worker(firstTask);
        // 2.實例化一個Thread對象
        final Thread t = w.thread;
        if (t != null) {
            // 3.線程池全局鎖
            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) {
                // 4.啟動這個線程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

// Worker類部分源碼
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);
    }
    //其余代碼略...
}

// Worker.runWorker方法源代碼
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    // 1.線程啟動之后，通過unlock方法釋放鎖
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // 2.Worker執(zhí)行firstTask或從workQueue中獲取任務，如果getTask方法不返回null,循環(huán)不退出
        while (task != null || (task = getTask()) != null) {
            // 2.1進行加鎖操作，保證thread不被其他線程中斷（除非線程池被中斷）
            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
            // 2.2檢查線程池狀態(tài)，倘若線程池處于中斷狀態(tài)，當前線程將中斷。 
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                // 2.3執(zhí)行beforeExecute 
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    // 2.4執(zhí)行任務
                    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 {
                    // 2.5執(zhí)行afterExecute方法 
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                // 2.6解鎖操作
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

// Worker.getTask方法源碼
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }

        int wc = workerCountOf(c);

        // Are workers subject to culling?
        // 1.allowCoreThreadTimeOut變量默認是false,核心線程即使空閑也不會被銷毀
        // 如果為true,核心線程在keepAliveTime內仍空閑則會被銷毀。 
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        // 2.如果運行線程數(shù)超過了最大線程數(shù)，但是緩存隊列已經空了，這時遞減worker數(shù)量。 
　　　　 // 如果有設置允許線程超時或者線程數(shù)量超過了核心線程數(shù)量，
        // 并且線程在規(guī)定時間內均未poll到任務且隊列為空則遞減worker數(shù)量
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            // 3.如果timed為true(想想哪些情況下timed為true),則會調用workQueue的poll方法獲取任務.
            // 超時時間是keepAliveTime。如果超過keepAliveTime時長，
            // poll返回了null，上邊提到的while循序就會退出，線程也就執(zhí)行完了。
            // 如果timed為false（allowCoreThreadTimeOut為false
            // 且wc > corePoolSize為false），則會調用workQueue的take方法阻塞在當前。
            // 隊列中有任務加入時，線程被喚醒，take方法返回任務，并執(zhí)行。
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

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

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 ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}