SpringBoot 异步调用方法并接收返回值

素颜马尾好姑娘i 2022-03-08 05:54 265阅读 0赞

项目中肯定会遇到异步调用其他方法的场景，比如有个计算过程，需要计算很多个指标的值，但是每个指标计算的效率快慢不同，如果采用同步执行的方式，运行这一个过程的时间是计算所有指标的时间之和。比如：

方法A：计算指标x，指标y，指标z的值，其中计算指标x需要1s，计算指标y需要2s，指标z需要3s。最终执行完方法A就是5s。

现在用异步的方式优化一下

方法A异步调用方法B，方法C，方法D，方法B，方法C，方法D分别计算指标x，指标y，指标z的值，那么最终执行完方法A的时间则是3s。

步骤一：配置线程池，添加@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;
        }
    }

结果：

![20190314143522410.png][]

![20190314143554907.png][]

关于Futura类的详解请移步：[https://blog.csdn.net/u014209205/article/details/80598209][https_blog.csdn.net_u014209205_article_details_80598209]

[20190314143522410.png]: /images/20220308/51c2a56c089f4eb1ac6aa3429c967ec8.png
[20190314143554907.png]: /images/20220308/2349ea293d924a2f964da7b2c28f561c.png
[https_blog.csdn.net_u014209205_article_details_80598209]: https://blog.csdn.net/u014209205/article/details/80598209