public ThreadPoolExecutor(int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue) {
 this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
  Executors.defaultThreadFactory(), defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory) {
 this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
  threadFactory, defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    RejectedExecutionHandler handler) {
 this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
  Executors.defaultThreadFactory(), handler);
}

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;
}

/**
 * The default thread factory
 */
static class DefaultThreadFactory implements ThreadFactory {
 private static final AtomicInteger poolNumber = new AtomicInteger(1);
 private final ThreadGroup group;
 private final AtomicInteger threadNumber = new AtomicInteger(1);
 private final String namePrefix;

 DefaultThreadFactory() {
 SecurityManager s = System.getSecurityManager();
 group = (s != null) ? s.getThreadGroup() :
    Thread.currentThread().getThreadGroup();
 namePrefix = "pool-" +
   poolNumber.getAndIncrement() +
   "-thread-";
 }

 public Thread newThread(Runnable r) {
 Thread t = new Thread(group, r,
    namePrefix + threadNumber.getAndIncrement(),
    0);
 if (t.isDaemon())
  t.setDaemon(false);
 if (t.getPriority() != Thread.NORM_PRIORITY)
  t.setPriority(Thread.NORM_PRIORITY);
 return t;
 }
}

volatile int runState;
// 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;

public boolean prestartCoreThread() {
 return addIfUnderCorePoolSize(null); //注意傳進去的參數(shù)是null
}

public int prestartAllCoreThreads() {
 int n = 0;
 while (addIfUnderCorePoolSize(null))//注意傳進去的參數(shù)是null
 ++n;
 return n;
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyTest {
	public static void main(String[] args) {
		// 創(chuàng)建線程池
		ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 5, 5, TimeUnit.SECONDS,
				new ArrayBlockingQueue<Runnable>(5));
		// 向線程池提交任務(wù)
		for (int i = 0; i < threadPool.getCorePoolSize(); i++) {
			threadPool.execute(new Runnable() {
				@Override
				public void run() {
					for (int x = 0; x < 2; x++) {
						System.out.println(Thread.currentThread().getName() + ":" + x);
						try {
							Thread.sleep(2000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}
			});
		}

		// 關(guān)閉線程池
		threadPool.shutdown(); // 設(shè)置線程池的狀態(tài)為SHUTDOWN，然后中斷所有沒有正在執(zhí)行任務(wù)的線程
		// threadPool.shutdownNow(); // 設(shè)置線程池的狀態(tài)為STOP，然后嘗試停止所有的正在執(zhí)行或暫停任務(wù)的線程，并返回等待執(zhí)行任務(wù)的列表，該方法要慎用，容易造成不可控的后果
	}
}

// 使用默認(rèn)線程工廠
public static ExecutorService newFixedThreadPool(int nThreads) {
 return new ThreadPoolExecutor(nThreads, nThreads,
     0L, TimeUnit.MILLISECONDS,
     new LinkedBlockingQueue<Runnable>());
}
// 需要自定義線程工廠
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
 return new ThreadPoolExecutor(nThreads, nThreads,
     0L, TimeUnit.MILLISECONDS,
     new LinkedBlockingQueue<Runnable>(),
     threadFactory);
}

// 1. 創(chuàng)建線程池對象，設(shè)置核心線程和最大線程數(shù)為5
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
// 2. 創(chuàng)建Runnable（任務(wù)）
Runnable task =new Runnable(){
 public void run() {
 System.out.println(Thread.currentThread().getName() + "--->運行");
 }
};
// 3. 向線程池提交任務(wù)
fixedThreadPool.execute(task);

public static ExecutorService newSingleThreadExecutor() {
 return new FinalizableDelegatedExecutorService
 (new ThreadPoolExecutor(1, 1,
    0L, TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue<Runnable>()));
}
// 為節(jié)省篇幅，省略了自定義線程工廠方式的源碼

// 1. 創(chuàng)建單線程線程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 2. 創(chuàng)建Runnable（任務(wù)）
Runnable task = new Runnable(){
 public void run() {
 System.out.println(Thread.currentThread().getName() + "--->運行");
 }
};
// 3. 向線程池提交任務(wù)
singleThreadExecutor.execute(task);

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

// 繼承了 ThreadPoolExecutor
public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor
 implements ScheduledExecutorService {
 // 構(gòu)造函數(shù)，省略了自定義線程工廠的構(gòu)造函數(shù)
	public ScheduledThreadPoolExecutor(int corePoolSize) {
 	super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
  	new DelayedWorkQueue());
	}
	
	// 延時執(zhí)行任務(wù)
	public ScheduledFuture<?> schedule(Runnable command,
     long delay,
     TimeUnit unit) {
 ...
 }
	// 定時執(zhí)行任務(wù)
	public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
       long initialDelay,
       long period,
       TimeUnit unit) {...}
}

// 1. 創(chuàng)建定時線程池
ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 2. 創(chuàng)建Runnable（任務(wù)）
Runnable task = new Runnable(){
 public void run() {
 System.out.println(Thread.currentThread().getName() + "--->運行");
 }
};
// 3. 向線程池提交任務(wù)
scheduledThreadPool.schedule(task, 2, TimeUnit.SECONDS); // 延遲2s后執(zhí)行任務(wù)
scheduledThreadPool.scheduleAtFixedRate(task,50,2000,TimeUnit.MILLISECONDS);// 延遲50ms后、每隔2000ms執(zhí)行任務(wù)

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

// 1. 創(chuàng)建緩存線程池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 2. 創(chuàng)建Runnable（任務(wù)）
Runnable task = new Runnable(){
 public void run() {
 System.out.println(Thread.currentThread().getName() + "--->運行");
 }
};
// 3. 向線程池提交任務(wù)
cachedThreadPool.execute(task);

/**
 * 在將來的某個時候執(zhí)行給定的任務(wù)。任務(wù)可以在新線程中執(zhí)行，也可以在現(xiàn)有的池線程中執(zhí)行。
 * 如果由于此執(zhí)行器已關(guān)閉或已達到其容量而無法提交任務(wù)以供執(zhí)行，則由當(dāng)前的{@code RejectedExecutionHandler}處理該任務(wù)。
 * 
 * @param command the task to execute 待執(zhí)行的任務(wù)命令
 */
public void execute(Runnable command) {
 if (command == null)
 throw new NullPointerException();
 /*
 * Proceed in 3 steps:
 * 
 * 1. 如果運行的線程少于corePoolSize，將嘗試以給定的命令作為第一個任務(wù)啟動新線程。
 *
 * 2. 如果一個任務(wù)可以成功排隊，那么我們?nèi)匀恍枰屑?xì)檢查兩點，其一，我們是否應(yīng)該添加一個線程
 * （因為自從上次檢查至今，一些存在的線程已經(jīng)死亡），其二，線程池狀態(tài)此時已改變成非運行態(tài)。因此，我們重新檢查狀態(tài)，如果檢查不通過，則移除已經(jīng)入列的任務(wù)，如果檢查通過且線程池線程數(shù)為0，則啟動新線程。
 * 
 * 3. 如果無法將任務(wù)加入任務(wù)隊列，則將線程池擴容到極限容量并嘗試創(chuàng)建一個新線程，如果失敗則拒絕任務(wù)。
 */
 int c = ctl.get();
 
 // 步驟1：判斷線程池當(dāng)前線程數(shù)是否小于線程池大小
 if (workerCountOf(c) < corePoolSize) {
 // 增加一個工作線程并添加任務(wù)，成功則返回，否則進行步驟2
 // true代表使用coreSize作為邊界約束，否則使用maximumPoolSize
 if (addWorker(command, true))
  return;
 c = ctl.get();
 }
 // 步驟2：不滿足workerCountOf(c) < corePoolSize或addWorker失敗，進入步驟2
 // 校驗線程池是否是Running狀態(tài)且任務(wù)是否成功放入workQueue（阻塞隊列）
 if (isRunning(c) && workQueue.offer(command)) {
 int recheck = ctl.get();
 // 再次校驗，如果線程池非Running且從任務(wù)隊列中移除任務(wù)成功，則拒絕該任務(wù)
 if (! isRunning(recheck) && remove(command))
  reject(command);
 // 如果線程池工作線程數(shù)量為0，則新建一個空任務(wù)的線程
 else if (workerCountOf(recheck) == 0)
  // 如果線程池不是Running狀態(tài)，是加入不進去的
  addWorker(null, false);
 }
 // 步驟3：如果線程池不是Running狀態(tài)或任務(wù)入列失敗，嘗試擴容maxPoolSize后再次addWorker，失敗則拒絕任務(wù)
 else if (!addWorker(command, false))
 reject(command);
}

private boolean addWorker(Runnable firstTask, boolean core) {
 // 外層循環(huán)：判斷線程池狀態(tài)
 retry:
 for (;;) {
 int c = ctl.get();
 int rs = runStateOf(c);

 /** 
  * 1.線程池為非Running狀態(tài)（Running狀態(tài)則既可以新增核心線程也可以接受任務(wù)）
  * 2.線程為shutdown狀態(tài)且firstTask為空且隊列不為空
  * 3.滿足條件1且條件2不滿足，則返回false
  * 4.條件2解讀：線程池為shutdown狀態(tài)時且任務(wù)隊列不為空時，可以新增空任務(wù)的線程來處理隊列中的任務(wù)
  */
 if (rs >= SHUTDOWN &&
  ! (rs == SHUTDOWN &&
  firstTask == null &&
  ! workQueue.isEmpty()))
  return false;

		// 內(nèi)層循環(huán)：線程池添加核心線程并返回是否添加成功的結(jié)果
 for (;;) {
  int wc = workerCountOf(c);
  // 校驗線程池已有線程數(shù)量是否超限：
  // 1.線程池最大上限CAPACITY 
  // 2.corePoolSize或maximumPoolSize（取決于入?yún)ore）
  if (wc >= CAPACITY ||
  wc >= (core ? corePoolSize : maximumPoolSize)) 
  return false;
  // 通過CAS操作使工作線程數(shù)+1，跳出外層循環(huán)
  if (compareAndIncrementWorkerCount(c)) 
  break retry;
  // 線程+1失敗，重讀ctl
  c = ctl.get(); // Re-read ctl
  // 如果此時線程池狀態(tài)不再是running，則重新進行外層循環(huán)
  if (runStateOf(c) != rs)
  continue retry;
  // 其他 CAS 失敗是因為工作線程數(shù)量改變了，繼續(xù)內(nèi)層循環(huán)嘗試CAS對線程數(shù)+1
  // else CAS failed due to workerCount change; retry inner loop
 }
 }

 /**
 * 核心線程數(shù)量+1成功的后續(xù)操作：添加到工作線程集合，并啟動工作線程
 */
 boolean workerStarted = false;
 boolean workerAdded = false;
 Worker w = null;
 try {
 final ReentrantLock mainLock = this.mainLock;
 w = new Worker(firstTask);
 final Thread t = w.thread;
 if (t != null) {
  // 下面代碼需要加鎖：線程池主鎖
  mainLock.lock(); 
  try {
  // 持鎖期間重新檢查，線程工廠創(chuàng)建線程失敗或獲取鎖之前關(guān)閉的情況發(fā)生時，退出
  int c = ctl.get();
  int rs = runStateOf(c);

				// 再次檢驗線程池是否是running狀態(tài)或線程池shutdown但線程任務(wù)為空
  if (rs < SHUTDOWN ||
   (rs == SHUTDOWN && firstTask == null)) {
   // 線程已經(jīng)啟動，則拋出非法線程狀態(tài)異常
   // 為什么會存在這種狀態(tài)呢？未解決
   if (t.isAlive()) // precheck that t is startable
   throw new IllegalThreadStateException();
   workers.add(w); //加入線程池
   int s = workers.size();
   // 如果當(dāng)前工作線程數(shù)超過線程池曾經(jīng)出現(xiàn)過的最大線程數(shù)，刷新后者值
   if (s > largestPoolSize)
   largestPoolSize = s; 
   workerAdded = true;
  }
  } finally {
  mainLock.unlock(); // 釋放鎖
  }
  if (workerAdded) { // 工作線程添加成功，啟動該線程
  t.start();
  workerStarted = true;
  }
 }
 } finally {
 //線程啟動失敗，則進入addWorkerFailed
 if (! workerStarted) 
  addWorkerFailed(w);
 }
 return workerStarted;
}

private final class Worker
 extends AbstractQueuedSynchronizer
 implements Runnable
{
 /**
 * This class will never be serialized, but we provide a
 * serialVersionUID to suppress a javac warning.
 */
 private static final long serialVersionUID = 6138294804551838833L;
 
 /** Thread this worker is running in. Null if factory fails. */
 final Thread thread; 
 
 /** Initial task to run. Possibly null. */
 Runnable firstTask;
 
 /** Per-thread task counter */
 volatile long completedTasks;
 
 /**
 * Creates with given first task and thread from ThreadFactory.
 * @param firstTask the first task (null if none)
 */
 // 通過構(gòu)造函數(shù)初始化，
 Worker(Runnable firstTask) {
 //設(shè)置AQS的同步狀態(tài)
 // state：鎖狀態(tài)，-1為初始值，0為unlock狀態(tài)，1為lock狀態(tài)
 setState(-1); // inhibit interrupts until runWorker 在調(diào)用runWorker前，禁止中斷
 
 this.firstTask = firstTask;
 // 線程工廠創(chuàng)建一個線程
 this.thread = getThreadFactory().newThread(this); 
 }
 
 /** Delegates main run loop to outer runWorker */
 public void run() {
 runWorker(this); //runWorker()是ThreadPoolExecutor的方法
 }
 
 // Lock methods
 // The value 0 represents the unlocked state. 0代表“沒被鎖定”狀態(tài)
 // The value 1 represents the locked state. 1代表“鎖定”狀態(tài)
 
 protected boolean isHeldExclusively() {
 return getState() != 0;
 }
 
 /**
 * 嘗試獲取鎖的方法
 * 重寫AQS的tryAcquire()，AQS本來就是讓子類來實現(xiàn)的
 */
 protected boolean tryAcquire(int unused) {
 // 判斷原值為0，且重置為1，所以state為-1時，鎖無法獲取。
 // 每次都是0->1，保證了鎖的不可重入性
 if (compareAndSetState(0, 1)) {
  // 設(shè)置exclusiveOwnerThread=當(dāng)前線程
  setExclusiveOwnerThread(Thread.currentThread()); 
  return true;
 }
 return false;
 }
 
 /**
 * 嘗試釋放鎖
 * 不是state-1，而是置為0
 */
 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(); }
 
 /**
 * 中斷（如果運行）
 * shutdownNow時會循環(huán)對worker線程執(zhí)行
 * 且不需要獲取worker鎖，即使在worker運行時也可以中斷
 */
 void interruptIfStarted() {
 Thread t;
 //如果state>=0、t!=null、且t沒有被中斷
 //new Worker()時state==-1，說明不能中斷
 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;
 // allow interrupts
 // new Worker()是state==-1，此處是調(diào)用Worker類的tryRelease()方法，將state置為0，而interruptIfStarted()中只有state>=0才允許調(diào)用中斷
 w.unlock(); 
  
 // 線程退出的原因，true是任務(wù)導(dǎo)致，false是線程正常退出
 boolean completedAbruptly = true; 
 try {
 // 當(dāng)前任務(wù)和從任務(wù)隊列中獲取的任務(wù)都為空，方停止循環(huán)
 while (task != null || (task = getTask()) != null) {
  //上鎖可以防止在shutdown()時終止正在運行的worker，而不是應(yīng)對并發(fā)
  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
  /**
  * 判斷1：確保只有在線程處于stop狀態(tài)且wt未中斷時，wt才會被設(shè)置中斷標(biāo)識
  * 條件1：線程池狀態(tài)>=STOP,即STOP或TERMINATED
  * 條件2：一開始判斷線程池狀態(tài)<STOP，接下來檢查發(fā)現(xiàn)Thread.interrupted()為true，即線程已經(jīng)被中斷，再次檢查線程池狀態(tài)是否>=STOP（以消除該瞬間shutdown方法生效，使線程池處于STOP或TERMINATED），
  * 條件1與條件2任意滿意一個，且wt不是中斷狀態(tài)，則中斷wt，否則進入下一步
  */
  if ((runStateAtLeast(ctl.get(), STOP) ||
   (Thread.interrupted() &&
   runStateAtLeast(ctl.get(), STOP))) &&
  !wt.isInterrupted())
  wt.interrupt(); //當(dāng)前線程調(diào)用interrupt()中斷
  
  try {
  //執(zhí)行前（空方法，由子類重寫實現(xiàn)）
  beforeExecute(wt, task);
   
  Throwable thrown = null;
  try {
   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 {
   //執(zhí)行后（空方法，由子類重寫實現(xiàn)）
   afterExecute(task, thrown); 
  }
  } 
  finally {
  task = null; 
  w.completedTasks++; //完成任務(wù)數(shù)+1
  w.unlock(); //釋放鎖
  }
 }
 // 
 completedAbruptly = false;
 } 
 finally {
 //處理worker的退出
 processWorkerExit(w, completedAbruptly);
 }
}

private Runnable getTask() {
 // 最新一次poll是否超時
 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.
 /**
  * 條件1：線程池狀態(tài)SHUTDOWN、STOP、TERMINATED狀態(tài)
  * 條件2：線程池STOP、TERMINATED狀態(tài)或workQueue為空
  * 條件1與條件2同時為true，則workerCount-1，并且返回null
  * 注：條件2是考慮到SHUTDOWN狀態(tài)的線程池不會接受任務(wù)，但仍會處理任務(wù)
  */
 if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
  decrementWorkerCount();
  return null;
 }

 int wc = workerCountOf(c);

 // Are workers subject to culling?
 /**
  * 下列兩個條件滿足任意一個，則給當(dāng)前正在嘗試獲取任務(wù)的工作線程設(shè)置阻塞時間限制（超時會被銷毀？不太確定這點），否則線程可以一直保持活躍狀態(tài)
  * 1.allowCoreThreadTimeOut：當(dāng)前線程是否以keepAliveTime為超時時限等待任務(wù)
  * 2.當(dāng)前線程數(shù)量已經(jīng)超越了核心線程數(shù)
  */
 boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
  
 // 兩個條件全部為true，則通過CAS使工作線程數(shù)-1，即剔除工作線程
 // 條件1：工作線程數(shù)大于maximumPoolSize，或（工作線程阻塞時間受限且上次在任務(wù)隊列拉取任務(wù)超時）
 // 條件2：wc > 1或任務(wù)隊列為空
 if ((wc > maximumPoolSize || (timed && timedOut))
  && (wc > 1 || workQueue.isEmpty())) {
  // 移除工作線程，成功則返回null，不成功則進入下輪循環(huán)
  if (compareAndDecrementWorkerCount(c))
  return null;
  continue;
 }

	 // 執(zhí)行到這里，說明已經(jīng)經(jīng)過前面重重校驗，開始真正獲取task了
 try {
  // 如果工作線程阻塞時間受限，則使用poll(),否則使用take()
  // poll()設(shè)定阻塞時間，而take()無時間限制，直到拿到結(jié)果為止
  Runnable r = timed ?
  workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
  workQueue.take();
  // r不為空，則返回該Runnable
  if (r != null)
  return r;
  // 沒能獲取到Runable，則將最近獲取任務(wù)是否超時設(shè)置為true
  timedOut = true;
 } catch (InterruptedException retry) {
  // 響應(yīng)中斷，進入下一次循環(huán)前將最近獲取任務(wù)超時狀態(tài)置為false
  timedOut = false;
 }
 }
}

/**
 * Performs cleanup and bookkeeping for a dying worker. Called
 * only from worker threads. Unless completedAbruptly is set,
 * assumes that workerCount has already been adjusted to account
 * for exit. This method removes thread from worker set, and
 * possibly terminates the pool or replaces the worker if either
 * it exited due to user task exception or if fewer than
 * corePoolSize workers are running or queue is non-empty but
 * there are no workers.
 *
 * @param w the worker
 * @param completedAbruptly if the worker died due to user exception
 */
private void processWorkerExit(Worker w, boolean completedAbruptly) {
 /**
 * 1.工作線程-1操作
 * 1）如果completedAbruptly 為true，說明工作線程發(fā)生異常，那么將正在工作的線程數(shù)量-1
 * 2）如果completedAbruptly 為false，說明工作線程無任務(wù)可以執(zhí)行，由getTask()執(zhí)行worker-1操作
 */
 if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
 decrementWorkerCount();

 // 2.從線程set集合中移除工作線程，該過程需要加鎖
 final ReentrantLock mainLock = this.mainLock;
 mainLock.lock();
 try {
 // 將該worker已完成的任務(wù)數(shù)追加到線程池已完成的任務(wù)數(shù)
 completedTaskCount += w.completedTasks;
 // HashSet<Worker>中移除該worker
 workers.remove(w);
 } finally {
 mainLock.unlock();
 }
 
	// 3.根據(jù)線程池狀態(tài)進行判斷是否結(jié)束線程池
 tryTerminate();
	
	/**
 * 4.是否需要增加工作線程
 * 線程池狀態(tài)是running 或 shutdown
 * 如果當(dāng)前線程是突然終止的，addWorker()
 * 如果當(dāng)前線程不是突然終止的，但當(dāng)前線程數(shù)量 < 要維護的線程數(shù)量，addWorker()
 * 故如果調(diào)用線程池shutdown()，直到workQueue為空前，線程池都會維持corePoolSize個線程，然后再逐漸銷毀這corePoolSize個線程
 */
 int c = ctl.get();
 if (runStateLessThan(c, STOP)) {
 if (!completedAbruptly) {
  int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
  if (min == 0 && ! workQueue.isEmpty())
  min = 1;
  if (workerCountOf(c) >= min)
  return; // replacement not needed
 }
 addWorker(null, false);
 }
}