概述

到目前为止我们使用多线程应用程序的目的是尽可能多地使用计算机处理器资源。所以，看起来我们仅需要为每个独立的任务分配一个不同的线程，并让处理器确定在任何时间它总会处理其中的某一个任务。对小系统来说这样做很好，但是当系统越来越复杂时，线程的数量也会越来越多，操作系统将会花费更多时间处理锁分配，理清线程之间的关系，处理程序指令的时间实际上是很少的。为了让我们的程序具备可扩展性，我们将不得不对线程进行一些控制。

对那些生存周期比较短的线程来说，使用线程池来处理任务要比为每个任务都创建一个线程然后顺序地回收它们要高效得多。一个任务，在概念上说，可以是一个单一方法的执行过程或者一系列方法的执行过程。为一个线程预分配一个集合或者一个池来以备未来之需以及能够在一个应用程序中重用的技术称作线程池。

什么是线程池

线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而，增加可用线程数量是可能的。线程池中的每个线程都有被分配一个任务，一旦任务已经完成了，线程回到线程池中并等待下一次分配任务。

为什么使用线程池

在 Java 中，如果每当一个请求到达就创建一个新线程，开销是相当大的。在实际使用中，每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在处理实际的用户请求的时间和资源要多得多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个 JVM 里创建太多的线程，可能会导致系统由于 过度消耗内存 或“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。

线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。另外，通过适当地调整线程池中的线程数目可以防止出现资源不足的情况。

ThreadPoolExecutor

ThreadPoolExecutor的构造方法有四个，其实现如下：

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) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), handler);
}

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;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}
构造方法的参数
  • corePoolSize
    程池中的核心线程数，也就是是线程池中的最小线程数;
    核心线程在 allowCoreThreadTimeout 被设置为true时会超时退出，默认情况下不会退出
  • maximumPoolSize
    最大线程池大小,当活动线程数达到这个值，后续任务会被阻塞
  • keepAliveTime
    线程池中超过 corePoolSize 数目的非核心线程最大存活时间；闲置时的超时时长，超过这个值后，闲置线程就会被回收
  • unit
    keepAliveTime 参数的时间单位。这是一个枚举，详情请参考 TimeUnit
  • workQueue
    执行前用于保持任务的队列，也就是线程池的缓存队列（亦即阻塞队列）。此队列仅保持由 execute 方法提交的 Runnable 任务
  • threadFactory
    线程工厂，为线程池提供创建新线程的功能，它是一个接口，只有一个方法：Thread newThread(Runnable r)
  • RejectedExecutionHandler
    线程池对拒绝任务的处理策略。一般是队列已满或者无法成功执行任务，这时 ThreadPoolExecutor 会调用 handler 的 rejectedExecution 方法来通知调用者
ThreadPoolExecutor默认有四个拒绝策略
  1. ThreadPoolExecutor.AbortPolicy()：直接抛出异常RejectedExecutionException
  2. ThreadPoolExecutor.CallerRunsPolicy()：直接调用run()方法并且阻塞执行
  3. ThreadPoolExecutor.DiscardPolicy()：直接丢弃后来的任务
  4. ThreadPoolExecutor.DiscardOldestPolicy()：丢弃在队列中队首的任务
ThreadPoolExecutor的执行过程

一个任务通过execute(Runnable)方法被添加到线程池，任务就是一个Runnable类型的对象，任务的执行方法就是Runnable类型对象的run()方法。

  1. 当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程
  2. 当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
  3. 当线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务
  4. 当提交任务数超过maximumPoolSize，并且阻塞队列已满，新提交任务由RejectedExecutionHandler处理
  5. 当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
  6. 当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭