线程池的好处
线程使应用能够更加充分合理地协调利用CPU、内存、网络、I/O等系统资源. 线程的创建需要开辟虚拟机栈、本地方法栈、程序计数器等线程私有的内存空间; 在线程销毁时需要回收这些系统资源. 频繁地创建和销毁线程会浪费大量的系统资源,增加并发编程风险.
在服务器负载过大的时候,如何让新的线程等待或者友好地拒绝服务?
这些都是线程自身无法解决的; 所以需要通过线程池协调多个线程,并实现类似主次线程隔离、定时执行、周期执行等任务.
线程池的作用包括: ●利用线程池管理并复用线程、控制最大并发数等 ●实现任务线程队列缓存策略和拒绝机制 ●实现某些与时间相关的功能 如定时执行、周期执行等 ●隔离线程环境 比如，交易服务和搜索服务在同一台服务器上,分别开启两个线程池,交易线程的资源消耗明显要大; 因此,通过配置独立的线程池,将较慢的交易服务与搜索服务隔离开,避免各服务线程相互影响.
在开发中,合理地使用线程池能够带来3个好处
- 降低资源消耗 通过重复利用已创建的线程,降低创建和销毁线程造成的系统资源消耗
- 提高响应速度 当任务到达时,任务可以不需要等到线程创建就能立即执行
- 提高线程的可管理性 线程是稀缺资源,如果过多地创建,不仅会消耗系统资源，还会降低系统的稳定性，导致使用线程池可以进行统一分配、调优和监控。
在了解线程池的基本作用后，我们学习一下线程池是如何创建线程的
创建线程池
首先从ThreadPoolExecutor构造方法讲起,学习如何自定义ThreadFactory和RejectedExecutionHandler; 并编写一个最简单的线程池示例. 然后,通过分析ThreadPoolExecutor的execute和addWorker两个核心方法; 学习如何把任务线程加入到线程池中运行.
- ThreadPoolExecutor 的构造方法如下
-
第1个参数: corePoolSize 表示常驻核心线程数 如果等于0,则任务执行完之后,没有任何请求进入时销毁线程池的线程; 如果大于0,即使本地任务执行完毕,核心线程也不会被销毁. 这个值的设置非常关键; 设置过大会浪费资源; 设置过小会导致线程频繁地创建或销毁.
-
第2个参数: maximumPoolSize 表示线程池能够容纳同时执行的最大线程数 从第1处来看,必须>=1. 如果待执行的线程数大于此值,需要借助第5个参数的帮助,缓存在队列中. 如果
maximumPoolSize = corePoolSize,即是固定大小线程池. -
第3个参数: keepAliveTime 表示线程池中的线程空闲时间 当空闲时间达到
keepAliveTime时,线程会被销毁,直到只剩下corePoolSize个线程; 避免浪费内存和句柄资源. 在默认情况下,当线程池的线程数大于corePoolSize时,keepAliveTime才起作用. 但是当ThreadPoolExecutor的allowCoreThreadTimeOut = true时,核心线程超时后也会被回收. -
第4个参数: TimeUnit表示时间单位 keepAliveTime的时间单位通常是TimeUnit.SECONDS.
-
第5个参数: workQueue 表示缓存队列 当请求的线程数大于
maximumPoolSize时,线程进入BlockingQueue. 后续示例代码中使用的LinkedBlockingQueue是单向链表,使用锁来控制入队和出队的原子性; 两个锁分别控制元素的添加和获取,是一个生产消费模型队列. -
第6个参数: threadFactory 表示线程工厂 它用来生产一组相同任务的线程; 线程池的命名是通过给这个factory增加组名前缀来实现的. 在虚拟机栈分析时,就可以知道线程任务是由哪个线程工厂产生的.
-
第7个参数: handler 表示执行拒绝策略的对象 当超过第5个参数
workQueue的任务缓存区上限的时候,就可以通过该策略处理请求,这是一种简单的限流保护. 友好的拒绝策略可以是如下三种: (1 ) 保存到数据库进行削峰填谷;在空闲时再提取出来执行 (2)转向某个提示页面 (3)打印日志
2.1.1 corePoolSize(核心线程数量)
线程池中应该保持的主要线程的数量.即使线程处于空闲状态，除非设置了allowCoreThreadTimeOut这个参数,当提交一个任务到线程池时,若线程数量<corePoolSize,线程池会创建一个新线程放入works(一个HashSet)中执行任务,即使其他空闲的基本线程能够执行新任务也还是会创建新线程 等到需要执行的任务数大于线程池基本大小时就不再创建,会尝试放入等待队列workQueue 如果调用线程池的prestartAllCoreThreads(),线程池会提前创建并启动所有核心线程
2.1.2 maximumPoolSize（线程池最大线程数）
线程池允许创建的最大线程数 若队列满,并且已创建的线程数小于最大线程数,则线程池会再创建新的线程放入works中执行任务,CashedThreadPool的关键,固定线程数的线程池无效 若使用了无界任务队列,这个参数就没什么效果
-
workQueue 存储待执行任务的阻塞队列，这些任务必须是
Runnable的对象（如果是Callable对象，会在submit内部转换为Runnable对象） -
runnableTaskQueue(任务队列):用于保存等待执行的任务的阻塞队列.可以选择以下几个阻塞队列.
- LinkedBlockingQueue:一个基于链表结构的阻塞队列,此队列按FIFO排序元素,吞吐量通常要高于ArrayBlockingQueue.静态工厂方法Executors.newFixedThreadPool()使用了这个队列
- SynchronousQueue:一个不存储元素的阻塞队列.每个插入操作必须等到另一个线程调用移除操作,否则插入操作一直处于阻塞状态,吞吐量通常要高于Linked-BlockingQueue,静态工厂方法Executors.newCachedThreadPool使用了这个队列
-
ThreadFactory:用于设置创建线程的工厂,可以通过线程工厂给每个创建出来的线程设置更有意义的名字.使用开源框架guava提供ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字,代码如下
new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();
-
RejectedExecutionHandler（拒绝策略） 当队列和线程池都满,说明线程池饱和,必须采取一种策略处理提交的新任务 策略默认
AbortPolicy,表无法处理新任务时抛出异常 在JDK 1.5中Java线程池框架提供了以下4种策略- AbortPolicy：丢弃任务，抛出 RejectedExecutionException
- CallerRunsPolicy:只用调用者所在线程来运行任务,有反馈机制，使任务提交的速度变慢）。
- DiscardOldestPolicy 若没有发生shutdown,尝试丢弃队列里最近的一个任务,并执行当前任务, 丢弃任务缓存队列中最老的任务，并且尝试重新提交新的任务
- DiscardPolicy:不处理,丢弃掉, 拒绝执行，不抛异常 当然,也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略.如记录日志或持久化存储不能处理的任务
/** * Invokes the rejected execution handler for the given command. * Package-protected for use by ScheduledThreadPoolExecutor. */ final void reject(Runnable command) { // 执行拒绝策略 handler.rejectedExecution(command, this); }
handler 构造线程池时候就传的参数，RejectedExecutionHandler的实例 RejectedExecutionHandler 在 ThreadPoolExecutor 中有四个实现类可供我们直接使用，当然，也可以实现自己的策略，一般也没必要。
//只要线程池没有被关闭，由提交任务的线程自己来执行这个任务
public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() { }
/**
* Executes task r in the caller's thread, unless the executor
* has been shut down, in which case the task is discarded.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}
// 不管怎样，直接抛出 RejectedExecutionException 异常
// 默认的策略，如果我们构造线程池的时候不传相应的 handler ，则指定使用这个
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
/**
* Always throws RejectedExecutionException.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
* @throws RejectedExecutionException always
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
// 不做任何处理，直接忽略掉这个任务
public static class DiscardPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code DiscardPolicy}.
*/
public DiscardPolicy() { }
/**
* Does nothing, which has the effect of discarding task r.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
// 若线程池未被关闭
// 把队列队头的任务(也就是等待了最长时间的)直接扔掉，然后提交这个任务到等待队列中
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() { }
/**
* Obtains and ignores the next task that the executor
* would otherwise execute, if one is immediately available,
* and then retries execution of task r, unless the executor
* is shut down, in which case task r is instead discarded.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
-
keepAliveTime（线程活动保持时间） 线程没有任务执行时最多保持多久时间终止 线程池的工作线程空闲后，保持存活的时间。 所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率
-
TimeUnit（线程活动保持时间的单位）:指示第三个参数的时间单位；可选的单位有天（DAYS）、小时（HOURS）、分钟（MINUTES）、毫秒（MILLISECONDS）、微秒（MICROSECONDS，千分之一毫秒）和纳秒（NANOSECONDS，千分之一微秒）
从代码第2处来看，队列、线程工厂、拒绝处理服务都必须有实例对象; 但在实际编程中,很少有程序员对这三者进行实例化,而通过Executors这个线程池静态工厂提供默认实现; 那么Exceutors与ThreadPoolExecutor是什么关系呢?
Executors工厂类
ExecutorService 的抽象类AbstractExecutorService提供了submit、invokeAll 等方法的实现; 但是核心方法Executor.execute()并没有在这里实现. 因为所有的任务都在该方法执行,不同实现会带来不同的执行策略.
通过Executors的静态工厂方法可以创建三个线程池的包装对象
- ForkJoinPool、
- ThreadPoolExecutor
- ScheduledThreadPoolExecutor
● Executors.newWorkStealingPool JDK8 引入,创建持有足够线程的线程池支持给定的并行度; 并通过使用多个队列减少竞争; 构造方法中把CPU数量设置为默认的并行度. 返回ForkJoinPool ( JDK7引入)对象,它也是AbstractExecutorService 的子类
● Executors.newCachedThreadPool maximumPoolSize 最大可以至Integer.MAX_VALUE,是高度可伸缩的线程池. 若达到该上限,相信没有服务器能够继续工作,直接OOM. keepAliveTime 默认为60秒; 工作线程处于空闲状态,则回收工作线程; 如果任务数增加,再次创建出新线程处理任务.
● Executors.newScheduledThreadPool 线程数最大至Integer.MAX_ VALUE,与上述相同,存在OOM风险. ScheduledExecutorService接口的实现类,支持定时及周期性任务执行; 相比Timer,ScheduledExecutorService 更安全,功能更强大. 与newCachedThreadPool的区别是不回收工作线程.
● Executors.newSingleThreadExecutor 创建一个单线程的线程池,相当于单线程串行执行所有任务,保证按任务的提交顺序依次执行.
● Executors.newFixedThreadPool 输入的参数即是固定线程数; 既是核心线程数也是最大线程数; 不存在空闲线程,所以keepAliveTime等于0.
其中使用了 LinkedBlockingQueue, 但是没有设置上限!!!,堆积过多任务!!!
下面介绍LinkedBlockingQueue的构造方法
使用这样的无界队列,如果瞬间请求非常大,会有OOM的风险; 除newWorkStealingPool 外,其他四个创建方式都存在资源耗尽的风险.
不推荐使用其中的任何创建线程池的方法,因为都没有任何限制,存在安全隐患.
Executors中默认的线程工厂和拒绝策略过于简单,通常对用户不够友好. 线程工厂需要做创建前的准备工作,对线程池创建的线程必须明确标识,就像药品的生产批号一样,为线程本身指定有意义的名称和相应的序列号. 拒绝策略应该考虑到业务场景,返回相应的提示或者友好地跳转. 以下为简单的ThreadFactory 示例
上述示例包括线程工厂和任务执行体的定义; 通过newThread方法快速、统一地创建线程任务,强调线程一定要有特定意义的名称,方便出错时回溯.
-
单线程池：newSingleThreadExecutor()方法创建，五个参数分别是ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue())。含义是池中保持一个线程，最多也只有一个线程，也就是说这个线程池是顺序执行任务的，多余的任务就在队列中排队。
-
固定线程池：newFixedThreadPool(nThreads)方法创建
池中保持nThreads个线程，最多也只有nThreads个线程，多余的任务也在队列中排队。
线程数固定且线程不超时
- 缓存线程池：newCachedThreadPool()创建，五个参数分别是ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue())。 含义是池中不保持固定数量的线程，随需创建，最多可以创建Integer.MAX_VALUE个线程（说一句，这个数量已经大大超过目前任何操作系统允许的线程数了），空闲的线程最多保持60秒，多余的任务在SynchronousQueue（所有阻塞、并发队列在后续文章中具体介绍）中等待。
为什么单线程池和固定线程池使用的任务阻塞队列是LinkedBlockingQueue()，而缓存线程池使用的是SynchronousQueue()呢？ 因为单线程池和固定线程池中，线程数量是有限的，因此提交的任务需要在LinkedBlockingQueue队列中等待空余的线程；而缓存线程池中，线程数量几乎无限（上限为Integer.MAX_VALUE），因此提交的任务只需要在SynchronousQueue队列中同步移交给空余线程即可。
- 单线程调度线程池：newSingleThreadScheduledExecutor()创建，五个参数分别是 (1, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue())。含义是池中保持1个线程，多余的任务在DelayedWorkQueue中等待。
- 固定调度线程池：newScheduledThreadPool(n)创建，五个参数分别是 (n, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue())。含义是池中保持n个线程，多余的任务在DelayedWorkQueue中等待。
有一项技术可以缓解执行时间较长任务造成的影响，即限定任务等待资源的时间，而不要无限的等待
先看第一个例子，测试单线程池、固定线程池和缓存线程池（注意增加和取消注释）：
public class ThreadPoolExam {
public static void main(String[] args) {
//first test for singleThreadPool
ExecutorService pool = Executors.newSingleThreadExecutor();
//second test for fixedThreadPool
// ExecutorService pool = Executors.newFixedThreadPool(2);
//third test for cachedThreadPool
// ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
pool.execute(new TaskInPool(i));
}
pool.shutdown();
}
}
class TaskInPool implements Runnable {
private final int id;
TaskInPool(int id) {
this.id = id;
}
@Override
public void run() {
try {
for (int i = 0; i < 5; i++) {
System.out.println("TaskInPool-["+id+"] is running phase-"+i);
TimeUnit.SECONDS.sleep(1);
}
System.out.println("TaskInPool-["+id+"] is over");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
复制代码
如图为排查底层公共缓存调用出错时的截图
绿色框采用自定义的线程工厂,明显比蓝色框默认的线程工厂创建的线程名称拥有更多的额外信息:如调用来源、线程的业务含义，有助于快速定位到死锁、StackOverflowError 等问题.
拒绝策略
下面再简单地实现一下RejectedExecutionHandler; 实现了接口的rejectedExecution方法,打印出当前线程池状态
在ThreadPoolExecutor中提供了四个公开的内部静态类
● AbortPolicy - 默认 丢弃任务并抛出RejectedExecutionException
● DiscardPolicy - 不推荐 丢弃任务,但不拋异常.
● DiscardOldestPolicy 抛弃队列中等待最久的任务,然后把当前任务加入队列中.
● CallerRunsPolicy 调用任务的run()方法绕过线程池直接执行.
根据之前实现的线程工厂和拒绝策略,线程池的相关代码实现如下
当任务被拒绝的时候，拒绝策略会打印出当前线程池的大小已经达到了maximumPoolSize=2,且队列已满,完成的任务数提示已经有1个(最后一行).
源码讲解
在ThreadPoolExecutor的属性定义中频繁地用位运算来表示线程池状态; 位运算是改变当前值的一种高效手段.
下面从属性定义开始
Integer 有32位; 最右边29位表工作线程数; 最左边3位表示线程池状态,可表示从0至7的8个不同数值 线程池的状态用高3位表示,其中包括了符号位. 五种状态的十进制值按从小到大依次排序为 RUNNING < SHUTDOWN < STOP < TIDYING <TERMINATED 这样设计的好处是可以通过比较值的大小来确定线程池的状态. 例如程序中经常会出现isRunning的判断:
-
000-1111111111111111111111111; 类似于子网掩码,用于与运算; 得到左边3位,还是右边29位
用左边3位,实现5种线程池状态; 在左3位之后加入中画线有助于理解;
-
111 - 0000000000000000000000000000(十进制: -536, 870, 912); 该状态表 线程池能接受新任务
-
000 - 0000000000000000000000000(十进制: 0); 此状态不再接受新任务,但可继续执行队列中的任务
-
001 - 00000000000000000000000000(十进制: 536,870， 912); 此状态全面拒绝,并中断正在处理的任务
-
010 - 00000000000000000000000000.(十进制值: 1, 073, 741, 824); 该状态表 所有任务已经被终止
-
101 - 000000000000000000000000000(十进制值: 1, 610,612, 736) 该状态表 已清理完现场
与运算,比如 001 - 000000000000000000000100011 表 67个工作线程; 掩码取反: 111 - 00000000000000000000000.,即得到左边3位001; 表示线程池当前处于STOP状态
同理掩码 000 - 11111111111111111111,得到右边29位,即工作线程数
把左3位与右29位或运算,合并成一个值
我们都知道Executor接口有且只有一个方法execute(); 通过参数传入待执行线程的对象. 下面分析ThreadPoolExecutor关于execute()方法的实现
线程池执行任务的方法如下
/**
* Executes the given task sometime in the future. The task
* may execute in a new thread or in an existing pooled thread.
*
* If the task cannot be submitted for execution, either because this
* executor has been shutdown or because its capacity has been reached,
* the task is handled by the current {@code RejectedExecutionHandler}.
*
* @param command the task to execute
* @throws RejectedExecutionException at discretion of
* {@code RejectedExecutionHandler}, if the task
* cannot be accepted for execution
* @throws NullPointerException if {@code command} is null
*/
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1\. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2\. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3\. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
// 返回包含线程数及线程池状态的Integer 类型数值
int c = ctl.get();
// 若工作线程数 < 核心线程数,则创建线程并执行当前任务
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
execute方法在不同的阶段有三次addWorker的尝试动作。
return;
// 若创建失败,为防止外部已经在线程池中加入新任务,在此重新获取一下
c = ctl.get();
}
// 若 工作线程数 >=核心线程数 或线程创建失败,则将当前任务放到工作队列中
// 只有线程池处于 RUNNING 态,才执行后半句 : 置入队列
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 只有线程池处于 RUNNING 态,才执行后半句 : 置入队列
if (! isRunning(recheck) && remove(command))
reject(command);
// 若之前的线程已被消费完,新建一个线程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
// 核心线程和队列都已满,尝试创建一个新线程
}
else if (!addWorker(command, false))
// 抛出RejectedExecutionException异常
// 若 addWorker 返回是 false,即创建失败,则唤醒拒绝策略.
reject(command);
}
发生拒绝的理由有两个 ( 1 )线程池状态为非RUNNING状态 (2)等待队列已满。
下面继续分析addWorker
addWorker 源码解析
根据当前线程池状态,检查是否可以添加新的任务线程,若可以则创建并启动任务; 若一切正常则返回true; 返回false的可能性如下
- 线程池没有处于
RUNNING态 - 线程工厂创建新的任务线程失败
参数
- firstTask 外部启动线程池时需要构造的第一个线程,它是线程的母体
- core 新增工作线程时的判断指标
-
true 需要判断当前
RUNNING态的线程是否少于corePoolsize -
false 需要判断当前
RUNNING态的线程是否少于maximumPoolsize
-
这段代码晦涩难懂,部分地方甚至违反代码规约,但其中蕴含丰富的编码知识点
-
第1处,配合循环语句出现的label,类似于goto 作用 label 定义时,必须把标签和冒号的组合语句紧紧相邻定义在循环体之前,否则会编译出错. 目的是 在实现多重循环时能够快速退出到任何一层; 出发点似乎非常贴心,但在大型软件项目中,滥用标签行跳转的后果将是灾难性的. 示例代码中在
retry下方有两个无限循环; 在workerCount加1成功后,直接退出两层循环. -
第2处,这样的表达式不利于阅读,应如是
-
第3处,与第1处的标签呼应,
AtomicInteger对象的加1操作是原子性的;break retry表 直接跳出与retry相邻的这个循环体 -
第4处,此
continue跳转至标签处,继续执行循环. 如果条件为false,则说明线程池还处于运行状态,即继续在for(;)循环内执行. -
第5处,
compareAndIncrementWorkerCount方法执行失败的概率非常低. 即使失败,再次执行时成功的概率也是极高的,类似于自旋原理. 这里是先加1,创建失败再减1,这是轻量处理并发创建线程的方式; 如果先创建线程,成功再加1,当发现超出限制后再销毁线程,那么这样的处理方式明显比前者代价要大. -
第6处,
Worker对象是工作线程的核心类实现，部分源码如下它实现了
Runnable接口,并把本对象作为参数输入给run()中的runWorker (this); 所以内部属性线程thread在start的时候,即会调用runWorker.
总结
线程池的相关源码比较精炼，还包括线程池的销毁、任务提取和消费等，与线程状态图一样，线程池也有自己独立的状态转化流程，本节不再展开。 总结一下，使用线程池要注意如下几点: (1)合理设置各类参数，应根据实际业务场景来设置合理的工作线程数。 (2)线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 (3)创建线程或线程池时请指定有意义的线程名称，方便出错时回溯。
线程池不允许使用Executors，而是通过ThreadPoolExecutor的方式创建，这样的处理方式能更加明确线程池的运行规则，规避资源耗尽的风险。
进一步查看源码发现,这些方法最终都调用了ThreadPoolExecutor和ScheduledThreadPoolExecutor的构造函数 而ScheduledThreadPoolExecutor继承自ThreadPoolExecutor
作者：注销用户
链接：juejin.cn/post/684490…
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
