通过手撸线程池深入理解其原理（下）

==> 学习汇总（持续更新）
==> 从零搭建后端基础设施系列（一）-- 背景介绍

---

摘要：上篇实现了简单的无锁线程池，中篇实现了简单的加锁线程池，本篇着重剖析java线程池源码。

一、基础概念
其实，把下面这些参数概念理解了，看线程池源码像看helloworld一样简单。

• corePoolSize
  核心线程数量，什么是核心线程呢？就是一创建出来就常驻内存，不退出不销毁，直观点看，代码长这样

  public void run(){
      while(true){
  	     //不停的执行任务或者等待执行任务
  	}
  }
  

• maximumPoolSize
  最大线程数量，什么是最大线程数呢？就是这个线程池最多能同时运行的线程数量。比如核心线程数是5，最大线程数是10，那么当5个核心线程不够用的时候，会最多再创建5个线程，达到最大线程数10。那么疑问就来了，非核心线程会被回收吗？答案是不确定，根据你设置的存活时间来定。
• keepAliveTime
  线程保持存活的时间，通俗的讲就是，某个线程在给定的时间内没有接活，那么就会退出销毁了。那么这个设置只对非核心线程有效吗？答案是否定的，线程池还有个参数可以设置核心线程也能被回收。
• BlockingQueue
  阻塞队列，什么是阻塞队列呢？和普通的队列有什么不一样？这人家的名字不是已经告诉你了嘛，区别在于人家可以阻塞。就是当队列为空的时候可以阻塞在那里等着。来简单看看其中一个阻塞队列LinkedBlockingDeque的实现。

  public E takeFirst() throws InterruptedException {
      final ReentrantLock lock = this.lock;
      lock.lock();
      try {
          E x;
          //如果队列一直为空，那么就一直阻塞在那
          //当队列不为空了，notEmpty.await()会被唤醒
          while ( (x = unlinkFirst()) == null)
              notEmpty.await();
          return x;
      } finally {
          lock.unlock();
      }
  }
  ……
  public E pollFirst(long timeout, TimeUnit unit)
      throws InterruptedException {
      long nanos = unit.toNanos(timeout);
      final ReentrantLock lock = this.lock;
      lock.lockInterruptibly();
      try {
          E x;
          //这个和take不一样的是，可以指定等待时间，超时直接返回null
          while ( (x = unlinkFirst()) == null) {
              if (nanos <= 0)
                  return null;
              nanos = notEmpty.awaitNanos(nanos);
          }
          return x;
      } finally {
          lock.unlock();
      }
  }
  

• ThreadFactory
  线程工厂，听着名字像是生产线程的，没错，就是字面意思。这是线程池将线程的创建开放出来给用户自定义，可以看个简单的例子。

  new ThreadFactory() {
     @Override
      public Thread newThread(Runnable r) {
          return new Thread(r, "我是从线程工厂出生的");
      }
  };
  

  通过线程工厂，我们能对线程进行个性化的定制，再具体的就不演示了。
• RejectedExecutionHandler
  拒绝执行策略，通俗点就是，当任务执行不过来了，你可以自定义一个处理策略，默认的策略就是直接抛异常。但是在实际应用中，应该自定义一个比较友好的处理策略。
• ctl
  是不是差点没认出来，这就是java线程池里到处出现的一个参数。

   private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
  

  可以看一下源码中的注释是如何解释这个缩写的参数的，它其实就是一个控制线程池大小和状态的参数。
  
  我们将它定义的状态给打印出来看看，就能一目了然。

  int COUNT_BITS = Integer.SIZE - 3;
  int CAPACITY = (1 << COUNT_BITS) - 1;
  int RUNNING = -1 << COUNT_BITS;
  int SHUTDOWN   =  0 << COUNT_BITS;
  int STOP       =  1 << COUNT_BITS;
  int TIDYING    =  2 << COUNT_BITS;
  int TERMINATED =  3 << COUNT_BITS;
  System.out.println("COUNT_BITS = " + COUNT_BITS);
  System.out.println("CAPACITY   = " + CAPACITY + "  = 000" + Integer.toBinaryString(CAPACITY));
  System.out.println("~CAPACITY  = " + ~CAPACITY + " = " + Integer.toBinaryString(~CAPACITY));
  System.out.println("RUNNING    = " + RUNNING + " = " + Integer.toBinaryString(RUNNING));
  System.out.println("SHUTDOWN   = " + SHUTDOWN + " = " + Integer.toBinaryString(SHUTDOWN));
  System.out.println("STOP       = " + STOP + "  = 00" + Integer.toBinaryString(STOP));
  System.out.println("TIDYING    = " + TIDYING + " = 0" + Integer.toBinaryString(TIDYING));
  System.out.println("TERMINATED = " + TERMINATED + " = 0" + Integer.toBinaryString(TERMINATED));
  

  
  可以看到，一个32位整型，容量用29位来表示，剩下的3位表示状态。只要ctl<0那么线程池就是正常运行的，如果ctl>=0就是要关闭了。
• 自旋
  通俗点就是死循环for(;;);，可能有人会问，为什么没见过用while来自旋的？其实吧，都行，从现在来看，两者效率基本一样。
• CAS
  CAS全称是compareAndSet，就是比较并更新的意思，这是一个原子操作，由底层汇编指令实现。使用到的汇编指令是cmpxchg，其作用是比较并交换操作数（感兴趣的百度一下这个指令的具体释义）。java是不能直接使用汇编的，那怎么办呢？java可以通过C语言间接的去使用这个指令，那么就引出了Unsafe这个类，简单的讲，这个类给你提供了类似C/C++的操作内存的方法，所以非常危险，我们如果要使用只能通过反射拿到它进行使用。
• AQS
  AQS全称是AbstractQueuedSynchronizer，它是一个队列同步器。它的作用就像是一条管道一样，严格的控制线程的先进先出，任一时刻，有且仅有一个线程能运行，其它都会被阻塞。比如说，有2个线程，同时争夺一个资源，那么线程1先拿到了，线程2再想去拿，就拿不到，并且放到队尾排队，只有线程1释放了这个资源，出队了，线程2才能拿到。依次类推。关于AQS后续通过其它文章再深入探讨。

二、ThreadPoolExecutor源码剖析
通过上面对基础概念的解释，这里就不再重复对其构造函数分析了。
1.任务提交的三种方式

• void execute(Runnable command)
  这种方式提交的任务，是没有返回值，也没有Future异步等待task执行结束。
• Future submit(Runnable task)
  这种方式提交的任务，也没有返回值，有Future异步等待task执行结束。

  public Future<?> submit(Runnable task) {
      if (task == null) throw new NullPointerException();
      RunnableFuture<Void> ftask = newTaskFor(task, null);
      execute(ftask);
      return ftask;
  }
  ……
  protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
      return new FutureTask<T>(runnable, value);
  }
  
  ……
  public interface RunnableFuture<V> extends Runnable, Future<V> {
  	void run();
  }
  

  这里对task的包装挺巧妙的，因为接口可以多继承，所以包装一个新的接口RunnableFuture继承自Runnable和Future，这样再通过中间人FutureTask将Runnable和Callable包装起来，完美！
• Future submit(Callable task)
  这种方式提交的任务，必须有返回值（也就是T不能为Void），有Future异步等待task执行结束。

这三种提交方式，最后都由execute执行。

2.线程池入口execute源码剖析

• 代码分析

  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();
          //如果线程池关闭了，那么就不要再往队列里面加任务了，这里
          //尝试删除之前加入的那个任务,注意，这个操作是可能失败返回
          //false的，因为你一加进去，可能就立马被执行了。如果删除成功
          //就使用相应的拒绝策略处理
          if (! isRunning(recheck) && remove(command))
              reject(command);
          //这个就比较耐人寻味，线程池正在运行并且大小为0的时候创建一个线程
          else if (workerCountOf(recheck) == 0)
              addWorker(null, false);
      }
      //这个就很好理解了，当核心线程满了，队列满了，就创建非核心线程
      //来处理，如果非核心线程也满了，就执行相应的拒绝策略处理了
      else if (!addWorker(command, false))
          reject(command);
  }
  

• Q&A
  1） 第一个if已经判断当前线程池大小没有达到核心线程数了，为什么addWorker还可能返回false？
  这个问题在我没有自己手撸一个线程池的时候，我看了好多遍也没理解。我们来假设这么一个场景，核心线程数为2，最大线程数为4，多线程并发提交任务，是不是有可能会发生同时进行int c = ctl.get();或者前后相隔非常非常短的时候进行int c = ctl.get();，这导致的结果是什么呢？线程没创建出来，线程池大小没更新，大家拿到的都是一个值，都小于corePoolSize，所以需要在addWorker里面进行拦截判断（具体的下面再讲），如果已经有2个核心线程创建完了，那么剩下的2个就会返回false，继续进行下面的分支判断。
  2）在什么情况下这个workerCountOf(recheck) == 0为true？
  为什么线程池运行的时候，并且经过前面核心线程的创建，还会出现线程数为0的情况。这个我也还没确切的结论。

3.创建工作线程addWorker源码剖析

• 代码分析

  private boolean addWorker(Runnable firstTask, boolean core) {
      retry:
      for (;;) {
          int c = ctl.get();
          //拿到线程池运行状态
          int rs = runStateOf(c);
  		
  		//1.线程池状态大于等于SHUTDOWN
  		//2.!(线程池状态正好等于SHUTDOWN && firstTask == null && ! workQueue.isEmpty())
  		//同时满足第一个条件和第二个条件，就不用继续往下创建工作线程了
  		//通俗的解释这段代码的意思，第一个条件很容易明白，就是线程池要
  		//关闭了，不能创建工作线程了。第二个条件就得琢磨一下，就是线程
  		//池状态正好等于SHUTDOWN，并且task是空的，并且队列不为空，那
  		//肯定得再搞个线程去处理队列中剩余的任务吧。反之如果线程池状态大于
  		//SHUTDOWN，就是要立马关掉，不做任何后续处理，那当然就不需要
  		//再创建工作线程了。
          if (rs >= SHUTDOWN &&
              ! (rs == SHUTDOWN &&
                 firstTask == null &&
                 ! workQueue.isEmpty()))
              return false;
  
          for (;;) {
              //拿到当前线程池大小
              int wc = workerCountOf(c);
              //1.线程池大小超过理论最大容量
              //2.如果要创建的是核心线程，那么要判断核心线程数是否已经满了，非核心线程同理
              //只要满足1和2其中一个条件，就返回false，创建失败
              if (wc >= CAPACITY ||
                  wc >= (core ? corePoolSize : maximumPoolSize))
                  return false;
              //如果前面的关卡都过了，说明可以创建，然后提前增加线程池大小
              //这里使用了CAS去增加   
              if (compareAndIncrementWorkerCount(c))
                  break retry;
              //如果修改失败了，拿到最新的值    
              c = ctl.get();  // Re-read ctl
              //判断一下线程池状态是否变化，如果有变化，就跳到外层循环
              //返回继续在内层循环使用CAS尝试增加线程池大小
              if (runStateOf(c) != rs)
                  continue retry;
          }
      }
  
      boolean workerStarted = false;
      boolean workerAdded = false;
      Worker w = null;
      try {
          //创建工作线程，这一步没必要加锁，可以并发创建
          w = new Worker(firstTask);
          final Thread t = w.thread;
          if (t != null) {
              final ReentrantLock mainLock = this.mainLock;
              //下面这里开始加锁，因为涉及到HashSet的读写，它是线程非安全的
              mainLock.lock();
              try {
           		
                  int rs = runStateOf(ctl.get());
  				//1.线程池正常运行
  				//2.线程池状态等于SHUTDOWN并且firstTask为空，意思就是创建一个线程去消耗队列里面的任务
  				//满足以上任意一个条件都能创建
                  if (rs < SHUTDOWN ||
                      (rs == SHUTDOWN && firstTask == null)) {
                      //检查这个线程是否正在运行，因为还没进行到下面t.start()，在这里就运行了的话，明显是不合法的（具体什么场景会碰到，我也不清楚）
                      if (t.isAlive()) // precheck that t is startable
                          throw new IllegalThreadStateException();
                      workers.add(w);
                      int s = workers.size();
                      //这里就是记录一下线程池最大数量
                      if (s > largestPoolSize)
                          largestPoolSize = s;
                      workerAdded = true;
                  }
              } finally {
                  mainLock.unlock();
              }
              if (workerAdded) {
                  //启动线程
                  t.start();
                  workerStarted = true;
              }
          }
      } finally {
          if (! workerStarted)
              //启动失败就进行一些处理操作
              addWorkerFailed(w);
      }
      return workerStarted;
  }
  

• Q&A
  1）为什么需要两层for循环？
  我已经在代码注释写了个大概，第一层循环的作用是判断线程池的状态。第二层循环的作用是判断是否能创建线程，如果能就使用CAS尝试增加线程池的大小。如果失败了，并且线程池状态发生了变化，那么跳到外层循环进行判断处理，反之继续在内层循环重复上述操作。
  2）为什么需要使用CAS增加线程池大小，而不直接使用++或+1呢？
  这里就引回到execute源码剖析那里了，还记得上面分析过，如果并发提交任务，会在第一个if分支里，全部进入到addWorker里，如果这时候不加锁，会出现创建了4个核心线程的情况，使用了CAS操作，能保证只有2个核心线程被创建，其它两个会返回false。
  3）为什么需要提前加线程池大小呢？
  这样能快速的让那些不速之客离开addWorker，也能让外面还在想进来的任务死了这条心。

4.工作线程Worker源码剖析

• 代码分析

  private final class Worker
      extends AbstractQueuedSynchronizer
      implements Runnable
  {
      private static final long serialVersionUID = 6138294804551838833L;
  	
  	//工作线程
      final Thread thread;
      //创建Worker的时候，如果传了Task，那么就直接执行这个Task，否则去队列中拿Task
      Runnable firstTask;
      
      //这就是一个统计用的
      volatile long completedTasks;
      
      Worker(Runnable firstTask) {
          setState(-1); // inhibit interrupts until runWorker
          this.firstTask = firstTask;
          //这里创建的线程，传入的Runnable就是Worker本身
          //当在外面调用t.start的时候，就会运行Woker中的run方法
          this.thread = getThreadFactory().newThread(this);
      }
  
      public void run() {
      	//真正执行的方法
          runWorker(this);
      }
  
  	//state == 0表示目前没有被线程持有，state == 1表示目前被一个线程持有，相当于被锁住了
      protected boolean isHeldExclusively() {
          return getState() != 0;
      }
  	
  	//尝试加锁，如果当前state == 0，那么尝试将state置为1，也就是加锁
      protected boolean tryAcquire(int unused) {
          if (compareAndSetState(0, 1)) {
          	//设置当前线程为这个Worker的独占线程（就是排他锁）
              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) {
              }
          }
      }
  }
  

• Q&A
  1）为什么Worker构造函数中有这一行setState(-1)代码？
  看到Woker的interruptIfStarted方法里，有这么一个判断
  “getState() >= 0 && (t = thread) != null && !t.isInterrupted()”，state要大于等于0，才能中断这个线程。为什么呢？很好理解嘛，我都还没启动，你就给我中断，这算是人干的事？当外面调用了t.start，线程启动了，state设置为0，这时候你可以中断。
  2）为什么runWorker方法在外面？
  这个我也没想到，难道仅仅是为了Worker代码尽量简洁？
  3）为什么要继承AbstractQueuedSynchronizer，不直接使用ReentrantLock？
  我们都知道，ReentrantLock是可重入锁，但是Worker的特性，它不能使用可重入锁，为什么呢？因为它需要实现不可重入的特性去反应线程现在的执行状态。下面分析到interruptIdleWorkers方法的时候，大家就能豁然开朗了。

5.执行任务runWorker源码剖析

• 代码分析

  final void runWorker(Worker w) {
      Thread wt = Thread.currentThread();
      Runnable task = w.firstTask;
      //这是防止重复执行这个task
      w.firstTask = null;
      //这里就是将state位置0的操作
      w.unlock(); // allow interrupts
      //这个变量也有点意思，考虑得比较全面，这个是防止while循环里面有捕获不到的异常，也就是非正常结束。最后会有相应的处理策略。
      boolean completedAbruptly = true;
      try {
      	//task != null就先执行它，然后才去队列里面拿task
      	//getTask有三种可能，第一个是返回task，第二个是返回null，第三个是一直阻塞(具体的分析getTask源码再讨论)
          while (task != null || (task = getTask()) != null) {
          	//执行任务的时候先加锁
              w.lock();
              
              //这种代码在线程池很常见，无非是判断当前线程池的状态，做相应的处理，可自己试着分析一下，很简单
              if ((runStateAtLeast(ctl.get(), STOP) ||
                   (Thread.interrupted() &&
                    runStateAtLeast(ctl.get(), STOP))) &&
                  !wt.isInterrupted())
                  wt.interrupt();
              try {
                  //开放给子类实现的方法
                  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 {
                   	//开放给子类实现的方法
                      afterExecute(task, thrown);
                  }
              } finally {
                  task = null;
                  w.completedTasks++;
                  w.unlock();
              }
          }
          //运行到这里，说明没有未知异常，置为false
          completedAbruptly = false;
      } finally {
          //这就是后续的处理，里面没啥好讨论的，感兴趣可自行分析
          processWorkerExit(w, completedAbruptly);
      }
  }
  

• Q&A
  1）为什么执行任务前要加锁？
  如果单单从这里看，确实没有加锁的必要，这一段就单纯的是同步执行task.run方法，是串行的。如果从全局看，有这么一个方法"interruptIdleWorkers"，可以看看它的代码。这里也呼应了上面分析的，为什么要用AQS实现一个不可重入锁，就是为了反应worker的状态。

  //尝试中断空闲的线程
  private void interruptIdleWorkers(boolean onlyOne) {
      final ReentrantLock mainLock = this.mainLock;
      mainLock.lock();
      try {
          for (Worker w : workers) {
              Thread t = w.thread;
              //重点来了，这里中断之前，需要判断一下线程是否空闲，怎么判断呢？简单，我们尝试去获取锁，如果获取成功，说明那个线程没有在执行task.run，也就是空闲的了。
              if (!t.isInterrupted() && w.tryLock()) {
                  try {
                      t.interrupt();
                  } catch (SecurityException ignore) {
                  } finally {
                      w.unlock();
                  }
              }
              if (onlyOne)
                  break;
          }
      } finally {
          mainLock.unlock();
      }
  }
  

6.获取任务getTask源码剖析

• 代码分析

  private Runnable getTask() {
  	//这个变量的设计，看一下中篇就知道了，很是巧妙
      boolean timedOut = false; 
  
      for (;;) {
          int c = ctl.get();
          int rs = runStateOf(c);
  		
  		//还是判断线程池状态那一套
          if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
              decrementWorkerCount();
              return null;
          }
  
          int wc = workerCountOf(c);
  
          //是否允许回收线程，很好理解，如果允许核心线程被回收或者当前线程池大小大于核心线程数，都是允许线程被回收的。
          boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
  		
  		//这一段，判断当前线程是否可以回收，如果可以，先将线程池大小减1，并且返回null，外面的循环就会退出了，线程也就退出了
  		//再来看看具体的条件
  		//1.当前线程池大小大于最大线程数
  		//2.允许线程被回收 并且 超过指定时间没获取到任务 并且 （当前线程池中还有至少2个线程 或者 队列为空了）
  		//满足1和2任意一个条件就可以回收线程了
          if ((wc > maximumPoolSize || (timed && timedOut))
              && (wc > 1 || workQueue.isEmpty())) {
              //这里也是用CAS尝试去将线程池大小减1
              if (compareAndDecrementWorkerCount(c))
                  return null;
              //如果失败了，说明有其它线程成功了，那就重复上述步骤    
              continue;
          }
  
          try {
              //允许回收的话，就调用poll，它可以设置超时时间，如果指定时间内没有任务处理，timedOut就为true，说明可以回收了
              //反之就调用take一直阻塞下去
              Runnable r = timed ?
                  workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                  workQueue.take();
              if (r != null)
                  return r;
              timedOut = true;
          } catch (InterruptedException retry) {
              timedOut = false;
          }
      }
  }
  

• Q&A
  1）为什么在获取Runnable为null的时候，直接递减线程池大小，然后返回null呢？
  如果你自己手撸过线程池，那么应该会遇到这个场景，也就知道为什么了，现在我举个小例子

  try {
       boolean timed;
       try {
           lock.lock();
           //因为这里锁住了，N个线程都会顺序判断一遍，注意，这里会非常快
           timed = currentPoolSize.get() > corePoolSize;
           //if(timed && timeout) {
           //    currentPoolSize.decrementAndGet();
           //    return null;
           //}
       } finally {
           lock.unlock();
       }
       //这里执行的会比上面的慢一些，会导致什么问题呢？
       //最坏的情况下，N个线程都直接运行到了这里，并且timed=true
       //那么会有很多runnable == null
       Runnable runnable = timed ? workerQueues.poll(keepTimeAlive, TimeUnit.NANOSECONDS) : workerQueues.take();
       if(runnable != null){
           return runnable;
       }
       //这里就会递减过头了，刹不住车
       currentPoolSize.decrementAndGet();
       return null;
       //timeout = true;
   } catch (InterruptedException e) {
       //timeout = false;
   }
  

  当然了，办法肯定有的，加锁，判断等等都行，麻烦且效率低下，那还不如递减先于获取来得实在呢。

  2）InterruptedException作用是什么？
  从名字就可以看出，中断异常，那么作用就很明显了，当调用的是take阻塞的时候，当线程中断的时候，这个就会抛异常。一般什么时候中断线程呢？关闭线程池的时候。

7.线程池shutdown源码剖析

• 代码分析

  public void shutdown() {
      final ReentrantLock mainLock = this.mainLock;
      mainLock.lock();
      try {
          checkShutdownAccess();
          //这就是更新线程池的状态
          advanceRunState(SHUTDOWN);
          //中断闲置的线程，还在执行的任务的让它继续收尾(上面已经分析过这个方法)
          interruptIdleWorkers();
          //开放给子类的方法
          onShutdown(); // hook for ScheduledThreadPoolExecutor
      } finally {
          mainLock.unlock();
      }
      //尝试将线程池状态置为TERMINATED，并且还有一些相应的处理
      tryTerminate();
  }
  
  private void advanceRunState(int targetState) {
      for (;;) {
          int c = ctl.get();
          //很简单的条件，比如targetState == SHUTDOWN
          //那么c >= SHUTDOWN的话，就不需要修改了
          //如果线程池还在运行状态，那么CAS修改它的状态
          if (runStateAtLeast(c, targetState) ||
              ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
              break;
      }
  }
  
  final void tryTerminate() {
      for (;;) {
          int c = ctl.get();
          //1.对于shutdown这个方法来说，调用这个方法的时候，线程池状态不可能是running了
          //2.也不可能是 >= TIDYING，应该是SHUTDOWN
          //3.如果是SHUTDOWN，并且队列中还有任务，也不行
          if (isRunning(c) ||
              runStateAtLeast(c, TIDYING) ||
              (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
              return;
          
          if (workerCountOf(c) != 0) { // Eligible to terminate		
          	//这里我也不知道为什么只中断一个？    
              interruptIdleWorkers(ONLY_ONE);
              return;
          }
  
          final ReentrantLock mainLock = this.mainLock;
          mainLock.lock();
          try {
          	//这段代码就比较简单，就是线程池状态从TIDYING -> TERMINATED
          	//之间，可以给子类一个收尾处理的方法
              if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                  try {
                      terminated();
                  } finally {
                      ctl.set(ctlOf(TERMINATED, 0));
                      termination.signalAll();
                  }
                  return;
              }
          } finally {
              mainLock.unlock();
          }
          // else retry on failed CAS
      }
  }
  

• Q&A
  1）tryTerminate作用是什么？
  这个我的理解，就是一个尝试做最后的收尾工作，给子类开放的一个方法，对于线程池关闭的主流程无任何影响。

8.线程池shutdownNow源码剖析

• 代码分析

  public List<Runnable> shutdownNow() {
      List<Runnable> tasks;
      final ReentrantLock mainLock = this.mainLock;
      mainLock.lock();
      try {
          checkShutdownAccess();
          advanceRunState(STOP);
          //和shutdown不同的是，不管是不是空闲线程，全部都中断了
          interruptWorkers();
          //这就是把剩余未执行的任务返回，给用户自行处理
          tasks = drainQueue();
      } finally {
          mainLock.unlock();
      }
      tryTerminate();
      return tasks;
  }
  private void interruptWorkers() {
      final ReentrantLock mainLock = this.mainLock;
      mainLock.lock();
      try {
          for (Worker w : workers)
              w.interruptIfStarted();
      } finally {
          mainLock.unlock();
      }
  }
  

• Q&A
  1）shutdownNow一定能让线程退出吗？
  在这里我要重点说一下，除非程序崩溃，否则没有任何外部方式使线程强制退出，只能是通过将该线程的中断位置为1，然后由线程自行判断决定是否处理这个中断信号。而shutdown和shutdownNow唯一的区别在于，前者只给空闲线程发送中断信号，后者给所有的线程发送。可以看下面这个例子

  public static void main(String[] args) throws InterruptedException {
      ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
  
      for (int i = 0; i < 4; i++) {
          poolExecutor.execute(() -> {
              System.out.println("当前线程:" + Thread.currentThread().getName() + " 开始");
              while (true){
                  if(Thread.currentThread().isInterrupted()){
                      System.out.println("接收到中断信号，退出");
                      break;
                  }
              }
              System.out.println("当前线程:" + Thread.currentThread().getName() + " 结束");
  
          });
      }
      Thread.sleep(2000);
      System.out.println("线程池关闭");
      List<Runnable> runnables = poolExecutor.shutdownNow();
      System.out.println(runnables.size());
  }
  

  
  如果使用的是shutdown，那么正在运行的线程，是无论如何都接收不到中断信息的。
  

三、总结
说实话，线程池的源码我之前看过很多次，但是每次都是懵懵懂懂，然后就是看不下去了，觉得太难了。然后突然兴起，想自己撸一个线程池，看看难度几何，写的过程，遇到很多问题，然后尝试去解决，最后发现有些思想竟然和java线程池一模一样，那些困扰我的问题也一一解开，那种感觉非常棒，哈哈。所以真就应了那一句，实践出真理啊，偷懒最终的苦还是自己承受。