Interface Executor(){
    void execute(Runnable command);

}

interface ExecutorService extends Executor{
    
}

abstract class AbstractExecutorService implements ExecutorService{    //此處把ExecutorService中的提交方法都實現(xiàn)了
}

 public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) { // ① 
            //核心線程數(shù)沒有滿就繼續(xù)添加核心線程
            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) // ⑤
                //如果worker為0，則添加一個非核心worker，所以線程池里至少有一個線程
                addWorker(null, false);// ⑥
        }
        //隊列滿了以后，添加非核心線程
        else if (!addWorker(command, false))// ⑧
            reject(command);//⑦
    }

ThreadPoolExecutor extends AbstractExecutorService{
    //保存所有的執(zhí)行線程（worker）
    HashSet<Worker> workers = new HashSet<Worker>();
    //存放待執(zhí)行的任務，這塊具體由指定的隊列實現(xiàn)

    BlockingQueue<Runnable> workQueue;
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler){
    }
    //添加執(zhí)行worker
    private boolean addWorker(Runnable firstTask, boolean core) {
        //這里每次都會基礎校驗和cas校驗，防止并發(fā)無法創(chuàng)建線程，
        retry:
        for(;;){
            for(;;){
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }
        try{
            //創(chuàng)建一個worker
            w = new Worker(firstTask);
            final Thread t = w.thread;
            try{
                //加鎖校驗，添加到workers集合中
                workers.add(w);
            }
            //添加成功，將對應的線程啟動，執(zhí)行任務
            t.start();
        }finally{
             //失敗執(zhí)行進行釋放資源
            addWorkerFailed(Worker w) 
        }
  
       
    }
    //Worker 是對任務和線程的封裝
    private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
        //線程啟動后會循環(huán)執(zhí)行任務
        public void run() {
            runWorker(this);
        }

    }

    //循環(huán)執(zhí)行
    final void runWorker(Worker w) {
        try{
            while (task != null || (task = getTask()) != null) {
                //執(zhí)行前的可擴展點
                beforeExecute(wt, task);
                try{
                     //執(zhí)行任務
                    task.run();
                }finally{
                    //執(zhí)行后的可擴展點，這塊也把異常給吃了
                    afterExecute(task, thrown);
                }
            }
            //這里會對執(zhí)行的任務進行統(tǒng)計
        }finally{
             //異常或者是循環(huán)退出都會走這里
             processWorkerExit(w, completedAbruptly);
        }
    }
    //獲取執(zhí)行任務，此處決定runWorker的狀態(tài)
    private Runnable getTask() {
        //worker的淘汰策略：允許超時或者工作線程>核心線程
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        //滿足淘汰策略且...，就返回null，交由processWorkerExit去處理線程
        if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
        // 滿足淘汰策略，就等一定的時間poll()，不滿足，就一直等待take()
        Runnable r = timed ?workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :workQueue.take();
    }
    //處理任務退出（循環(huán)獲取不到任務的時候）
    private void processWorkerExit(Worker w, boolean completedAbruptly) {
        //異常退出的，不能調整線程數(shù)的
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();
        
        //不管成功或失敗，都執(zhí)行以下邏輯
        //1，計數(shù)，2，減去一個線程

        completedTaskCount += w.completedTasks;
        //將線程移除，并不關心是否非核心
        workers.remove(w);
        //如果是還是運行狀態(tài)

        if (!completedAbruptly) {
            //正常終止的，處理邏輯
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            //核心線程為0 ，最小值也是1
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            //總線程數(shù)大于min就不再添加
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }        //異常退出一定還會添加worker，正常退出一般不會再添加線程，除非核心線程數(shù)為0
        addWorker(null, false);
    }
    
}

    public boolean prestartCoreThread() {
        return workerCountOf(ctl.get()) < corePoolSize &&
            addWorker(null, true);
    }
    void ensurePrestart() {
        int wc = workerCountOf(ctl.get());
        if (wc < corePoolSize)
            addWorker(null, true);
        else if (wc == 0)
            addWorker(null, false);
    }

    public int prestartAllCoreThreads() {
        int n = 0;
        while (addWorker(null, true))
            ++n;
        return n;
    }

    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 LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

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

    public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }