深度剖析：线程池运行原理及常见面试题，看完这篇文章彻底懂了！

public class ThreadPoolExecutor extends AbstractExecutorService {
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
}

public class ThreadPoolExecutor extends AbstractExecutorService {
  public void execute(Runnable command) {

    if (command == null)
      throw new NullPointerException();
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     *
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     */
    int c = ctl.get();
    /**
     * 步骤1：workerCount < corePoolSize，尝试创建一个新线程执行任务
     * workerCountOf()方法取出 ctl变量低 29位的值，表示当前活动的线程数；
     * 如果当前活动的线程数小于corePoolSize，则新建一个线程放入线程池中，并把该任务放到线程中
     */
    if (workerCountOf(c) < corePoolSize) {
      /**
       * addWorker中的第二个参数表示限制添加线程的数量 是根据据corePoolSize 来判断还是maximumPoolSize来判断；
       * 如果是ture，根据corePoolSize判断
       * 如果是false，根据maximumPoolSize判断
       */
      if (addWorker(command, true))
        return;

      // 如果 addWorker()添加失败，则重新获取 ctl值
      c = ctl.get();
    }
    /**
     * 步骤2：当步骤1的 addWorker()失败，并且线程池是RUNNING，并且任务成功接入阻塞队列
     */
    if (isRunning(c) && workQueue.offer(command)) {
      //double-check，重新获取ctl的值
      int recheck = ctl.get();
      /**
       * 因为线程池的状态一直在变化，所以再次判断线程池的状态，如果不是运行状态，并且移之前已添加到阻塞队列中command
       * 然后进入拒绝策略，流程终止
       */
      if (!isRunning(recheck) && remove(command))
        reject(command);
      /**
       * 线程池为Running状态，获取线程池中的总线程数，如果数量是0，则执行 addWorker()方法；
       * 第一个参数为null，表示在线程池中创建一个线程，但不去启动
       * 第二个参数为false，将线程池的线程数量的上限设置为maximumPoolSize，添加线程时根据maximumPoolSize来判断
       */
      else if (workerCountOf(recheck) == 0)
        addWorker(null, false);
      /**
       * 步骤3：步骤1的 addWorker()失败并且无法进入步骤2，有两种情况：
       * 1、线程池的状态不是RUNNING；
       * 2、线程池状态是RUNNING，但是workerCount >= corePoolSize， workerQueue已满
       * 再次调用addWorker方法，第二个参数传 false，将线程池的线程数上限设置为 maximumPoolSize；
       * 如果失败则执行拒绝策略；
       */
    } else if (!addWorker(command, false))
      reject(command);
  }
}

public class ThreadPoolExecutor extends AbstractExecutorService {
  /**
   * 给线程池增加新的 worker
   * @param firstTask 当前任务
   * @param core 创建新worker是以 corePoolSize还是 maximumPoolSize作为最大阈值
   * @return 返回增加新的 worker的结果，true or false
   */
  private boolean addWorker(Runnable firstTask, boolean core) {
    // retry 作用域为 for循环
    retry:
    // 自旋
    for (int c = ctl.get(); ; ) {
      // Check if queue empty only if necessary.
      /**
       * 这里的判断比较绕，直白的说：线程池已经关闭 或者 有资格关闭，则无法 addWorker并且返回false；
       * 如果线程池当前的 runState为 SHUTDOWN、STOP、TIDYING、TERMINATED 其中一种；并且下面的结果
       * 三个条件 通过 || (或) 连接，只要有一个为 true，就返回 true；
       * 1. 线程池当前的 runState为 STOP、TIDYING、TERMINATED 其中一种；表示关闭状态，不再接收提交的任务，但却可以继续处理阻塞队列中已经保存的任务；
       * 2. firstTask 不为空
       * 3. Check if queue empty only if necessary.阻塞队列为空
       */
      if (runStateAtLeast(c, SHUTDOWN)
        && (runStateAtLeast(c, STOP)
        || firstTask != null
        || workQueue.isEmpty()))
        return false;

      for (; ; ) {
        // workerCount 大于最大线程阈值，无法 addWorker，返回false
        if (workerCountOf(c)
          >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
          return false;
        // 通过 CAS 方式来增加线程数，如果成功，则跳出最外层 for
        if (compareAndIncrementWorkerCount(c))
          break retry;
        c = ctl.get();  // Re-read ctl
        // 线程池状态为 非 RUNNING，则重新进入 for循环
        if (runStateAtLeast(c, SHUTDOWN))
          continue retry;
        // else CAS failed due to workerCount change; retry inner loop
      }
    }

    // addWorker() 的核心流程
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
      /**
       * 根据firstTask来创建Worker对象，每个Worker对象里面会封装一个通过 ThreadFactory创建的线程
       * Worker(Runnable firstTask) {
       *     setState(-1); // inhibit interrupts until runWorker
       *     this.firstTask = firstTask;
       *     this.thread = getThreadFactory().newThread(this);
       *  }
       */

      w = new Worker(firstTask);
      final Thread t = w.thread;
      if (t != null) {
        final ReentrantLock mainLock = this.mainLock;
        // 获取可重入锁
        mainLock.lock();
        try {
          // Recheck while holding lock.
          // Back out on ThreadFactory failure or if
          // shut down before lock acquired.
          int c = ctl.get();
          // 如果线程池的runState为 RUNNING状态，或者 runState < STOP(RUNNING或者SHUTDOWN)并且任务为空
          // 如果线程不为NEW，则抛异常
          if (isRunning(c) ||
            (runStateLessThan(c, STOP) && firstTask == null)) {
            if (t.getState() != Thread.State.NEW)
              throw new IllegalThreadStateException();
            workers.add(w);
            workerAdded = true;
            int s = workers.size();
            if (s > largestPoolSize)
              largestPoolSize = s;
          }
        } finally {
          mainLock.unlock();
        }
        if (workerAdded) {
          // 启动线程，Worker implements Runnable，是一个线程类，此时t.start()会调用 Worker的run()方法，从而调用 runWorker()方法
          t.start();
          workerStarted = true;
        }
      }
    } finally {
      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;

  // TODO: switch to AbstractQueuedLongSynchronizer and move
  // completedTasks into the lock word.

  /**
   * Creates with given first task and thread from ThreadFactory.
   * @param firstTask the first task (null if none)
   */
  Worker(Runnable firstTask) {
    /**
     *  把state设置为 -1，阻止中断直到调用runWorker方法；
     *  因为 AQS默认 state是 0，刚创建一个 Worker对象，在没有执行任务时，不应该被中断
     */
    setState(-1); // inhibit interrupts until runWorker
    this.firstTask = firstTask;
    /**
     * 创建一个线程，newThread()方法入参是 this对象，也就是 Worker对象，
     * 因为 Worker implements Runnable，Worker 是一个线程类；
     * 所以 Worker对象中的 Thread.start()会间接调用 Worker类中 run()方法
     */
    this.thread = getThreadFactory().newThread(this);
  }

  /** Delegates main run loop to outer runWorker.
   * 将主运行循环委托给外部 runWorker
   */
  public void run() {
    runWorker(this);
  }

  // Lock methods
  //
  // The value 0 represents the unlocked state.
  // The value 1 represents the locked state.

  protected boolean isHeldExclusively() {
    return getState() != 0;
  }

  /** 获取锁
   * CAS 方式修改 state，不可重入；
   * state根据 0 来判断，所以 Worker构造方法中state=-1，就是为了禁止在执行任务前对线程进行中断；
   * 因此，在 runWorker()方法中会先调用Worker对象的 unlock()方法将 state设置为 0
   */
  protected boolean tryAcquire(int unused) {
    if (compareAndSetState(0, 1)) {
      setExclusiveOwnerThread(Thread.currentThread());
      return true;
    }
    return false;
  }

  // 释放锁
  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();
  }

  void interruptIfStarted() {
    Thread t;
    if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
      try {
        t.interrupt();
      } catch (SecurityException ignore) {
      }
    }
  }
}

private final class Worker extends AbstractQueuedSynchronizer implements Runnable {

  final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    // 获取任务
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
      while (task != null || (task = getTask()) != null) {
        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
        if ((runStateAtLeast(ctl.get(), STOP) ||
          (Thread.interrupted() &&
            runStateAtLeast(ctl.get(), STOP))) &&
          !wt.isInterrupted())
          wt.interrupt();
        try {
          beforeExecute(wt, task);
          try {
            task.run();
            afterExecute(task, null);
          } catch (Throwable ex) {
            afterExecute(task, ex);
            throw ex;
          }
        } finally {
          task = null;
          w.completedTasks++;
          w.unlock();
        }
      }
      completedAbruptly = false;
    } finally {
      processWorkerExit(w, completedAbruptly);
    }
  }
}

 public class ThreadPoolExecutor extends AbstractExecutorService {

  private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (; ; ) {
      int c = ctl.get();

      /**
       * 再次判断线程池的 runState，决定能够获取到 task
       */
      // Check if queue empty only if necessary.
      if (runStateAtLeast(c, SHUTDOWN)
        && (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
        decrementWorkerCount();
        return null;
      }

      int wc = workerCountOf(c);

      /**
       * timed 变量用于判断是否需要进行 keepAliveTime超时处理；
       * allowCoreThreadTimeOut 默认是 false，代表核心线程不允许超时；
       * wc > corePoolSize，表示当前线程数大于核心线程数；
       * 对于超出 corePoolSize的线程，需要 keepAliveTime超时处理；
       */
      // Are workers subject to culling?
      boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

      /**
       * wc > maximumPoolSize 产生的原因是：此方法执行阶段同时执行了 setMaximumPoolSize()方法；
       * timed && timedOut 如果为true，表示当前操作需要进行获取任务超时处理，并且上次从阻塞队列中获取任务发生了超时；
       * 如果池中的线程数大于 1，或者 workQueue为空，则尝试将 workCount减1；如果减1失败，则返回重试；
       */
      if ((wc > maximumPoolSize || (timed && timedOut))
        && (wc > 1 || workQueue.isEmpty())) {
        if (compareAndDecrementWorkerCount(c))
          return null;
        continue;
      }

      /**
       * 从工作队列中获取任务，根据 timed来决定采用超时获取task()还是堵塞获取task
       * timed为 true，则通过workQueue的poll方法进行超时控制，如果在keepAliveTime时间内没有获取任务，则返回null；
       * 否则通过take方法，如果队列为空，则take方法会阻塞直到队列中不为空；
       */
      try {
        Runnable r = timed ?
          workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
          workQueue.take();
        if (r != null)
          return r;
        timedOut = true;
      } catch (InterruptedException retry) {
        timedOut = false;
      }
    }
  }
}

 public class ThreadPoolExecutor extends AbstractExecutorService {

  private void processWorkerExit(Worker w, boolean completedAbruptly) {
    // 如果completedAbruptly为 true，则说明线程执行时出现异常，需要将 workerCount 减1
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
      decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    // 获取锁
    mainLock.lock();
    try {
      // 已完成 taskCount计数加1
      completedTaskCount += w.completedTasks;
      // 从 workers hashSet中移除当前 worker
      workers.remove(w);
    } finally {
      mainLock.unlock();
    }

    // 钩子函数，根据线程池的状态来判断是否结束线程池
    tryTerminate();

    int c = ctl.get();
    /**
     * 当前线程 runState为 RUNNING或 SHUTDOWN 时，如果 worker是异常结束，会执行 addWorker()方法；
     * 如果allowCoreThreadTimeOut=true，那么等待队列有任务，至少保留一个worker；
     * 如果allowCoreThreadTimeOut=false，workerCount少于coolPoolSize
     */
    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);
    }
  }
}

ThreadPoolExecutor executor=new ThreadPoolExecutor(2,
  4,
  4,
  TimeUnit.SECONDS,
  new LinkedBlockingQueue<>(),
  Executors.defaultThreadFactory(),
  new ThreadPoolExecutor.AbortPolicy());