SpringBoot异步调用方法实现场景代码实例
一、背景
项目中肯定会遇到异步调用其他方法的场景，比如有个计算过程，需要计算很多个指标的值，但是每个指标计算的效率快慢不同，如果采用同步执行的方式，运行这一个过程的时间是计算所有指标的时间之和。比如：
方法A：计算指标x，指标y，指标z的值，其中计算指标x需要1s，计算指标y需要2s，指标z需要3s。最终执行完方法A就是5s。
现在用异步的方式优化一下
方法A异步调用方法B，方法C，方法D，方法B，方法C，方法D分别计算指标x，指标y，指标z的值，那么最终执行完方法A的时间则是3s。
还有一种用途是当一个业务里面需要多个请求时，这时候异步并发请求所得到的回报远远是物有所值的。因为他是异步执行的，话不多说，一下是在springBoot里面使用并发请求；
二、springboot中异步并发使用
2.1、appllication.yml
#****************集成Async线程池开始******************* async:#Async线程池配置 executor: corepoolsize:20 maxpoolsize:25 queuecapacity:40 keepaliveseconds:200 threadnameprefix:appasync awaitterminationseconds:60 #*****************集成Async线程池结束******************
2.2、配置线程池
@Configuration
@EnableAsync
publicclassExecutorConfig{
@Value("${async.executor.corepoolsize}")
privateIntegercorePoolSize;
@Value("${async.executor.maxpoolsize}")
privateIntegermaxPoolSize;
@Value("${async.executor.queuecapacity}")
privateIntegerqueueCapacity;
@Value("${async.executor.keepaliveseconds}")
privateIntegerkeepAliveSeconds;
@Value("${async.executor.threadnameprefix}")
privateStringthreadNamePrefix;
@Value("${async.executor.awaitterminationseconds}")
privateIntegerawaitTerminationSeconds;
/**
*线程池
*
*@return
*/
@Bean(name="asyncExecutor")
publicExecutorasyncExecutor(){
ThreadPoolTaskExecutorexecutor=newThreadPoolTaskExecutor();
//基础线程数corePoolSize:10
executor.setCorePoolSize(corePoolSize);
//最大线程数maxPoolSize:15
executor.setMaxPoolSize(maxPoolSize);
//队列长度queueCapacity:25
executor.setQueueCapacity(queueCapacity);
//线程池维护线程所允许的空闲时间,单位为秒keepAliveSeconds:200
executor.setKeepAliveSeconds(keepAliveSeconds);
//线程名字threadNamePrefix:appasync
executor.setThreadNamePrefix(threadNamePrefix);
executor.setRejectedExecutionHandler(newThreadPoolExecutor.CallerRunsPolicy());
//等待所有任务都完成再继续销毁其他的Bean
executor.setWaitForTasksToCompleteOnShutdown(true);
//线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住
executor.setAwaitTerminationSeconds(awaitTerminationSeconds);
executor.initialize();
returnexecutor;
}
}
2.3、线程池监控（这个可有可无，主要是为了对线程池参数及时的调优）
@RestController
@Slf4j
@RequestMapping("/pubapi/asyncExecutor")
publicclassAsyncExecutorControllerextendsBaseController{
@Resource(name="asyncExecutor")
privateExecutorasyncExecutor;
@PostMapping("/monitor")publicResultBean>getAsyncExecutorData(){
ResultBean>resultBean=ResultBeanUtil.error500();
if(asyncExecutor==null){
returnresultBean;
}
try{
ThreadPoolTaskExecutorexecutorTask=(ThreadPoolTaskExecutor)asyncExecutor;
ThreadPoolExecutorexecutor=executorTask.getThreadPoolExecutor();
//当前排队线程数
intqueueSize=executor.getQueue().size();
//当前活动线程数
intactiveCount=executor.getActiveCount();
//执行完线程数
longcompletedThreadCount=executor.getCompletedTaskCount();
//总线程数
longtaskCount=executor.getTaskCount();
//初始线程数
intpoolSize=executor.getPoolSize();
//核心线程数
intcorePoolSize=executor.getCorePoolSize();
//线程池是否终止
booleanisTerminated=executor.isTerminated();
//线城池是否关闭
booleanisShutdown=executor.isShutdown();
//线程空闲时间
longkeepAliveTime=executor.getKeepAliveTime(TimeUnit.MILLISECONDS);
//最大允许线程数
longmaximumPoolSize=executor.getMaximumPoolSize();
//线程池中存在的最大线程数
longlargestPoolSize=executor.getLargestPoolSize();
MapthreadPoolData=newHashMap<>(18);
threadPoolData.put("当前排队线程数",queueSize);
threadPoolData.put("当前活动线程数",activeCount);
threadPoolData.put("执行完线程数",completedThreadCount);
threadPoolData.put("总线程数",taskCount);
threadPoolData.put("初始线程数",poolSize);
threadPoolData.put("核心线程数",corePoolSize);
threadPoolData.put("线程池是否终止",isTerminated);
threadPoolData.put("线城池是否关闭",isShutdown);
threadPoolData.put("线程空闲时间",keepAliveTime);
threadPoolData.put("最大允许线程数",maximumPoolSize);
threadPoolData.put("线程池中存在的最大线程数",largestPoolSize);
InetAddressinetAddress=IdWorker.getLocalHostLANAddress();
MapresultData=newHashMap<>(4);
resultData.put("ip",inetAddress.getHostAddress());
resultData.put("threadPoolData",threadPoolData);
resultBean=ResultBeanUtil.success("请求成功！",resultData);
}catch(Exceptione){
e.printStackTrace();
}
returnresultBean;
}
}
2.4、代码中使用
publicvoidgetMap(){
/**
*先将耗时的、相互之间无依赖的操作先执行，由于其执行结果暂时不是特别关注，所以
*/
FuturefutureA=functionA();
FuturefutureB=functionB();
/**
*执行其他的操作，其实functionA(),functionB()也在工作
*/
aaa();
/**
*获取异步的结果，然后计算
*/
try{
StringresultA=futureA.get();
StringresuleB=futureB.get();
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(ExecutionExceptione){
e.printStackTrace();
}
}
publicFuturefunctionA(){
Futurefuture=null;
try{
Thread.sleep(5000);
future=newAsyncResult("functionA");
}catch(InterruptedExceptione){
e.printStackTrace();
}
returnfuture;
}
publicFuturefunctionB(){
Futurefuture=null;
try{
Thread.sleep(3000);
future=newAsyncResult("functionB");
}catch(InterruptedExceptione){
e.printStackTrace();
}
returnfuture;
}
publicvoidaaa(){
System.out.println("我是");
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。