import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class ThreadPoolDemo1 {

  public static void main(String[] args) {
    // 創(chuàng)建一個(gè)可重用固定線程數(shù)的線程池
    ExecutorService pool = Executors.newFixedThreadPool(2);
    // 創(chuàng)建實(shí)現(xiàn)了Runnable接口對(duì)象，Thread對(duì)象當(dāng)然也實(shí)現(xiàn)了Runnable接口
    Thread ta = new MyThread();
    Thread tb = new MyThread();
    Thread tc = new MyThread();
    Thread td = new MyThread();
    Thread te = new MyThread();
    // 將線程放入池中進(jìn)行執(zhí)行
    pool.execute(ta);
    pool.execute(tb);
    pool.execute(tc);
    pool.execute(td);
    pool.execute(te);
    // 關(guān)閉線程池
    pool.shutdown();
  }
}

class MyThread extends Thread {

  @Override
  public void run() {
    System.out.println(Thread.currentThread().getName()+ " is running.");
  }
}

pool-1-thread-1 is running.
pool-1-thread-2 is running.
pool-1-thread-1 is running.
pool-1-thread-2 is running.
pool-1-thread-1 is running.

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

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,
             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;
  // 線程池的等待隊(duì)列
  this.workQueue = workQueue;
  this.keepAliveTime = unit.toNanos(keepAliveTime);
  // 線程工廠對(duì)象
  this.threadFactory = threadFactory;
  // 拒絕策略的句柄
  this.handler = handler;
}

public static ThreadFactory defaultThreadFactory() {
  return new DefaultThreadFactory();
}

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

  // 提供創(chuàng)建線程的API。
  public Thread newThread(Runnable r) {
    // 線程對(duì)應(yīng)的任務(wù)是Runnable對(duì)象r
    Thread t = new Thread(group, r,
               namePrefix + threadNumber.getAndIncrement(),
               0);
    // 設(shè)為“非守護(hù)線程”
    if (t.isDaemon())
      t.setDaemon(false);
    // 將優(yōu)先級(jí)設(shè)為“Thread.NORM_PRIORITY”
    if (t.getPriority() != Thread.NORM_PRIORITY)
      t.setPriority(Thread.NORM_PRIORITY);
    return t;
  }
}

public static class AbortPolicy implements RejectedExecutionHandler {
  public AbortPolicy() { }

  // 拋出異常
  public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    throw new RejectedExecutionException("Task " + r.toString() +
                       " rejected from " +
                       e.toString());
  }
}

public void execute(Runnable command) {
  // 如果任務(wù)為null，則拋出異常。
  if (command == null)
    throw new NullPointerException();
  // 獲取ctl對(duì)應(yīng)的int值。該int值保存了"線程池中任務(wù)的數(shù)量"和"線程池狀態(tài)"信息
  int c = ctl.get();
  // 當(dāng)線程池中的任務(wù)數(shù)量 < "核心池大小"時(shí)，即線程池中少于corePoolSize個(gè)任務(wù)。
  // 則通過addWorker(command, true)新建一個(gè)線程，并將任務(wù)(command)添加到該線程中；然后，啟動(dòng)該線程從而執(zhí)行任務(wù)。
  if (workerCountOf(c) < corePoolSize) {
    if (addWorker(command, true))
      return;
    c = ctl.get();
  }
  // 當(dāng)線程池中的任務(wù)數(shù)量 >= "核心池大小"時(shí)，
  // 而且，"線程池處于允許狀態(tài)"時(shí)，則嘗試將任務(wù)添加到阻塞隊(duì)列中。
  if (isRunning(c) && workQueue.offer(command)) {
    // 再次確認(rèn)“線程池狀態(tài)”，若線程池異常終止了，則刪除任務(wù)；然后通過reject()執(zhí)行相應(yīng)的拒絕策略的內(nèi)容。
    int recheck = ctl.get();
    if (! isRunning(recheck) && remove(command))
      reject(command);
    // 否則，如果"線程池中任務(wù)數(shù)量"為0，則通過addWorker(null, false)嘗試新建一個(gè)線程，新建線程對(duì)應(yīng)的任務(wù)為null。
    else if (workerCountOf(recheck) == 0)
      addWorker(null, false);
  }
  // 通過addWorker(command, false)新建一個(gè)線程，并將任務(wù)(command)添加到該線程中；然后，啟動(dòng)該線程從而執(zhí)行任務(wù)。
  // 如果addWorker(command, false)執(zhí)行失敗，則通過reject()執(zhí)行相應(yīng)的拒絕策略的內(nèi)容。
  else if (!addWorker(command, false))
    reject(command);
}

private boolean addWorker(Runnable firstTask, boolean core) {
  retry:
  // 更新"線程池狀態(tài)和計(jì)數(shù)"標(biāo)記，即更新ctl。
  for (;;) {
    // 獲取ctl對(duì)應(yīng)的int值。該int值保存了"線程池中任務(wù)的數(shù)量"和"線程池狀態(tài)"信息
    int c = ctl.get();
    // 獲取線程池狀態(tài)。
    int rs = runStateOf(c);

    // 有效性檢查
    if (rs >= SHUTDOWN &&
      ! (rs == SHUTDOWN &&
        firstTask == null &&
        ! workQueue.isEmpty()))
      return false;

    for (;;) {
      // 獲取線程池中任務(wù)的數(shù)量。
      int wc = workerCountOf(c);
      // 如果"線程池中任務(wù)的數(shù)量"超過限制，則返回false。
      if (wc >= CAPACITY ||
        wc >= (core ? corePoolSize : maximumPoolSize))
        return false;
      // 通過CAS函數(shù)將c的值+1。操作失敗的話，則退出循環(huán)。
      if (compareAndIncrementWorkerCount(c))
        break retry;
      c = ctl.get(); // Re-read ctl
      // 檢查"線程池狀態(tài)"，如果與之前的狀態(tài)不同，則從retry重新開始。
      if (runStateOf(c) != rs)
        continue retry;
      // else CAS failed due to workerCount change; retry inner loop
    }
  }

  boolean workerStarted = false;
  boolean workerAdded = false;
  Worker w = null;
  // 添加任務(wù)到線程池，并啟動(dòng)任務(wù)所在的線程。
  try {
    final ReentrantLock mainLock = this.mainLock;
    // 新建Worker，并且指定firstTask為Worker的第一個(gè)任務(wù)。
    w = new Worker(firstTask);
    // 獲取Worker對(duì)應(yīng)的線程。
    final Thread t = w.thread;
    if (t != null) {
      // 獲取鎖
      mainLock.lock();
      try {
        int c = ctl.get();
        int rs = runStateOf(c);

        // 再次確認(rèn)"線程池狀態(tài)"
        if (rs < SHUTDOWN ||
          (rs == SHUTDOWN && firstTask == null)) {
          if (t.isAlive()) // precheck that t is startable
            throw new IllegalThreadStateException();
          // 將Worker對(duì)象(w)添加到"線程池的Worker集合(workers)"中
          workers.add(w);
          // 更新largestPoolSize
          int s = workers.size();
          if (s > largestPoolSize)
            largestPoolSize = s;
          workerAdded = true;
        }
      } finally {
        // 釋放鎖
        mainLock.unlock();
      }
      // 如果"成功將任務(wù)添加到線程池"中，則啟動(dòng)任務(wù)所在的線程。 
      if (workerAdded) {
        t.start();
        workerStarted = true;
      }
    }
  } finally {
    if (! workerStarted)
      addWorkerFailed(w);
  }
  // 返回任務(wù)是否啟動(dòng)。
  return workerStarted;
}

public Future<?> submit(Runnable task) {
  if (task == null) throw new NullPointerException();
  RunnableFuture<Void> ftask = newTaskFor(task, null);
  execute(ftask);
  return ftask;
}

public void shutdown() {
  final ReentrantLock mainLock = this.mainLock;
  // 獲取鎖
  mainLock.lock();
  try {
    // 檢查終止線程池的“線程”是否有權(quán)限。
    checkShutdownAccess();
    // 設(shè)置線程池的狀態(tài)為關(guān)閉狀態(tài)。
    advanceRunState(SHUTDOWN);
    // 中斷線程池中空閑的線程。
    interruptIdleWorkers();
    // 鉤子函數(shù)，在ThreadPoolExecutor中沒有任何動(dòng)作。
    onShutdown(); // hook for ScheduledThreadPoolExecutor
  } finally {
    // 釋放鎖
    mainLock.unlock();
  }
  // 嘗試終止線程池
  tryTerminate();
}