Java线程池 ThreadPoolExecutor 详解
作者:??话唠扇贝? 发布时间:2021-05-24 10:35:42
一 为什么要使用线程池
对于操作系统而言,创建一个线程的代价是十分昂贵的, 需要给它分配内存、列入调度,同时在线程切换时要执行内存换页,清空 CPU 缓存,切换回来时还要重新从内存中读取信息,破坏了数据的局部性。因此在并发编程中,当线程创建过多时,会影响程序性能,甚至引起程序崩溃。
而线程池属于池化管理模式,具有以下优点:
降低资源消耗:通过重复利用已创建的线程降低线程创建和销毁造成的性能消耗。
提高响应速度:当任务到达时,任务可以不需要等到线程创建就能立即执行。
提高线程的可管理性:能够对线程进行统一分配、调优和监控。
二 线程池原理详解
2.1 线程池核心组成
线程池包含 3 个核心部分:
线程集合:核心线程和工作线程
阻塞队列:用于待执行任务排队
拒绝策略处理器:阻塞队列满后,对任务处理进行
2.2 Execute 原理
当一个新任务提交至线程池之后,线程池的处理流程如下:
首先判断当前运行的线程数量是否小于 corePoolSize。如果是,则创建一个工作线程来执行任务;如果都在执行任务,则进入步骤 2。
判断 BlockingQueue 是否已经满了,若没满,则将任务放入 BlockingQueue;若满了,则进入步骤 3。
判断当前运行的总线程数量是否小于 maximumPoolSize,如果是则创建一个新的工作线程来执行任务。
否则交给 RejectedExecutionHandler 来处理任务。
当 ThreadPoolExecutor 创建新线程时,通过 CAS 来更新线程池的状态 ctl。
三 线程池的使用
线程池的使用主要分为以下三个步骤:
3.1 创建线程池
3.1.1 自定义线程池
线程池的真正实现类是 ThreadPoolExecutor,其构造方法有如下 4 种:
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
(必需)线程池中的核心线程数,当提交一个任务时,线程池创建一个新线程执行任务,直到当前线程数等于 corePoolSize, 即使有其他空闲线程能够执行新来的任务, 也会继续创建线程;如果当前线程数为 corePoolSize,继续提交的任务被保存到阻塞队列中,等待被执行;如果执行了线程池的 **prestartAllCoreThreads()**方法,线程池会提前创建并启动所有核心线程。workQueue
(必需)用来保存等待被执行的任务的阻塞队列。ArrayBlockingQueue
: 基于数组结构的有界阻塞队列,按 FIFO 排序任务;LinkedBlockingQueue
: 基于链表结构的阻塞队列,按 FIFO 排序任务,吞吐量通常要高于 ArrayBlockingQueue;SynchronousQueue
: 一个不存储元素的阻塞队列,每个插入操作必须等到另一个线程调用移除操作,否则插入操作一直处于阻塞状态,吞吐量通常要高于 LinkedBlockingQueue;PriorityBlockingQueue
: 具有优先级的 * 阻塞队列;maximumPoolSize
(必需)线程池中能容纳的最大线程数。如果当前阻塞队列满了,且继续提交任务,则创建新的线程执行任务,前提是当前线程数小于 maximumPoolSize;当阻塞队列是 * 队列, 则 maximumPoolSize 则不起作用, 因为无法提交至核心线程池的线程会一直持续地放入 workQueue。keepAliveTime
(必需)线程闲置超时时长。如果超过该时长,非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时,核心线程也会超时回收。unit
(必需)keepAliveTime 的单位,常用的有:TimeUnit.MILLISECONDS(毫秒)、TimeUnit.SECONDS(秒)、TimeUnit.MINUTES(分)threadFactory
(可选)创建线程的工厂,通过自定义的线程工厂可以给每个新建的线程设置一个具有识别度的线程名。默认为 DefaultThreadFactoryhandler
(可选)线程池的饱和策略,当阻塞队列满了,且没有空闲的工作线程,如果继续提交任务,必须采取一种策略处理该任务,线程池提供了 4 种策略:AbortPolicy
: 直接抛出异常,默认策略;CallerRunsPolicy
: 用调用者所在的线程来执行任务;DiscardOldestPolicy
: 丢弃阻塞队列中靠最前的任务,并执行当前任务;DiscardPolicy
: 直接丢弃任务; 也可以根据应用场景实现 RejectedExecutionHandler 接口,自定义饱和策略,如记录日志或持久化存储不能处理的任务。
3.1.2 功能线程池
除了调用 ThreadPoolExecutor 自定义线程池的方式,其实 Executors 也已经为我们封装好了 4 种常见的功能线程池,如下:
定长线程池(FixedThreadPool)
定时线程池(ScheduledThreadPool)
可缓存线程池(CachedThreadPool)
单线程化线程池(SingleThreadExecutor)
定长线程池(FixedThreadPool)
特点:只有核心线程,线程数量固定,执行完立即回收,任务队列为链表结构的有界队列。
应用场景:控制线程最大并发数。
使用示例:
// 1. 创建定长线程池对象 & 设置线程池线程数量固定为 3
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
// 2. 创建好 Runnable 类线程对象 & 需执行的任务
Runnable task = new Runnable(){
public void run() {
...//待执行的耗时任务
}
};
// 3. 向线程池提交任务
fixedThreadPool.execute(task);
定时线程池(ScheduledThreadPool)
特点:核心线程数量固定,非核心线程数量无限,执行完闲置 10ms 后回收,任务队列为延时阻塞队列。
应用场景:执行定时或周期性的任务。
使用示例:
// 1. 创建定时线程池对象 & 设置线程池线程数量固定为 5
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 2. 创建好 Runnable 类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
...//待执行的耗时任务
}
};
// 3. 向线程池提交任务
scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟 1s 后执行任务
可缓存线程池(CachedThreadPool)
特点:无核心线程,非核心线程数量无限,执行完闲置 60s 后回收,任务队列为不存储元素的阻塞队列。
应用场景:执行大量、耗时少的任务。
使用示例:
// 1. 创建可缓存线程池对象
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 2. 创建好 Runnable 类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
...//待执行的耗时任务
}
};
// 3. 向线程池提交任务
cachedThreadPool.execute(task);
单线程化线程池(SingleThreadExecutor)
特点:只有 1 个核心线程,无非核心线程,执行完立即回收,任务队列为链表结构的有界队列。
应用场景:不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作,如数据库操作、文件操作等。
使用示例:
// 1. 创建单线程化线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 2. 创建好 Runnable 类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
...//待执行的耗时任务
}
};
// 3. 向线程池提交任务
singleThreadExecutor.execute(task);
3.1.3 功能线程池存在的问题
目前已不推荐使用功能线程池,而是通过自定义 ThreadPoolExecutor 的方式。因为直接使用功能线程池具有资源耗尽的风险。
newFixedThreadPool 和 newSingleThreadExecutor: 主要问题是堆积的请求处理队列均采用 LinkedBlockingQueue,可能会耗费非常大的内存,甚至 OOM。
newCachedThreadPool 和 newScheduledThreadPool: 主要问题是线程数最大数是 Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至 OOM。
3.2 向线程池提交任务
向线程池提交任务的流程非常简单,只需要向线程池的 execute 方法传入 Runnable 对象即可。
// 向线程池提交任务
threadPool.execute(new Runnable() {
@Override
public void run() {
... //待执行的任务
}
});
3.3 关闭线程池
当线程池不再使用时,需要手动关闭以释放资源。线程池关闭的原理是:遍历线程池中的所有线程,然后逐个调用线程的 interrupt 方法来中断线程。一般通过调用以下两个方法:
shutdown():将线程池里的线程状态设置成 SHUTDOWN 状态, 然后中断所有没有正在执行任务的线程。
shutdownNow():将线程池里的线程状态设置成 STOP 状态, 然后停止所有正在执行或暂停任务的线程. 只要调用这两个关闭方法中的任意一个, isShutDown() 返回 true. 当所有任务都成功关闭了, isTerminated()返回 true。
3.4 自定义线程池需要考虑因素
使用 ThreadPoolExecutor 自定义线程池时,需要从任务的优先级,任务的执行时间长短,任务的性质(CPU 密集/ IO 密集),任务的依赖关系这四个角度来分析。并且近可能地使用有界的工作队列。
性质不同的任务可用使用不同规模的线程池分开处理:
CPU 密集型: 尽可能少的线程,核心线程数 = CPU 核心数 + 1
IO 密集型: 尽可能多的线程, 核心线程数 = CPU 核心数 * 2
混合型: CPU 密集型的任务与 IO 密集型任务的执行时间差别较小,拆分为两个线程池;否则没有必要拆分。
来源:https://juejin.cn/post/7125044789623390216
猜你喜欢
- Java7中文件IO发生了很大的变化,专门引入了很多新的类:import java.nio.file.DirectoryStream;imp
- 前言自从国产之光fastjson频频暴雷,jackson json的使用是越来越广泛了。尤其是spring家族把它搞成了默认的JSON处理包
- 最近要做一个java web项目,因为页面不是很多,所以就没有前后端分离,前后端写在一起,这时候就用到thymeleaf了,以下是不动脑式的
- 题外话: 泛型与通配符是Java语法中比较难懂的两个语法,学习泛型和通配符的主要目的是能够看懂源码,实际使用的不多。1.泛型1.1泛型的用法
- java 接口回调实例详解首先官方对接口回调的定义是这样的,所谓回调:就是A类中调用B类中的某个方法C,然后B类中反过来调用A类中的方法D,
- 简介石头剪刀布游戏,进入游戏后,玩家需要输入玩家姓名。系统界面之后弹出欢迎界面,玩家可以选择出拳或者退出游戏。玩家选择出拳后同电脑出拳比较,
- SharedPreferences介绍:SharedPreferences是Android平台上一个轻量级的存储类,主要是保存一些常用的配置
- 本文实例讲解了iOS从背景图中取色的代码,分享给大家供大家参考,具体内容如下实现代码:void *bitmapData; //内存空间的指针
- 1、jdbc1) 含义:JDBC是java语言连接数据库,Java Date Base Connectivity2) jdbc的本质:在编程
- 继承什么是继承呢?继承(Inheritance)是一种联结类与类的层次模型。指的是一个类(称为子类、子接口)继承另外的一个类(称为父类、父接
- 本文实例为大家分享了Unity实现场景漫游相机的具体代码,供大家参考,具体内容如下前言拿到场景后总喜欢在场景里面玩一段时间,那这个脚本就是你
- 讲这个例子前,咱们先来看一个简单的程序:字符串数组实现数字转字母:#include <stdio.h>#include <
- 基于这段时间折腾redis遇到了各种问题,想着整理一下。本文主要介绍基于Spring+Mybatis以注解的形式整合Redis。废话少说,进
- 定义:用于顺序访问集合对象的元素,不需要知道集合对象的底层表示。特点: 1、它支持以不同的方式遍历一个
- Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spri
- 项目结构:运行效果:========================================================下面是代
- 使用flatMap列出子目录前面已经看到如何列出指定目录下的文件了。我们再来看下如何遍历指定目录的直接子目录(深度为1),先实现一个简单的版
- 一、概述我们对于这个图片肯定会非常熟悉,这两幅图片我们都可以看做是一个文件结构,对于这样的结构我们称之为树形结构。在数据结构中我们了解到可以
- 异常处理机制已经成为判断一门编程语言是否成熟的标准之一,其对代码的健壮性有很大影响。一直以来异常处理使用不是很得心应手,今天对异常进行了较为
- 其他的不多说了!我们来看看效果吧 一、实现方式一:直接引入compile方式A