线程池是一个资源调度池,我们可以将需要做的任务直接丢到线程池中,关于线程池的简介可以看前文的这篇文章:
java 多线程开发系列之九:玩转线程池(线程池的简介和简单使用) https://www.cnblogs.com/jilodream/p/23471356
考虑到硬件资源以及任务的时限性,线程池中的任务并不能无限加,(防盗连接:本文首发自http://www.cnblogs.com/jilodream/ )而且即使资源无限,也并不代表可以承载的待执行任务越多越好,至于原因,我下文中会提到。
我们可以通过线程数和任务队列来控制可执行的最大任务数量=正在执行+待执行。
当任务数已经超过线程池的最大任务数时,线程池会依据一段预定的执行逻辑来处理这个超限任务。而这一段预定的执行逻辑通过接口实现类嵌入到线程池中。
这段包含执行实现的接口实例,我们称之为拒绝策略。
java为拒绝策略声明了一个接口,并提供了4个常用的策略实现。
接口如下:
1 public interface RejectedExecutionHandler {
2
3 void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
4 }
拒绝任务执行的逻辑有两个参数,
1,runnable,待执行的任务
2,ThreadPoolExecutor ,当前线程池
有人看到这个源码会疑惑,线程池除了可以提交runnable任务,不也可以提交callable任务嘛。
对于callable任务,这里不就没法传了么?
其实翻看submit源码我就可以看到,在提交callable任务时,callable 的任务被进一步包装为RunnableFuture提交的,而RunnableFuture又是继承了
Runnable接口的。所以参数1也是可以持有到callable任务的。(线程池内部的执行逻辑后边有精力慢慢总结,内部其实非常复杂。)
在使用多线程中,我们常常会根据不同的场景需要,配置不同的拒绝策略实例。
依次来看下这四个拒绝策略实例:
(1)AbortPolicy 中止策略
Abort
美 əˈbɔː (r)t,英 əˈbɔː (r)t,
v. 中止;流产;放弃;堕胎;
这个策略的作用是终止当前提交的任务,直接丢弃掉,并抛出一个运行时异常告知任务提交者。
它是线程池的默认处理策略。
来看源码:
1 public static class AbortPolicy implements RejectedExecutionHandler {
2
3 public AbortPolicy() { }
4
5 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
6 throw new RejectedExecutionException("Task " + r.toString() +
7 " rejected from " +
8 e.toString());
9 }
10 }
(2)DiscardPolicy 丢弃策略
这个策略就是丢弃当前任务,什么都不做,实现也是一段空逻辑。
1 public static class DiscardPolicy implements RejectedExecutionHandler {
2
3 public DiscardPolicy() { }
4
5 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
6 }
7 }
(3)DiscardOldestPolicy 丢弃最老策略
将任务队列待执行的任务中,最早的一个丢弃掉。重新尝试执行该任务。(防盗连接:本文首发自http://www.cnblogs.com/jilodream/ )注意丢弃老任务后,仍然需要重新提交可能仍会被其它任务抢先提交成功。
1 public static class DiscardOldestPolicy implements RejectedExecutionHandler {
2
3 public DiscardOldestPolicy() { }
4
5
6 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
7 if (!e.isShutdown()) {
8 e.getQueue().poll();
9 e.execute(r);
10 }
11 }
12 }
(4)CallerRunsPolicy 调用者运行策略
这个策略是由提交该任务的线程自己执行这个任务。
注意由于拒绝执行的方法rejectedExecution()是由任务提交者执行的,因此这里直接使用run方法,而非start()方法。
1 public static class CallerRunsPolicy implements RejectedExecutionHandler {
2
3 public CallerRunsPolicy() { }
4
5 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
6 if (!e.isShutdown()) {
7 r.run();
8 }
9 }
10 }
注意这四种线程池内置的拒绝策略,没有孰好孰坏。他们有各自的使用场景。
AbortPolicy 中止策略
适用于提交者需要明确感知任务提交是否成功的场景。
比如用户提交了创建任务,需要明确知道任务创建的任务到底有没有提交成功。
或者金融转账提交
亦或者用户下单购买商品,先不说是否超卖或者被审计驳回,首先创建任务的申请到底提交成功了没有,用户需要感知。
DiscardPolicy 丢弃策略
这个策略通常用来处理,(防盗连接:本文首发自http://www.cnblogs.com/jilodream/ )线程丢就丢了无所谓的旁路任务提交。比如有兜底任务保证的同步子任务。没执行也没关系,有同步兜底检查。
DiscardOldestPolicy 丢弃最老策略
这个策略通常用来更新实时数据,比如采集数据什么的。相当于通过旧数据淘汰机制,对新数据起到一定的保护作用。
比如实时的温度传感数据,通常大家更关心最新的数据,新数据的优先级远大于旧数据。
CallerRunsPolicy 调用者运行策略
这个策略通常用来处理任务不能随意丢弃的场景。并且由于调用者自身执行了任务。从而对线程池天然起到了限流作用(注意这是一把双刃剑)。
消费者消费消息时,通常会用到这个策略。但是这个策略也有天然劣势,由于提交线程本身不再受到线程池的停止动作的约束。
而且也会导致职责不明,本来是上游的任务提交者,结果又变为了下游任务处理者。
当任务处理非常缓慢阻塞时,导致上游的消费出现问题。当大规模任务阻塞时,异步变同步,导致整个调用链路全部阻塞。
线程池从原来的资源池变为了临时的"蓄水池",异步的优势荡然无存。
同时这种策略实际执行时,如果有用到ThreaLocal,还可能导致提交线程的ThreadLocal被污染。
以上是java线程池提供的四种策略,在实际生产中,通常会借鉴上述思路,实现自定义策略。
(1)对于核心业务的主路分支,我们不能随意丢弃,也不希望影响到任务提交者。
当触发拒绝策略时,先入MQ,异步消费MQ后再次提交,多次提交仍然未果,进入死信队列或者入库,等工作人员手动触发或审核。
(2)对于非核心业务即使丢弃,也要进行日志记录,入库或者入kafka等,保证可追溯。
最后来看一个自定义策略的例子:
1 public class MyRejectPolicyStudy implements RejectedExecutionHandler {
2 @Override
3 public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
4 System.out.println("exec Reject policy's thread is " + Thread.currentThread().getName());
5 Thread t = new Thread(r);
6 t.setName("临时线程");
7 t.start();
8 }
9
10 public static void main(String[] args) throws ExecutionException, InterruptedException {
11 ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS,
12 new SynchronousQueue<>());
13 executor.setRejectedExecutionHandler(new MyRejectPolicyStudy());
14 Callable<Integer> task1 = () -> {
15 TimeUnit.SECONDS.sleep(2);
16 System.out.println("exec task1 thread is " + Thread.currentThread().getName());
17 return 1;
18 };
19
20 Callable<Integer> task2 = () -> {
21 TimeUnit.SECONDS.sleep(2);
22 System.out.println("exec task2 thread is " + Thread.currentThread().getName());
23 return 2;
24 };
25 Future<Integer> submit1 = executor.submit(task1);
26 Future<Integer> submit2 = executor.submit(task2);
27
28 Integer rtn1 = submit1.get();
29 System.out.println("task 1 ,result=" + rtn1);
30 Integer rtn2 = submit2.get();
31 System.out.println("task 2 ,result=" + rtn2);
32 }
33 }
结果如下:
exec Reject policy's thread is main
exec task1 thread is pool-1-thread-1
exec task2 thread is 临时线程
task 1 ,result=1
task 2 ,result=2
我们可以得出以下结论:
1、拒绝策略的rejectedExecution()是由提交者执行的,在这里是main线程,前文也有提到,查看源码也可以进一步确认。
2、只要任务submit后,我们通过返回的future对象获取到任务句柄(handler),后边无论是哪个线程(线程池线程还是其它线程)真正执行了该任务,
我们都可以从future中拿到任务结果(或取消任务)。
再回到文章开头说到任务不是容纳的任务越多越好这个问题,(防盗连接:本文首发自http://www.cnblogs.com/jilodream/ )有时我们希望提交的任务可以尽快的执行或者被响应,如果线程池容纳的任务非常多,就会导致待执行的任务越来越多,新提交的线程就总是不会被快速的响应到。
要明白拒绝策略是一种反馈,我们不应该将其认为是系统能力不行的一种消极处理机制,更不应该认为拒绝策略总是不好的。