JAVA并发编程之ThreadPool线程池技术的使用及深入理解
JAVA并发编程之ThreadPool线程池技术的使用及深入理解
- 1、线程池的简介
- 2、架构说明
- 3、Executors工具类
- 4、底层原理
-
- 4.1、线程池的7个重要参数
- 4.2、线程池底层工作原理(面试概率极高)
- 5、Executor工具类存在的问题
- 6、拒绝策略
- 7、自定义线程池
1、线程池的简介
引用举例：
10年前单核CPU电脑，假的多线程，像马戏团小丑玩多个球，CPU需要来回切换。
现在是多核电脑，多个线程各自跑在独立的CPU上，不用切换效率高。
线程池的特点：复用既有线程；控制最大线程并发数；管理线程资源。
线程池的优势：
线程池做的工作主要是控制运行的线程数量，如果线程数量超过了最大数量，超出数量的线程排队等候，等线程任务执行完毕，再从队列中取出任务来执行。
- 效率高,降低资源消耗。
- 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
- 性能高,提高响应速度。
- 当任务到达时，任务可以不需要等待线程创建就能立即执行。
- 提高线程的可管理性,避免资源浪费。
- 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
2、架构说明
Java中的线程池是通过Executor框架实现的，该框架中用到了Executor，ExecutorService，ThreadPoolExecutor这几个类。
(1)Executor顶层接口
Executor接口是顶层接口，只有一个execute方法，过于简单。通常不使用它，而是使用ExecutorService接口。
(2)ExecutorService接口
(3)AbstractExecutorService抽象类和ThreadPookExecutor实现类
结构：顶层接口Executor（execute） --> 子接口ExecutorService（submit shutdown） --> 抽象类AbstractExecutorService --> 实现类ThreadPoolExecutor
那么问题来了，怎么创建一个连接池对象呢？通常使用Executors工具类
3、Executors工具类
架构图可以看到Executors工具类，有没有联想到Collections，Arrays等。没错，可以用它快速创建线程池。
List list = Arrays.asList("");
ExecutorService threadPool = Executors.newCachedThreadPool();
Executors类中的方法
直接编码演示：每种连接池的效果
(1)固定大小线程池
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
//线程池的声明ExecutorService 底层接口只有一个声明方法太简单 ,所以使用executorService接口
//固定大小线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
//线程池执行任务
//可以把lambda表达式理解为简洁的匿名函数.
//我们先声明一个函数式接口(函数式接口:就是只有一个抽象方法的接口.
// lambda表达式和方法引用,只能用在函数式接口上),比较一下lambda表达式和匿名函数
executorService.execute(() -> {
System.out.println(Thread.currentThread().getName()+"执行了任务");
});
}
//当任务执行完了不会立马销毁销毁,会等待新的任务过来,手动销毁线程池
executorService.shutdown();
}
}
(2)无限大小线程池
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
//线程池的声明ExecutorService 底层接口只有一个声明方法太简单 ,所以使用executorService接口
//固定大小线程池
//ExecutorService executorService = Executors.newFixedThreadPool(5);
//无限大小线程池
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 100; i++) {
//线程池执行任务
//可以把lambda表达式理解为简洁的匿名函数.
//我们先声明一个函数式接口(函数式接口:就是只有一个抽象方法的接口.
// lambda表达式和方法引用,只能用在函数式接口上),比较一下lambda表达式和匿名函数
executorService.execute(() -> {
System.out.println(Thread.currentThread().getName()+"执行了任务");
});
}
//当任务执行完了不会立马销毁销毁,会等待新的任务过来,手动销毁线程池
executorService.shutdown();
}
}
(3)单个大小的线程池
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
//线程池的声明ExecutorService 底层接口只有一个声明方法太简单 ,所以使用executorService接口
//固定大小线程池
//ExecutorService executorService = Executors.newFixedThreadPool(5);
//无限大小线程池
//ExecutorService executorService = Executors.newCachedThreadPool();
//单个大小的线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 100; i++) {
//线程池执行任务
//可以把lambda表达式理解为简洁的匿名函数.
//我们先声明一个函数式接口(函数式接口:就是只有一个抽象方法的接口.
// lambda表达式和方法引用,只能用在函数式接口上),比较一下lambda表达式和匿名函数
executorService.execute(() -> {
System.out.println(Thread.currentThread().getName()+"执行了任务");
});
}
//当任务执行完了不会立马销毁销毁,会等待新的任务过来,手动销毁线程池
executorService.shutdown();
}
}
(4)定时任务线程池
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
System.out.println("定时任务初始化时间" + System.currentTimeMillis());
//固定周期执行
scheduledExecutorService.scheduleAtFixedRate(() -> {
//System.currentTimeMillis()计算方式与时间的单位转换
//延迟时间意义,需要矫正时间。
System.out.println(Thread.currentThread().getName() + "定时任务执行了" + System.currentTimeMillis());
}, 5, 10, TimeUnit.SECONDS);
// scheduledExecutorService.schedule(() -> {
// //System.currentTimeMillis()计算方式与时间的单位转换
// System.out.println(Thread.currentThread().getName()+"定时任务执行了"+System.currentTimeMillis());
// }, 10, TimeUnit.SECONDS);
}
}
工具类：Executors
- newFixedThreadPool(线程数)：固定大小的线程池，阻塞队列是最大整型
- newCachedThreadPool()：无限大小的线程池，最大可扩展线程数是最大整型
- newSingleThreadExecutor()：单个大小的线程池，阻塞队列是最大整型
- newScheduledThreadPool(线程数)：定时任务的线程池，最大可扩展线程数是最大整型
4、底层原理
上述案例中的四个方法的本质都是ThreadPoolExecutor的实例化对象，只是具体参数值不同。
4.1、线程池的7个重要参数
线程池的7个重要参数
- corePoolSize：核心线程数(线程池中的常驻核心线程数,有多少线程数)
- maximumPoolSize：最大可扩展线程数(线程池中能够容纳同时 执行的最大线程数，此值必须大于等于1,最大可扩展大小线程数）
- keepAliveTime：扩展线程数的空闲时间（多余的空闲线程的存活时间 当前池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到 只剩下corePoolSize个线程为止,扩展线程数的生存时间。）
- unit：keepAliveTime 时间的单位
- workQueue：阻塞任务队列 （被提交但尚未被执行的任务,候客区大小）
- threadFactory：表示生成线程池中工作线程的线程工厂( 用于创建线程，一般默认的即可)
- handler：拒绝执行处理器,拒绝策略(表示当队列满了，并且工作线程大于 等于线程池的最大线程数（maximumPoolSize）时，如何来拒绝 请求执行的runnable的策略)
4.2、线程池底层工作原理(面试概率极高)
具体流程：
重要的事情说三遍：以下重要：以下重要：以下重要：
-
线程池初始化之后,在创建了线程池后，线程池中的线程数为0。
-
向线程池提交一个任务,当调用execute()方法添加一个请求任务时，线程池会做出如下判断：
-
如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
-
如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入阻塞队列；
-
如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
-
如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。
-
(简述面试版本)
- 1.线程池初始化之后，线程数为0
- 2.向线程池提交一个任务进行execute，此时线程池底层会做出如下判断：
- 1.判断核心线程数是否已满，未满创建新的核心线程处理该任务
- 2.如果核心线程数已满，判断阻塞队列是否已满，未满则放入阻塞队列
- 3.如果阻塞队列已满，判断最大可扩展性线程数是否已满，未满则创建新的非核心线程处理该任务
- 4.如果最大可扩展线程数已满，执行拒绝策略
- 3.一个任务执行完之后，线程会从阻塞队列中获取下一个任务执行
- 4.一个线程如果空闲时间到达生存时间，依然要做出判断：判断当前线程数是否大于核心线程数，大于则销毁当前线程。直至核心线程数。
5、Executor工具类存在的问题
在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。
而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活；使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。
不推荐使用Executors工具类初始化线程池，因为他们都可能导致OOM。推荐使用ThreadPoolExecutor构造方法创建线程池
6、拒绝策略
一般我们创建线程池时，为防止资源被耗尽，任务队列都会选择创建有界任务队列，但种模式下如果出现任务队列已满且线程池创建的线程数达到你设置的最大线程数时，这时就需要你指定ThreadPoolExecutor的RejectedExecutionHandler参数即合理的拒绝策略，来处理线程池"超载"的情况。
ThreadPoolExecutor自带的拒绝策略如下：
例子:
- AbortPolicy(默认)：直接抛出RejectedExecutionException异常阻止系统正常运行
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(5));
for (int i = 0; i < 20; i++) {
threadPoolExecutor.submit(() -> {
System.out.println(Thread.currentThread().getName() + "执行了任务");
});
}
}
}
- CallerRunsPolicy：“调用者运行”一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(5),Executors.defaultThreadFactory(),new java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 0; i < 20; i++) {
threadPoolExecutor.submit(() -> {
System.out.println(Thread.currentThread().getName() + "执行了任务");
});
}
}
}
- DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加人队列中 尝试再次提交当前任务。
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 0; i < 20; i++) {
int finalI = i;
threadPoolExecutor.submit(() -> {
System.out.println(Thread.currentThread().getName() + "执行了任务"+ finalI);
});
}
}
}
- DiscardPolicy：该策略默默地丢弃无法处理的任务，不予任何处理也不抛出异常。 如果允许任务丢失，这是最好的一种策略。
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardPolicy());
for (int i = 0; i < 20; i++) {
int finalI = i;
threadPoolExecutor.submit(() -> {
System.out.println(Thread.currentThread().getName() + "执行了任务"+ finalI);
});
}
}
}
以上内置的策略均实现了RejectedExecutionHandler接口，也可以自己扩展RejectedExecutionHandler接口，定义自己的拒绝策略
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
(Runnable r, java.util.concurrent.ThreadPoolExecutor executor) ->{
System.out.println("执行了拒绝策略(自定义拒绝策略)");
});
for (int i = 0; i < 20; i++) {
int finalI = i;
threadPoolExecutor.submit(() -> {
System.out.println(Thread.currentThread().getName() + "执行了任务"+ finalI);
});
}
}
}
7、自定义线程池
自定义线程池：
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
//自定义线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(5));
for (int i = 0; i < 20; i++) {
threadPoolExecutor.submit(() -> {
System.out.println(Thread.currentThread().getName() + "执行了任务");
});
}
}
}