public class Executors {
	public static ExecutorService newFixedThreadPool(int nThreads) {
        	return new ThreadPoolExecutor(nThreads, nThreads,
                             	         0L, TimeUnit.MILLISECONDS,
                            	          new LinkedBlockingQueue<Runnable>());
  	  }
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<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);
    }

    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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
}

// 構(gòu)造器一
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
        Executors.defaultThreadFactory(), defaultHandler);
    }
	// 構(gòu)造器二
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }
	// 構(gòu)造器三
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

//創(chuàng)建一個可緩存的線程池
        ExecutorService cachedThreadPool= Executors.newCachedThreadPool();
        //通過execute方法執(zhí)行接口
        cachedThreadPool.execute(()->{
            //Runnable to do something.
        });

        ExecutorService threadPool = new ThreadPoolExecutor(// 自定義一個線程池
                1, // 核心線程數(shù)
                2, // 最大線程數(shù)
                60, // 超過核心線程數(shù)的額外線程存活時間
                TimeUnit.SECONDS, // 線程存活時間的時間單位
                new ArrayBlockingQueue<>(3) // 有界隊列，容量是3個
                , Executors.defaultThreadFactory()    // 線程工廠
                , new ThreadPoolExecutor.AbortPolicy() //線程的拒絕策略
        );
        //執(zhí)行一個任務
        threadPool.execute(()->{
            //線程執(zhí)行的具體邏輯
            //Runnable to do something.
        });

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            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)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

    private boolean addWorker(Runnable firstTask, boolean core) {
     	// 外層循環(huán)，負責判斷線程池狀態(tài)，處理線程池狀態(tài)變量加1操作
        retry:
        for (;;) {
		    // 狀態(tài)總體相關(guān)值：運行狀態(tài) + 執(zhí)行線程任務數(shù)量 
            int c = ctl.get();
			// 讀取狀態(tài)值 - 運行狀態(tài)
            int rs = runStateOf(c);
            // Check if queue empty only if necessary.
			// 滿足下面兩大條件的，說明線程池不能接受任務了，直接返回false處理
			// 主要目的就是想說，只有線程池的狀態(tài)為 RUNNING 狀態(tài)時，線程池才會接收
			// 新的任務，增加新的Worker工作線程
			// 線程池的狀態(tài)已經(jīng)至少已經(jīng)處于不能接收任務的狀態(tài)了
            if (rs >= SHUTDOWN &&
			  //目的是檢查線 程池是否處于關(guān)閉狀態(tài)
                ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()))
                       return false;
				// 內(nèi)層循環(huán)，負責worker數(shù)量加1操作
				for (;;) {
				// 獲取當前worker線程數(shù)量
					int wc = workerCountOf(c);
					if (wc >= CAPACITY ||
						// 如果線程池數(shù)量達到最大上限值CAPACITY
						// core為true時判斷是否大于corePoolSize核心線程數(shù)量
						// core為false時判斷是否大于maximumPoolSize最大設(shè)置的線程數(shù)量
						wc >= (core ? corePoolSize : maximumPoolSize))
						return false;
					// 調(diào)用CAS原子操作，目的是worker線程數(shù)量加1
					if (compareAndIncrementWorkerCount(c)) //
						break retry;
					c = ctl.get();  // Re-read ctl
					// CAS原子操作失敗的話，則再次讀取ctl值
					if (runStateOf(c) != rs)
					// 如果剛剛讀取的c狀態(tài)不等于先前讀取的rs狀態(tài)，則繼續(xù)外層循環(huán)判斷
						continue retry;
					// else CAS failed due to workerCount change; retry inner loop
					// 之所以會CAS操作失敗，主要是由于多線程并發(fā)操作，導致workerCount
					// 工作線程數(shù)量改變而導致的，因此繼續(xù)內(nèi)層循環(huán)嘗試操作
				}
        }
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
			// 創(chuàng)建一個Worker工作線程對象，將任務firstTask，
			// 新創(chuàng)建的線程thread都封裝到了Worker對象里面
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
				// 由于對工作線程集合workers的添加或者刪除，
				// 涉及到線程安全問題，所以才加上鎖且該鎖為非公平鎖
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
					// 獲取鎖成功后，執(zhí)行臨界區(qū)代碼，首先檢查獲取當前線程池的狀態(tài)rs
                    int rs = runStateOf(ctl.get());
					// 當線程池處于可接收任務狀態(tài)
					// 或者是不可接收任務狀態(tài)，但是有可能該任務等待隊列中的任務
					// 滿足這兩種條件時，都可以添加新的工作線程
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                         workers.add(w);
						// 添加新的工作線程到工作線程集合workers，workers是set集合
                        int s = workers.size();
                        if (s > largestPoolSize) 
						// 變量記錄了線程池在整個生命周期中曾經(jīng)出現(xiàn)的最大線程個數(shù)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) { 
				// 往workers工作線程集合中添加成功后，則立馬調(diào)用線程start方法啟動起來
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
			// 如果啟動線程失敗的話，還得將剛剛添加成功的線程共集合中移除并且做線				// 程數(shù)量做減1操作
                addWorkerFailed(w);
        }
        return workerStarted;
    }

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
		// allow interrupts 允許中斷
        w.unlock();
        boolean completedAbruptly = true;
        try {
			// 不斷從等待隊列blockingQueue中獲取任務
			// 之前addWorker(null, false)這樣的線程執(zhí)行時，
			// 會通過getTask中再次獲取任務并執(zhí)行
            while (task != null || (task = getTask()) != null) {
                w.lock(); 
				// 上鎖，并不是防止并發(fā)執(zhí)行任務，
				// 而是為了防止shutdown()被調(diào)用時不終止正在運行的worker線程
                // 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
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
					// task.run()執(zhí)行前，由子類實現(xiàn)
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run(); // 執(zhí)行線程Runable的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 {
						// task.run()執(zhí)行后，由子類實現(xiàn)
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

        threadPool.shutdown();
        threadPool.shutdownNow();