Java ThreadPoolExecutor详解

ThreadPoolExecutor是Java语言对于线程池的实现。池化技术是一种复用资源，减小开销的技术。线程是操做系统的资源，线程的建立与调度由操做系统负责，线程的建立与调度都要耗费大量的资源，其中线程建立须要占用必定的内存，而线程的调度须要不断的切换线程上下文形成必定的开销。同时线程执行完毕以后就会被操做系统回收，这样在高并发状况下就会形成系统频繁建立线程。

为此线程池技术为了解决上述问题，使线程在使用完毕后不回收而是重复利用。若是线程可以复用，那么咱们就能够使用固定数量的线程来解决并发问题，这样一来不只节约了系统资源，并且也会减小线程上下文切换的开销。

参数

ThreadPoolExecutor的构造函数有7个，它们分别是：

1. corePoolSize（int）：线程池的核心线程数量
2. maximumPoolSize（int）：线程池最大线程数量
3. keepAliveTime（long）：保持线程存活的时间
4. unit（TimeUnit）：线程存活时间单位
5. workQueue（BlockingQueue）：工做队列，用于临时存放提交的任务
6. threadFactory（ThreadFactory）：线程工厂，用于建立线程
7. handler（RejectedExecutionHandler）：任务拒绝处理器，当线程池没法再接受新的任务时，会交给它处理

通常状况下，咱们只使用前五个参数，剩余两个咱们使用默认参数便可。

任务提交逻辑

其实，线程池建立参数都与线程池的任务提交逻辑密切相关。根据源码描述能够得知：当提交一个新任务时（执行线程池的execute方法）会通过三个步骤的处理。

1. 当任务数量小于corePoolSize时，线程池会建立一个新的线程（建立新线程由传入参数threadFactory完成）来处理任务，哪怕线程池中有空闲线程，依然会选择建立新线程来处理。
2. 当任务数量大于corePoolSize时，线程池会将新任务压入工做队列（参数中传递的workQueue）等待调度。
3. 当新提交的任务没法压入工做队列时，会检查当前任务数量是否大于maximumPoolSize。若是小于maximunPoolSize则会新建线程来处理任务（这时咱们的keepAliveTime参数就起做用了，它主要做用于这种状况下建立的线程，若是任务数量减少，这些线程闲置了，那么在超过keepAliveTime时间后就会被回收）。若是大于了maximumPoolSize就会交由任务拒绝处理器handler处理。

线程池状态

正如线程有不一样的状态同样，线程池也拥有不一样的运行状态。源码中提出，线程池有五种状态，分别为：

1. RUNNING：运行状态，不断接收任务并处理它们。
2. SHUTDOWN：关闭状态，不接收新任务，可是会处理工做队列中排队的任务。
3. STOP：中止状态，不接收新任务，清空工做队列且不会处理工做队列的任务。
4. TIDYING：待终止状态，此状态下，任务队列和线程池都为空。
5. TERMINATED：终止状态，线程池关闭。

如何让线程不被销毁

文章开头说到，线程在执行完毕以后会被操做系统回收销毁，那么线程池时如何保障线程不被销毁？首先看一个测试用例：

public static void testThreadState()
{
    Thread thread = new Thread(() -> System.out.println("Hello world")); // 建立一个线程
    System.out.println(thread.getState()); // 此时线程的状态为NEW
    thread.start(); // 启动线程，状态为RUNNING
    System.out.println(thread.getState());
    try
    {
      thread.join();
      System.out.println(thread.getState()); // 线程运行结束，状态为TERMINATED
      thread.start(); // 此时再启动线程会发生什么呢？
    } catch (InterruptedException e)
    {
      e.printStackTrace();
    }
}

结果输出：

NEW
RUNNABLE
Hello world
TERMINATED
Exception in thread "main" java.lang.IllegalThreadStateException
	at java.base/java.lang.Thread.start(Thread.java:794)
	at misc.ThreadPoolExecutorTest.testThreadState(ThreadPoolExecutorTest.java:90)
	at misc.ThreadPoolExecutorTest.main(ThreadPoolExecutorTest.java:114)

能够看出，当一个线程运行结束以后，咱们是不可能让线程起死回生从新启动的。既然如此ThreadPoolExecutor如何保障线程执行完一个任务不被销毁而继续执行下一个任务呢？

其实这里就要讲到咱们最开始传入的参数workQueue，它的接口类型为BlockingQueue<T>，直译过来就是阻塞队列。这中队列有个特色，就是当队列为空而尝试出队操做时会阻塞。

基于阻塞队列的如上特色，ThreadPoolExecutor采用不断循环+阻塞队列的方式来实现线程不被销毁。

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

关闭线程池

想要关闭线程池能够经过调用shutdown()和shutdownNow()方法实现。两种方法有所不一样，其中调用shutdown()方法会中止接收新的任务，处理工做队列中的任务，调用这个方法以后线程池会进入SHUTDOWN状态，此方法无返回值而且不抛出异常。

而shutdownNow()方法会中止接收新的任务，并且会返回未完成的任务集合，同时这个方法也会抛出异常。

如何建立一个适应业务背景的线程池

线程池建立有七个参数，这几个参数的相互做用能够建立出适应特定业务场景的线程池。其中最为重要的有三个参数分别为：corePoolSize，maximumPoolSize，workQueue。其中前两个参数已经在上文中做了详细介绍，而workQueue参数在线程池建立中也极为重要。workQueue主要有三种：

1. SynchronousQueue：这个队列只能容纳一个元素，并且只有当队列为空时能够入队。
2. ArrayBlockingQueue：这是一个固定容量大小的队列。
3. LinkedBlockingQueue：链式阻塞队列，容量无限。

经过上述三种队列的特性咱们能够得知，

1. 当使用SynchronousQueue的时候，老是倾向于新建线程处理请求，若是线程池大小参数设置的很大，那么线程数量倾向于无限增加。这样的线程池可以高效处理突发增加的请求，并且处理效率很高，可是开销很大。
2. 当使用ArrayBlockingQueue的时候，线程池所能处理的瞬时最大任务量为队列大小 + 线程池最大数量，这样的线程池中规中矩，使用的业务场景不少，具体还需结合业务场景来调配三个参数的大小。例如I/O密集型的场景，多数的线程处于阻塞状态，为了提升系统吞吐量，咱们但愿可以有多数线程来处理IO。这样的话咱们偏向于将corePoolSize设置的大一点。并且阻塞队列大小不要设置很大，同时maximumPoolSize也设置的大一点。
3. 当使用LinkedBlockingQueue时，线程池的maximumPoolSize参数会失效，由于按照任务提交流程来看，LinkedBlockingQueue能够无限制地容纳任务，天然不会出现队列没法工做，新建线程处理的状况。使用LinkedBlockingQueue能够平稳地处理一些请求激增的状况，可是处理效率不会提升，仅仅可以起到必定的缓冲做用。