10. ThreadPool 线程池

10. ThreadPool 线程池

10.1 线程池介绍

 线程池（thread pool）：一种线程使用模式。线程过多会带来调度开销， 进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理 者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代 价。线程池不仅能够保证内核的充分利用，还能防止过分调度。 例子： 10 年前单核 CPU 电脑，假的多线程，像马戏团小丑玩多个球，CPU 需 要来回切换。 现在是多核电脑，多个线程各自跑在独立的 CPU 上，不用切换 效率高。

 **线程池的优势：**线程池做的工作只要是控制运行的线程数量，处理过程中将任 务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量， 超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

它的主要特点为：

1. 降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
2. 提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行。
3. 提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资 源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
4. Java 中的线程池是通过 Executor 框架实现的，该框架中用到了 Executor，Executors， ExecutorService，ThreadPoolExecutor 这几个类

10.2 参数说明

• corePoolSize 线程池的核心线程数

• maximumPoolSize 能容纳的最大线程数量

• keepAliveTime 空闲线程存活时间

• unit 存活的时间单位

• workQueue 存放提交但未执行额度任务队列

• threadFactory 创建线程的工厂类

• handler 等待队列满后的拒绝策略

   线程池中，有个三个重要的参数，决定影响了拒绝策略：corePoolSize-核心线程数，也即最小的线程数。workQueue-阻塞队列。maximumPoolSize- 最大线程数

   当提交任务数大于corePoolSize 的时候，会优先将任务放到workQueue阻塞队列中。当阻塞队列饱和后，会扩充线程此中线程数，直到maximumPoolSize 最大线程数配置。此时，再多的任务，则会触发线程池的拒绝策略，。

   总结起来，当提价的任务数大于(workQueue.size()+maximumPoolSize)，就会线程池的拒绝策略。

  10.3 拒绝策略

  1. AbortPolicy

     默认策略直接抛出RejectedExecutionException异常执行系统正常运行。

  2. CallerRunsPolicy

     “调用者运行”,一种调节机制，该策略不会抛弃任务，也不会抛出异常，而是将某些任务退回到调用者，从而降低新任务的流量。

  3. DiscardOldestPoilcy

     抛弃队列中等待最久的任务，然后把当前任务加入队列中，尝试再次提交当前任务。

  4. DiscardPolicy

     该策略默默地丢弃无法处理的任务，不给予任何处理也不抛异常。

  10.4 线程池的种类与创建

  10.4.1 newCachedThreadPool

   作用：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

   特定：

  • 线程池数量没有固定，可达到最大值(Interger.MAX_VALUE)

  • 线程池中的线程可进行缓存重复利用和回收(回收默认时间为1分钟)

  • 当线程池中，没有可用线程，会重新创建一个线程

    创建方式:

    /**
    * 可缓存线程池
    * @return
    */
    public static ExecutorService newCachedThreadPool(){
    /**
    * corePoolSize 线程池的核心线程数
    * maximumPoolSize 能容纳的最大线程数
    * keepAliveTime 空闲线程存活时间
    * unit 存活的时间单位
    * workQueue 存放提交但未执行任务的队列
    * threadFactory 创建线程的工厂类:可以省略
    * handler 等待队列满后的拒绝策略:可以省略
    */
    return new ThreadPoolExecutor(0,
    	Integer.MAX_VALUE,
    	60L,
    	TimeUnit.SECONDS,
    	new SynchronousQueue<>(),
    	Executors.defaultThreadFactory(),
    	new ThreadPoolExecutor.AbortPolicy());
    }
    

    **场景：**适用创建一个可无限扩大的线程池，服务器负载压力较轻，执行时间较短，任务多的场景。

    10.4.2 newFixedThreadPool

     **作用：**创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行着些线程。在任意点，在大多数线程会出于处理任务的活动状态。如果在所有线程出于活动状态的时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线 程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池 中的线程将一直存在。

    特征：

  • 线程池中的线程处于一定的量，可以很好的控制线程的并发量。

  • 线程可以重复被使用，在显示关闭之前，都将一直存在。

  • 超出一定量的线程被提交时候需要在队列中等待。

  创建方式

  /**
  * 固定长度线程池
  * @return
  */
  public static ExecutorService newFixedThreadPool(){
  /**
  * corePoolSize 线程池的核心线程数
  * maximumPoolSize 能容纳的最大线程数
  * keepAliveTime 空闲线程存活时间
  * unit 存活的时间单位
  * workQueue 存放提交但未执行任务的队列
  * threadFactory 创建线程的工厂类:可以省略
  * handler 等待队列满后的拒绝策略:可以省略
  */
  return new ThreadPoolExecutor(10,
  	10,
  	0L,
  	TimeUnit.SECONDS,
  	new LinkedBlockingQueue<>(),
  	Executors.defaultThreadFactory(),
  	new ThreadPoolExecutor.AbortPolicy());
  }
  

  场景

   适用于可以预测线程数量的业务中，或者服务器负载较重，对线程数有严格限制场景。

10.4.3 newSingleThreadExecutor

 作用：创建一个使用单位worker线程的Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭之前的执行期间出现失败终止了此单个线程那么如果需要，一个新线程将替代他执行后续的任务）。可保证顺序地执行各 个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool 不同，可保证无需重新配置此方法所返回的执行程序即 可使用其他的线程。

特征：

 线程池中最多执行 1 个线程，之后提交的线程活动将会排在队列中以此 执行

创建方式：

/**
* 单一线程池
* @return
*/
public static ExecutorService newSingleThreadExecutor(){
/**
* corePoolSize 线程池的核心线程数
* maximumPoolSize 能容纳的最大线程数
* keepAliveTime 空闲线程存活时间
* unit 存活的时间单位
* workQueue 存放提交但未执行任务的队列
* threadFactory 创建线程的工厂类:可以省略
* handler 等待队列满后的拒绝策略:可以省略
*/
return new ThreadPoolExecutor(1,
	1,
	0L,
	TimeUnit.SECONDS,
	new LinkedBlockingQueue<>(),
	Executors.defaultThreadFactory(),
	new ThreadPoolExecutor.AbortPolicy());
}

**场景：**适用于需要保证顺序执行各个任务，并且在任意时间点，不会同时有多个线程场景。

10.4.4 newScheduleThreadPool

作用：线程池支持定时周期性执行任务，创建一个corePoolSize为传入参 数，最大线程数为整形的最大数的线程池。

特征

• 线程池中具有指定数量的线程，即便是空线程也将保留

• 可定时或者 延迟执行线程活动

创建方式

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) {
	return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}

场景

 适用于需要多个后台线程执行周期任务的场景。

10.4.5 newWorkStealingPool

 jdk1.8 提供的线程池，底层使用的事ForkJoinPool实现，创建一个拥有任务队列的线程池，可以减少连接数，创建当前可用cpu核数的线程来并执行任务。

创建方式

public static ExecutorService newWorkStealingPool(int parallelism) {
    /**
    * parallelism：并行级别，通常默认为 JVM 可用的处理器个数
    * factory：用于创建 ForkJoinPool 中使用的线程。
    * handler：用于处理工作线程未处理的异常，默认为 null
    * asyncMode：用于控制 WorkQueue 的工作模式:队列---反队列
    */
	return new ForkJoinPool(parallelism,ForkJoinPool.defaultForkJoinWorkerThreadFactory,null,true);
}

场景

适用于大耗时，可并行执行的场景。

案例

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(2,
                5,
                2L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        try {
            for (int i = 0; i < 5  ; i++) {
                // 执行
                executorService.execute(() -> {
                    try {
                        System.out.println(Thread.currentThread().getName() + "正在办理业务");
                        Thread.sleep(5000);
                        System.out.println(Thread.currentThread().getName() + "办理业务结束");
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

    }
}

1. 在创建了线程池后，线程池中的线程数为零。

2. 当调用execute()方法添加一个任务请求时，线程会做出如下判断；

   1. 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
   2. 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列；
   3. 如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立即运行这个任务；
   4. 如果队列满了且正在运行的线程数量大于或等于maxmumPoolSize,那么线程池会启动饱和拒绝策略来执行。

3. 当一个线程完成任务时，它会从队列中取消一个任务来执行。

4. 当一个线程无事可以做超过一定时间(keepAliveTime)时，线程会判断：

   1. 如果当前运行的线程大于大于corePoolSize，那么这个线程就会被停掉。
   2. 所以线程池的所有任务完成后，它最终会收缩到corePoolSized的大小。

10.5 注意事项

1. 项目中创建多线程时，使用常见的三种线程池创建方式，单一、可变、定长都有一定的问题，原因是FixedThreadPool和SingleThreadExecutror底层都是用LinkedBlockingQueue实现的，这个队列最大长度为Integer.MAX_VALUE，可能会创建大量的线程,容易导致OOM。所以实际产生一般通过ThreadPoolExecutor7个参数，自定义线程池。
2. 创建线程池推荐适用 ThreadPoolExecutor 及其 7 个参数手动创建
   • corePoolSize 线程池的核心线程数
   • maximumPoolSize 能容纳的最大线程数
   • keepAliveTime 空闲线程存活时间
   • unit 存活的时间单位
   • workQueue 存放提交但未执行任务队列
   • threadFactory 创建线程的工厂类
   • handler 等待队列满后的拒绝策略