目录
前言
近阶段工作中遇到需要自定义拒绝策略的情况,网上查阅资料,大多文章都写的比较简单,所以花点时间自己研究下。
线程池拒绝策略的触发条件
一般情况下,我们都会手动创建一个有界线程池
@Bean("myThread")
public ThreadPoolTaskExecutor myThread(){
ThreadPoolTaskExecutor executor=new ThreadPoolTaskExecutor();
//核心线程数
executor.setCorePoolSize(2);
//队列容量
executor.setQueueCapacity(2);
//最大线程数
executor.setMaxPoolSize(2);
//拒绝策略
executor.setRejectedExecutionHandler(ThreadPoolExecutor.AbortPolicy);
return executor;
}
创建任务执行时首先判断是否大于核心线程数,超过核心线程数后,新进入的任务开始进入队列中,再大于队列数后会继续创建线程执行任务,直到大于最大线程数后就会开始执行拒绝策略。
上面代码里使用了自带的拒绝策略,总共有4种,可以看下源码比较好理解:
AbortPolicy拒绝并抛出异常
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task"+r.toString+" rejected from "+e.toString);
}
}
DiscardPolicy丢弃任务并不做任何操作
public static class DiscardPolicy implements RejectedExecutionHandler {
/**
* Creates a <tt>DiscardPolicy</tt>.
*/
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) {
}
}
DiscardOldestPolicy丢弃最老的任务
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
//线程池队列是一个LinkedBlockingQueue先进先出,poll()方法从队头出队元素
e.getQueue().poll();
e.execute(r);
}
}
}
CallerRunsPolicy调用主线程处理
public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
//直接调用run方法相当于非异步执行
r.run();
}
}
}
通过查看源码可以看到,实现拒绝策略需要实现RejectedExecutionHandler接口,然后实现rejectedExecution方法即可。该方法两个参数,第一个就是被拒绝的Runnable任务,第二个是你使用的线程池对象。
然后模拟下业务处理
@Slf4j
@Service
public class HandleService{
@Async("myThread")
public void handle(BusinessObject object){
try{
log.info("Thread[{}],start handle...");
Thread.currentThread().sleep(20000);
log.info("Thread[{}],finish handle");
}catch(Exception e){
}
}
}
开启异步处理
@EnableAsync
@SpringBootApplication
public class Main{
@Resource
HandleService handleService;
public static void main(String[] args){
SrpingApplication.run(Main.class,args);
}
@PostConstruct
public void startAsync(){
BusinessObject object=new Business();
object.setBusinessKey("123456");
object.setBusinessType("save");
for(int i=0;i<10;i++){
handleService.handle(object)
}
}
}
自定义拒绝策略
这里主要是反射拿到任务的参数。不用@Async的话自己实现Runnable接口的也可以用这种方法拿到,不过获取的属性有些差异。
@Slf4j
@Component
public class RejectHanlde implements RejectedExecutionHandler{
@Override
@SneakyThrows
public void rejectedExecution(Runnable r,ThreadPoolExecutor executor){
Field field=r.getClass().getDeclaredField("callable");
field.setAccessible(true);
Callable callable=(Callable)field.get(r);
Field invocationField=callable.getClass().getDeclaredField("arg$2");
invocationField.setAccessible(true);
MethodInvocation invocation=(MethodInvocation)invocationField.get(callable);
Object[] args=invocation.getArguments();
BusinessObject object=(BusinessObject)args[0];
log.info("拒绝策略拒绝任务:{}",new ObjectMapper().writeValueAsString(object));
//可以用LinkedBlokingQueue的put方法阻塞入队
//executor.getQueue().put(r);
}
}
线程池换成自己的拒绝策略
@Configuration
public class ThreadPoolConfigs{
@Resource
RejectHandler handler;
@Bean("myThread")
public ThreadPoolTaskExecutor myThread(){
ThreadPoolTaskExecutor executor=new ThreadPoolTaskExecutor();
//核心线程数
executor.setCorePoolSize(2);
//队列容量
executor.setQueueCapacity(2);
//最大线程数
executor.setMaxPoolSize(2);
//拒绝策略
executor.setRejectedExecutionHandler(handler);
return executor;
}
}