线程池执行流程

当状态是shutdown时，是可以添加任务为空的现成加速队列执行的

• 线程池核心线程也可以超时销毁，参数：allowCoreThreadTimeOut，默认false，时间也是keepAliveTime参数

• 在应用入口捕获线程池未捕获的异常，说明：如下只能捕获线程池调用execute方法的未捕获的异常，submit方法的不行，submit方法的必须在执行处使用try catch手动捕获处理，或者通过返回值调用get()方法捕获。推荐execute和submit都try catch统一思想，还有个好处是，普通线程池异常会销毁当前线程同时创建一个新的线程，如果异常比较多创建线程也会消耗性能。

  Thread.setDefaultUncaughtExceptionHandler((thread, e) -> {
    String desc = format("捕获DefaultUncaughtExceptionHandler异常, 线程名称: {}", thread.getName());
    log.error(desc, e);
  });
  

• ScheduledExecutorService抛出异常时不继续执行时因为下方注释：

  public void run() {
    boolean periodic = isPeriodic();
    if (!canRunInCurrentRunState(periodic))
      cancel(false);
    else if (!periodic)
      ScheduledFutureTask.super.run();
    // 这里执行如果抛异常会返回false，就不会不停的向队列中反复添加任务
    else if (ScheduledFutureTask.super.runAndReset()) {
      setNextRunTime();
      reExecutePeriodic(outerTask);
    }
  }
  
  protected boolean runAndReset() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
      return false;
    boolean ran = false;
    int s = state;
    try {
      Callable<V> c = callable;
      if (c != null && s == NEW) {
        try {
          c.call(); // don't set result
          ran = true;
        } catch (Throwable ex) {
          setException(ex);
        }123
      }
    } finally {
      // runner must be non-null until state is settled to
      // prevent concurrent calls to run()
      runner = null;
      // state must be re-read after nulling runner to prevent
      // leaked interrupts
      s = state;
      if (s >= INTERRUPTING)
        handlePossibleCancellationInterrupt(s);
    }
    return ran && s == NEW;
  }
  

• 普通线程池抛出异常，会销毁当前线程，并且新建1个

      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);
                      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();
                  }
              }
              completedAbruptly = false;
          } finally {
              processWorkerExit(w, completedAbruptly);
          }
      }
  

  抛出异常会执行processWorkerExit方法：

      private void processWorkerExit(Worker w, boolean completedAbruptly) {
          if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
              decrementWorkerCount();
  
          final ReentrantLock mainLock = this.mainLock;
          mainLock.lock();
          try {
              completedTaskCount += w.completedTasks;
            // 移除当前worker
              workers.remove(w);
          } finally {
              mainLock.unlock();
          }
  
          tryTerminate();
  
          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
              }
            // 新建1个新的worker
              addWorker(null, false);
          }
      }
  

• 超时销毁逻辑

      private Runnable getTask() {
          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.
              if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                  decrementWorkerCount();
                  return null;
              }
  
              int wc = workerCountOf(c);
  
              // Are workers subject to culling?
              boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
  
            // 判断超时，销毁，core线程根据参数也可能被销毁
              if ((wc > maximumPoolSize || (timed && timedOut))
                  && (wc > 1 || workQueue.isEmpty())) {
                  if (compareAndDecrementWorkerCount(c))
                      return null;
                  continue;
              }
  
              try {
                  Runnable r = timed ?
                      workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                      workQueue.take();
                  if (r != null)
                      return r;
                  timedOut = true;
              } catch (InterruptedException retry) {
                  timedOut = false;
              }
          }
      }