线程池工作机制

1、线程池的好处

• 降低资源消耗：重复利用已创建的线程，降低线程创建和销毁造成的消耗

• 提高响应速度：任务到达时，无需等待新线程的创建就能立即执行

• 提高线程的可管理性：线程是稀缺资源，使用线程池可以进行统一分配，监控和调优

2、线程池的创建的各个参数含义

ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务

/**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
 * parameters.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 * @param keepAliveTime when the number of threads is greater than
 *        the core, this is the maximum time that excess idle threads
 *        will wait for new tasks before terminating.
 * @param unit the time unit for the {@code keepAliveTime} argument
 * @param workQueue the queue to use for holding tasks before they are
 *        executed.  This queue will hold only the {@code Runnable}
 *        tasks submitted by the {@code execute} method.
 * @param threadFactory the factory to use when the executor
 *        creates a new thread
 * @param handler the handler to use when execution is blocked
 *        because the thread bounds and queue capacities are reached
 * @throws IllegalArgumentException if one of the following holds:<br>
 *         {@code corePoolSize < 0}<br>
 *         {@code keepAliveTime < 0}<br>
 *         {@code maximumPoolSize <= 0}<br>
 *         {@code maximumPoolSize < corePoolSize}
 * @throws NullPointerException if {@code workQueue}
 *         or {@code threadFactory} or {@code handler} is null
 */
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

corePoolSize 核心线程数

maximumPoolSize 最大线程数

线程池中允许的最大线程数。

keepAliveTime 线程空闲时的存活时间

当线程没有执行任务时，继续存活的时间。当线程池中的线程数量大于核心线程数时，即时没有新任务提交，核心线程外的线程也不会立即销毁，而是等待keepAliveTime才会销毁。

unit 线程空闲时的存活时间单位

workQueue 阻塞队列

阻塞队列：1）支持阻塞的插入方法：当队列满时，队列会阻塞插入元素的线程，直到队列不满；2）支持阻塞的移除方法：在队列为空时，获取元素的线程会等待队列变为非空

生产者和消费者模式能够解决并发问题，通过平衡生产线程和消费线程的工作能力来提高程序整体处理数据的速度。通过阻塞队列来进行通信，生产者生产完数据不用等待消费者处理，直接扔给阻塞队列，消费者也直接从阻塞队列中取数据，既能够解耦，又平衡两者的处理能力。

常用阻塞队列：

• ArrayBlockingQueue：由数组结构组成的有界阻塞队列

• LinkedBlockingQueue：由链表结构组成的有界阻塞队列

• SynchronousQueue：不存储元素的阻塞队列（OkHttp请求任务线程池用的这个 https://www.jianshu.com/p/0ccd09cd1c4c ）

• PriorityBlockingQueue：支持优先级排序的无界阻塞队列

• DelayQueue：带有延时的无界阻塞队列，其中元素只有当指定的延迟时间到了，才能从队列中获取元素

threadFactory 创建线程的工厂

handler 拒绝策略

当阻塞队列满了，且没有空闲的工作线程，继续提交任务会采取一种策略处理新任务。线程池提供了4中策略：

1）AbortPolicy：直接抛出异常，默认策略

2）CallerRunsPolicy：用调用者所在的线程来执行任务

3）DiscardPolicy：直接丢弃任务

4）DiscardOldestPolicy：丢弃阻塞队列中最靠前的任务

也可以自己根据应用场景（如记录日志或持久化储存不能处理的任务）实现RejectedExecutionHandler接口，自定义拒绝策略。

3、线程池的工作机制

看下ThreadPoolExecutor的execute方法：

public void execute(Runnable command) {
  if (command == null)
    throw new NullPointerException();

  int c = ctl.get();
  //①当前运行线程数<corePoolSize，则调用addWorker创建线程执行任务
  if (workerCountOf(c) < corePoolSize) {
    if (addWorker(command, true))
      return;
    c = ctl.get();
  }
  //②如果不小于corePoolSize，则将任务添加到workQueue
  if (isRunning(c) && workQueue.offer(command)) {
    int recheck = ctl.get();
    if (! isRunning(recheck) && remove(command))
      reject(command);
    else if (workerCountOf(recheck) == 0)
      addWorker(null, false);
  }
  //③放入workQueue失败，则创建线程执行任务，如果创建失败（当前线程数>maximumPoolSize）则拒绝该任务
  else if (!addWorker(command, false))
    reject(command);
}

流程图：

线程池执行流程.png

4、提交任务和关闭线程池

提交任务：

• execute方法用于提交不需要返回值的任务

• submit方法用于提交需要返回值的任务，线程池会返回一个Future类型的对象，通过这个对象可以判断任务是否执行成功，这个Future对象的get()方法来获取返回值（get方法会阻塞当前线程直到任务完成）

关闭线程池：遍历线程池中的工作线程，然后逐个调用interrupt方法来中断线程。

• shutdown将线程池的状态设置为SHUTDOWN，然后中断所有没有正在执行任务的线程

• shutdownNow将线程池的状态设置为STOP，中断正在执行任务的线程，并发返回没有被执行的任务列表

5、合理配置线程池

• 任务性质

  • CPU密集型任务

    如大量计算和内存操作，配置尽可能小的线程数，如Ncpu+1个线程的线程池（Ncpu是CPU核心数），留一个做切换；如果线程太多，会造成CPU频繁调度造成性能损耗。

  • IO密集型任务

    如磁盘，网络，文件操作等，IO操作不占用CPU，配置尽可能多的线程数，如2*Ncpu+1

    估算线程池最佳大小的公式：Nthreads = Ncpu * Ucpu * (1 + W/C)，其中 Ncpu = CPU核心数， Ucpu = CPU使用率，0~1，W/C = 等待时间与计算时间的比率

  • 混合型任务

    如果可以拆分，将其拆分为一个CPU密集型任务和一个IO密集型任务。如果两任务执行时间相差不大，那么拆分后的吞吐量高于串行；如果两任务执行时间相差很大，没必要拆分。

• 任务优先级

  任务的优先级不同可以使用PriorityBlockingQueue来处理，可以自定义类实现compareTo()方法来指定元素排序规则，或者初始化PriorityBlockingQueue时，指定构造参数Comparator来对元素进行排序。

• 任务的执行时间

  执行时间不同的任务可以交给不同规模的线程池来处理，或者使用优先级队列，让执行时间短的任务先执行。

• 任务的依赖性

  依赖其它系统的资源，如数据库连接池的任务，等待时间长，CPU空闲长，可以设置多的线程数

• 建议使用有界队列

  有界增加系统的稳定性和预警能力，无界可能撑满内存。