public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)

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

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

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

//Executor#execute
public interface Executor {
 void execute(Runnable command);
}

//ThreadPoolExecutor#execute
public void execute(Runnable command) {
　　if (command == null) 
  throw new NullPointerException();
　　int c = ctl.get(); 
 …
}

//ThreadPoolExecutor
private static final int COUNT_BITS = Integer.SIZE – 3;  //32-3=29，線程數(shù)量所占位數(shù)
private static final int CAPACITY = (1 << COUNT_BITS) – 1; //低29位表示最大線程數(shù)，229-1
//五種線程池狀態(tài)
private static final int RUNNING = -1 << COUNT_BITS; /int型變量高3位（含符號位）101表RUNING
private static final int SHUTDOWN = 0 << COUNT_BITS; //高3位000
private static final int STOP = 1 << COUNT_BITS; //高3位001
private static final int TIDYING = 2 << COUNT_BITS; //高3位010
private static final int TERMINATED = 3 << COUNT_BITS; //高3位011

//ThreadPoolExecutor#execute
public void execute(Runnable command) {
 if (command == null) 
  throw new NullPointerException();
　　 int c = ctl.get(); //由它可以獲取到當前有效的線程數(shù)和線程池的狀態(tài)
/*1.獲取當前正在運行線程數(shù)是否小于核心線程池，是則新創(chuàng)建一個線程執(zhí)行任務，否則將任務放到任務隊列中*/
 if (workerCountOf(c) < corePoolSize){
  if (addWorker(command, tre))  //在addWorker中創(chuàng)建工作線程執(zhí)行任務
   return ;
  c = ctl.get();
 }
/*2.當前核心線程池中全部線程都在運行workerCountOf(c) >= corePoolSize，所以此時將線程放到任務隊列中*/
 if (isRunning(c) && workQueue.offer(command)) { //線程池是否處于運行狀態(tài)，且是否任務插入任務隊列成功
  int recheck = ctl.get();
　　　　 if (!isRunning(recheck) && remove(command))  //線程池是否處于運行狀態(tài)，如果不是則使剛剛的任務出隊
　　　　　　 reject(command); //拋出RejectedExceptionException異常
　　　　 else if (workerCountOf(recheck) == 0)
　　　　　　 addWorker(null, false);
　　}
/*3.插入隊列不成功，且當前線程數(shù)數(shù)量小于最大線程池數(shù)量，此時則創(chuàng)建新線程執(zhí)行任務，創(chuàng)建失敗拋出異常*/
　　else if (!addWorker(command, false)){
　　　　reject(command); //拋出RejectedExceptionException異常
　　}
}

//ThreadPoolExecutor#addWorker
private boolean addWorker(Runnable firstTask, boolean core) {
/*首先會再次檢查線程池是否處于運行狀態(tài)，核心線程池中是否還有空閑線程，都滿足條件過后則會調(diào)用compareAndIncrementWorkerCount先將正在運行的線程數(shù)+1，數(shù)量自增成功則跳出循環(huán)，自增失敗則繼續(xù)從頭繼續(xù)循環(huán)*/
　　...
　　if (compareAndIncrementWorkerCount(c))
　　　　break retry;
　　...
/*正在運行的線程數(shù)自增成功后則將線程封裝成工作線程Worker*/
　　boolean workerStarted = false;
　　boolean workerAdded = false;
　　Worker w = null;
　　try {
　　　　final ReentrantLock mainLock = this.mainLock;  //全局鎖
　　　　w = new Woker(firstTask);  //將線程封裝為Worker工作線程
　　　　final Thread t = w.thread;
　　　　if (t != null) {
　　　　　　mainLock.lock(); //獲取全局鎖
/*當持有了全局鎖的時候，還需要再次檢查線程池的運行狀態(tài)等*/
　　　　　　try {
　　　　　　　　int c = clt.get();
　　　　　　　　int rs = runStateOf(c);  //線程池運行狀態(tài)
　　　　　　　　if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)){  //線程池處于運行狀態(tài)，或者線程池關(guān)閉且任務線程為空
　　　　　　　　　　if (t.isAlive()) //線程處于活躍狀態(tài)，即線程已經(jīng)開始執(zhí)行或者還未死亡，正確的應線程在這里應該是還未開始執(zhí)行的
　　　　　　　　　　　　throw new IllegalThreadStateException();
　　　　　　　　　　workers.add(w); //private final HashSet<Worker> wokers = new HashSet<Worker>();包含線程池中所有的工作線程，只有在獲取了全局的時候才能訪問它。將新構(gòu)造的工作線程加入到工作線程集合中
　　　　　　　　　　int s = worker.size(); //工作線程數(shù)量
　　　　　　　　　　if (s > largestPoolSize)
　　　　　　　　　　　　largestPoolSize = s;
　　　　　　　　　　workerAdded = true; //新構(gòu)造的工作線程加入成功
　　　　　　　　}
　　　　　　} finally {
　　　　　　　　mainLock.unlock();
　　　　　　}
　 　　　　if (workerAdded) {
　　　　　　　　t.start(); //在被構(gòu)造為Worker工作線程，且被加入到工作線程集合中后，執(zhí)行線程任務，注意這里的start實際上執(zhí)行Worker中run方法，所以接下來分析Worker的run方法
　　　　　　　　workerStarted = true;
　　　　　　}
　　　　}
　　} finally {
　　　　if (!workerStarted) //未能成功創(chuàng)建執(zhí)行工作線程
　　　　　　addWorkerFailed(w); //在啟動工作線程失敗后，將工作線程從集合中移除
　　}
　　return workerStarted;
}

//ThreadPoolExecutor$Worker，它繼承了AQS，同時實現(xiàn)了Runnable，所以它具備了這兩者的所有特性
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
　　final Thread thread;
　　Runnable firstTask;
　　public Worker(Runnable firstTask) {
　　　　setState(-1); //設(shè)置AQS的同步狀態(tài)為-1，禁止中斷，直到調(diào)用runWorker
　　　　this.firstTask = firstTask;
　　　　this.thread = getThreadFactory().newThread(this); //通過線程工廠來創(chuàng)建一個線程，將自身作為Runnable傳遞傳遞
　　}
　　public void run() {
　　　　runWorker(this); //運行工作線程
　　}
}