项目中肯定会遇到异步调用其他方法的场景，比如有个计算过程，需要计算很多个指标的值，但是每个指标计算的效率快慢不同，如果采用同步执行的方式，运行这一个过程的时间是计算所有指标的时间之和。比如：
方法A：计算指标x，指标y，指标z的值，其中计算指标x需要1s，计算指标y需要2s，指标z需要3s。最终执行完方法A就是5s。
现在用异步的方式优化一下
方法A异步调用方法B，方法C，方法D，方法B，方法C，方法D分别计算指标x，指标y，指标z的值，那么最终执行完方法A的时间则是3s。
步骤1：配置线程池，添加@Configuration和@EnableAsync注解
@Configuration
@EnableAsync
public class ExecutorConfig {
/**
* 线程池
*
* @return
*/
@Bean(name = "asyncExecutor")
public Executor asyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(15);
executor.setQueueCapacity(25);
executor.setKeepAliveSeconds(200);
executor.setThreadNamePrefix("async-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 等待所有任务都完成再继续销毁其他的Bean
executor.setWaitForTasksToCompleteOnShutdown(true);
// 线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住
executor.setAwaitTerminationSeconds(60);
executor.initialize();
return executor;
}
}
步骤2：定义方法A，方法B，方法C，方法D
@Service
public class AsyncService {
@Async("asyncExecutor")
public Future<Integer> methodB(){
try{
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
return new AsyncResult<>(1);
}
@Async("asyncExecutor")
public Future<Integer> methodC(){
try{
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
return new AsyncResult<>(2);
}
@Async("asyncExecutor")
public Future<Integer> methodD(){
try{
Thread.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
return new AsyncResult<>(3);
}
}
@GetMapping("test")
public Integer methodA() throws Exception{
long start = System.currentTimeMillis();
Future<Integer> future1 = asyncService.methodB();
Future<Integer> future2 = asyncService.methodC();
Future<Integer> future3 = asyncService.methodD();
Integer x = future1.get();
Integer y = future2.get();
Integer z = future3.get();
long end = System.currentTimeMillis();
System.out.println("耗时：" + (end - start));
return x + y +z;
}
}
结果：
关于Futura类的详解请移步：了解JAVA Future类
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。
