线程池作用

思考线程有什么弊端?

• 线程在java中是一个对象,更是操作系统的宝贵资源,线程创建和销毁都需要时间。如果创建时间+销毁时间 >执行时间就很不划算
• java对象占用堆内存,操作系统线程占用系统内存。根据JVM规范,一个线程默认最大栈大小1M,这个栈空间是需要从系统内存中分配的。线程过多,会消耗很多的内存
• 操作系统需要频繁切换线程上下文(所有线程都想被运行)影响性能

线程池的作用就是为了控制线程数量,管理线程生命周期

线程池原理-概念

线程池管理器

• 用于创建并管理线程池,包括创建线程,销毁线程,添加新任务

工作线程

• 线程池中线程,在没有任务时处于等待状态,可以循环的执行任务

任务接口

• 每个任务都必须实现的接口,以供工作线程调度任务的执行,它主要规范了任务的入口,任务执行完后的收尾工作,任务的执行状态等

任务队列

• 用于存放没有处理的任务,提供一种缓存机制

线程池API简介

类型	名称	描述
接口	Executor	最上层的接口,定义了执行任务的方法execute
接口	ExecutorService	继承了Executor接口,扩展了Callable、Future、关闭方法
接口	ScheduledExecutorService	继承了ExecutorService接口,扩展了定时任务相关方法
实现类	ThreadPoolExecutor	基础、标准的线程池实现
实现类	ScheduledThreadPoolExecutor	继承了ThreadPoolExecutor实现了ScheduledExecutorService接口中相关定时任务的方法

可以认为ScheduledThreadPoolExecutor是最丰富的实现类

ExecutorService

//监测ExecutorService是否已经关闭,直到所有任务完成执行,或超时完成,或当前线程被中断
executorService.awaitTermination(long timeout, TimeUnit unit);
//执行给定的任务集合,执行完毕后,返回结果
executorService.invokeAll(Collection<? extends Callable<T>> tasks);
//执行给定的任务集合,执行完毕或者超时后,返回结果,其他任务终止
executorService. invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit);
//执行给定的任务,任意一个执行成功则返回结果,其他任务终止
executorService.invokeAny(Collection<? extends Callable<T>> tasks);
//执行给定的任务,任意一个执行成功或者超时则返回结果,其他任务终止
executorService.invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit);
//如果此线程池已关闭,则返回true
executorService.isShutdown();
//如果关闭后所有任务都已完成,则返回true
executorService.isTerminated();
//优雅关闭线程池,之前提交的任务将被执行,但是不会接收新的任务
executorService.shutdown();
//尝试停止所有正在执行的任务,停止等待任务的处理,并返回等待执行的任务列表
executorService.shutdownNow();
//提交一个用于执行的Callable返回任务,并返回一个Future<T>对象,用于获取Callable执行结果
executorService.submit(Callable<T> task);
//提交可运行任务执行,并返回一个Future对象,执行结果为null
executorService.submit(Runnable task);
//提交可运行任务执行,并返回一个Future对象,执行结果为传入的result
executorService.submit(Runnable task,T result);

ScheduledExecutorService

在ExecutorService定义的API基础上扩展了以下几个定时相关的API

//创建并执行一个一次性有返回值的任务,过了延迟时间就会被执行
scheduledExecutorService.schedule(Callable < V > callable, long delay, TimeUnit unit);
//创建并执行一个一次性的任务,过了延迟时间就会被执行
scheduledExecutorService.schedule(Runnable command, long delay, TimeUnit unit);//创建并执行一个周期性的任务,过了初始延迟时间第一次被执行,后续以给定的周期时间执行。执行过程中发生了异常,那么任务就停止
//一次任务执行时长超过了周期时间,下一次任务会等到该次任务执行结束后,立刻执行,这也是它和scheduleWithFixedDelay的重要区别
scheduledExecutorService.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);//创建并执行一个周期性的任务,过了初始延迟时间第一次被执行,后续以给定的周期时间执行。执行过程中发生了异常,那么任务就停止
//一次任务执行时长超过了周期时间,下一次任务会在该次任务执行结束时间的基础上,计算执行延时。对于超过周期的长时间处理任务的不同处理方式,这是它和scheduleAtFixedRate的重要区别
scheduledExecutorService.scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);

特别注意scheduleAtFixedRate和scheduleWithFixedDelay的区别,其实对于正常执行的情况来说他们没有区别,可是对于任务执行时间 > 周期任务的调度时间他们就有不同的处理方式

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);scheduledExecutorService.scheduleAtFixedRate(() -> {System.err.println("scheduleAtFixedRate开始执行"+ LocalDateTime.now());try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.err.println("scheduleAtFixedRate执行本次任务花了3秒,影响了每隔2秒执行一次的周期任务.得立刻调度周期任务"+ LocalDateTime.now());}, 1, 2, TimeUnit.SECONDS);scheduledExecutorService.scheduleWithFixedDelay(() -> {System.out.println("scheduleWithFixedDelay开始执行"+ LocalDateTime.now());try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("scheduleWithFixedDelay执行本次任务花了3秒,影响了每隔2秒执行一次的周期任务.从现在开始计算到了周期时间(2秒)后再调度周期任务"+ LocalDateTime.now());}, 1, 2, TimeUnit.SECONDS);

scheduleAtFixedRate如果执行任务的时间 > 周期任务的调度时间任务执行结束后会立刻调度新的周期任务

scheduleWithFixedDelay如果执行任务的时间 > 周期任务的调度时间任务执行结束后会在当前时间的基础上重新计算调度新的周期任务时间

Executors工具类

可以自己实例化线程池,也可以使用Executors创建线程池的工厂类,常用方法如下

//创建一个固定大小,任务队列容量无界的线程池.核心线程数=最大线程数
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5);//创建一个大小无界的缓存线程池,它的任务队列是一个同步队列.任务加入到线程池中,如果线程池中有空闲线程,则用空闲线程执行,如无则创建新线程执行.
//线程池中的线程空闲超过60秒,将被销毁释放.线程数随任务的多少变化.适用于执行消耗较小的异步任务.核心线程数=0,最大线程数量=Integer.MAX_VALUE
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();//只有一个线程来执行无界任务队列的单一线程池.该线程池确保任务按加入的顺序一个一个依次执行。当唯一的线程因任务异常中止时,将创建一个新的线程来继续执行后续的任务
//与newFixedThreadPool(1)的区别在于单一线程池的池大小在newSingleThreadExecutor方法中硬编码,不能再改变
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();//创建一个可以执行定时任务的线程池.该池的核心线程数由参数指定,最大线程数Integer.MAX_VALUE
ExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);

Executors工具类的队列都是无界的,这可能会导致程序内存溢出,所以尽量自己实例化线程池,具体原因得看线程池execute内部的实现原理

线程池execute内部实现原理

如果没有搞懂execute的内部原理,线上环境很可能会出现内存溢出

// 线程池信息:核心线程数量5,最大线程数量10.无界队列.超出核心线程数量的线程存活时间：5秒
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());for (int i = 0; i < 15; i++) {int finalI = i;threadPoolExecutor.execute(() -> {try {TimeUnit.SECONDS.sleep(3);System.out.println("执行结束" + finalI);} catch (InterruptedException e) {e.printStackTrace();}});System.out.println("任务提交成功" + i);
}
//查看线程数量,查看队列等待数量
TimeUnit.SECONDS.sleep(1);
System.err.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
System.err.println("当前线程池等待数量为:" + threadPoolExecutor.getQueue().size());//等待15秒,查看线程数量和队列数量(理论上,会被超出核心线程数量的线程执行)
TimeUnit.SECONDS.sleep(9);
System.err.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
System.err.println("当前线程池等待数量为:" + threadPoolExecutor.getQueue().size());

从执行结果来看,15个任务已经提交到线程池.但是处理任务的线程始终只有5个,并没有根据最大线程数加开线程

难道设置的最大线程数是摆设的吗?为什么会没有加开线程呢?

带着问题点来看下ThreadPoolExecutor.execute的源码是如何实现的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6hedcjhC-1591010373041)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200529180438418.png)]

可以看到官方也给出了注释,简单来说分为三步

1. 判断线程池中线程的存活数量是否小于核心线程数量,如果小于加开线程处理该任务
2. 超过核心线程数量加入任务队列,加入成功等待线程池中存活线程处理
3. 加入队列失败判断线程的存活数量是否小于最大线程数数量如果小于加开线程处理该任务,否则拒绝执行

总结

我: 关于这一点颠覆了之前对线程池的认知,我觉得只要超过核心线程数再有任务进来你会加开线程

线程池: 我不要你觉得我要我觉得,只要任务队列能一直缓存我就不会加开新的线程

线程池的使用

拒绝策略

// 创建一个核心线程数=5,最大线程数=10,任务队列=3的线程池,指定自己的拒绝策略
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10,5, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<>(3), (r, executor) -> System.err.println("有任务被拒绝执行了"));
// 执行十五个任务
for (int i = 0; i < 15; i++) {int finalI = i;threadPoolExecutor.execute(() -> {try {TimeUnit.SECONDS.sleep(3);System.out.println("执行结束" + finalI);} catch (InterruptedException e) {e.printStackTrace();}});
}
System.err.println("当前线程池的线程数量为:" + threadPoolExecutor.getPoolSize());
System.err.println("当前线程池的任务数量为:" + threadPoolExecutor.getQueue().size());
threadPoolExecutor.shutdown();

有两个任务被拒绝执行了因为线程池最大容纳的任务数量为最大线程数+任务队列数,所以图上线程池最大容纳的任务是10+3=13,可是提交了15个任务,15-13 = 2 所以会有两个任务被拒绝执行了

当前线程池的线程数量为10是因为线程池最大数量设置的是10,所以最多只有十个线程处理任务

缓存线程池