SpringBoot：异步开发之异步调用

前言

除了异步请求，通常上咱们用的比较多的应该是异步调用。一般在开发过程当中，会遇到一个方法是和实际业务无关的，没有紧密性的。好比记录日志信息等业务。这个时候正常就是启一个新线程去作一些业务处理，让主线程异步的执行其余业务。因此，本章节重点说下在SpringBoot中如何进行异步调用及其相关知识和注意点。

何为异步调用

说异步调用前，咱们说说它对应的同步调用。一般开发过程当中，通常上咱们都是同步调用，即：程序按定义的顺序依次执行的过程，每一行代码执行过程必须等待上一行代码执行完毕后才执行。而异步调用指：程序在执行时，无需等待执行的返回值可继续执行后面的代码。显而易见，同步有依赖相关性，而异步没有，因此异步可并发执行，可提升执行效率，在相同的时间作更多的事情。

题外话：处理异步、同步外，还有一个叫回调。其主要是解决异步方法执行结果的处理方法，好比在但愿异步调用结束时返回执行结果，这个时候就能够考虑使用回调机制。

Async异步调用

在SpringBoot中使用异步调用是很简单的，只须要使用@Async注解便可实现方法的异步调用。

注意：须要在启动类加入@EnableAsync使异步调用@Async注解生效。

@SpringBootApplicationbr/>@EnableAsync
@Slf4j
public class Chapter21Application {

public static void main(String[] args) { SpringApplication.run(Chapter21Application.class, args); log.info("Chapter21启动!"); }

}

@Async异步调用

使用@Async很简单，只须要在须要异步执行的方法上加入此注解便可。这里建立一个控制层和一个服务层，进行简单示例下。

SyncService.java

@Component
public class SyncService {

@Async public void asyncEvent() throws InterruptedException { //休眠1s Thread.sleep(1000); //log.info("异步方法输出：{}!", System.currentTimeMillis()); } public void syncEvent() throws InterruptedException { Thread.sleep(1000); //log.info("同步方法输出：{}!", System.currentTimeMillis()); }

}
控制层：AsyncController.java

@RestControllerbr/>@Slf4j
public class AsyncController {

@Autowired
SyncService syncService;

@GetMapping("/async") public String doAsync() throws InterruptedException { long start = System.currentTimeMillis(); log.info("方法执行开始：{}", start); //调用同步方法 syncService.syncEvent(); long syncTime = System.currentTimeMillis(); log.info("同步方法用时：{}", syncTime - start); //调用异步方法 syncService.asyncEvent(); long asyncTime = System.currentTimeMillis(); log.info("异步方法用时：{}", asyncTime - syncTime); log.info("方法执行完成：{}!",asyncTime); return "async!!!"; }

}
应用启动后，能够看见控制台输出:
2018-08-16 22:21:35.949 INFO 17152 --- [nio-8080-exec-5] c.l.l.s.c.controller.AsyncController : 方法执行开始：1534429295949
2018-08-16 22:21:36.950 INFO 17152 --- [nio-8080-exec-5] c.l.l.s.c.controller.AsyncController : 同步方法用时：1001
2018-08-16 22:21:36.950 INFO 17152 --- [nio-8080-exec-5] c.l.l.s.c.controller.AsyncController : 异步方法用时：0
2018-08-16 22:21:36.950 INFO 17152 --- [nio-8080-exec-5] c.l.l.s.c.controller.AsyncController : 方法执行完成：1534429296950!
2018-08-16 22:21:37.950 INFO 17152 --- [cTaskExecutor-3] c.l.l.s.chapter21.service.SyncService : 异步方法内部线程名称：SimpleAsyncTaskExecutor-3!
能够看出，调用异步方法时，是当即返回的，基本没有耗时。

这里有几点须要注意下：

在默认状况下，未设置TaskExecutor时，默认是使用SimpleAsyncTaskExecutor这个线程池，但此线程不是真正意义上的线程池，由于线程不重用，每次调用都会建立一个新的线程。可经过控制台日志输出能够看出，每次输出线程名都是递增的。
调用的异步方法，不能为同一个类的方法，简单来讲，由于Spring在启动扫描时会为其建立一个代理类，而同类调用时，仍是调用自己的代理类的，因此和日常调用是同样的。其余的注解如@Cache等也是同样的道理，说白了，就是Spring的代理机制形成的。

自定义线程池

前面有提到，在默认状况下，系统使用的是默认的SimpleAsyncTaskExecutor进行线程建立。因此通常上咱们会自定义线程池来进行线程的复用。

建立一个自定义的ThreadPoolTaskExecutor线程池：br/>Config.java
@Configuration
public class Config {

/** * 配置线程池 * @return */ @Bean(name = "asyncPoolTaskExecutor") public ThreadPoolTaskExecutor getAsyncThreadPoolTaskExecutor() { ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor(); taskExecutor.setCorePoolSize(20); taskExecutor.setMaxPoolSize(200); taskExecutor.setQueueCapacity(25); taskExecutor.setKeepAliveSeconds(200); taskExecutor.setThreadNamePrefix("oKong-"); // 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者 taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); taskExecutor.initialize(); return taskExecutor; }

}
此时，使用的是就只须要在@Async加入线程池名称便可：

@Async("asyncPoolTaskExecutor")
public void asyncEvent() throws InterruptedException {
//休眠1s
Thread.sleep(1000);
log.info("异步方法内部线程名称：{}!", Thread.currentThread().getName());
}
再次启动应用，就能够看见已是使用自定义的线程了。
2018-08-16 22:32:02.676 INFO 4516 --- [nio-8080-exec-1] c.l.l.s.c.controller.AsyncController : 方法执行开始：1534429922676
2018-08-16 22:32:03.681 INFO 4516 --- [nio-8080-exec-1] c.l.l.s.c.controller.AsyncController : 同步方法用时：1005
2018-08-16 22:32:03.693 INFO 4516 --- [nio-8080-exec-1] c.l.l.s.c.controller.AsyncController : 异步方法用时：12
2018-08-16 22:32:03.693 INFO 4516 --- [nio-8080-exec-1] c.l.l.s.c.controller.AsyncController : 方法执行完成：1534429923693!
2018-08-16 22:32:04.694 INFO 4516 --- [ oKong-1] c.l.l.s.chapter21.service.SyncService : 异步方法内部线程名称：oKong-1!
这里简单说明下，关于ThreadPoolTaskExecutor参数说明：

corePoolSize：线程池维护线程的最少数量
keepAliveSeconds：容许的空闲时间,当超过了核心线程出以外的线程在空闲时间到达以后会被销毁
maxPoolSize：线程池维护线程的最大数量,只有在缓冲队列满了以后才会申请超过核心线程数的线程
queueCapacity：缓存队列
rejectedExecutionHandler：线程池对拒绝任务（无线程可用）的处理策略。这里采用了CallerRunsPolicy策略，当线程池没有处理能力的时候，该策略会直接在 execute 方法的调用线程中运行被拒绝的任务；若是执行程序已关闭，则会丢弃该任务。还有一个是AbortPolicy策略：处理程序遭到拒绝将抛出运行时RejectedExecutionException。
而在一些场景下，若须要在关闭线程池时等待当前调度任务完成后才开始关闭，能够经过简单的配置，进行优雅的停机策略配置。关键就是经过setWaitForTasksToCompleteOnShutdown(true)和setAwaitTerminationSeconds方法。

setWaitForTasksToCompleteOnShutdown:代表等待全部线程执行完，默认为false。
setAwaitTerminationSeconds:等待的时间，由于不能无限的等待下去。
因此，线程池完整配置为：
@Bean(name = "asyncPoolTaskExecutor")
public ThreadPoolTaskExecutor getAsyncThreadPoolTaskExecutor() {
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
taskExecutor.setCorePoolSize(20);
taskExecutor.setMaxPoolSize(200);
taskExecutor.setQueueCapacity(25);
taskExecutor.setKeepAliveSeconds(200);
taskExecutor.setThreadNamePrefix("oKong-");
// 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者
taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
//调度器shutdown被调用时等待当前被调度的任务完成
taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
//等待时长
taskExecutor.setAwaitTerminationSeconds(60);
taskExecutor.initialize();
return taskExecutor;
}

异步回调及超时处理

对于一些业务场景下，须要异步回调的返回值时，就须要使用异步回调来完成了。主要就是经过Future进行异步回调。

异步回调
修改下异步方法的返回类型，加入Future。

@Async("asyncPoolTaskExecutor")
public Future<String> asyncEvent() throws InterruptedException {
//休眠1s
Thread.sleep(1000);
log.info("异步方法内部线程名称：{}!", Thread.currentThread().getName());
return new AsyncResult<>("异步方法返回值");
}
其中AsyncResult是Spring提供的一个Future接口的子类。

而后经过isDone方法，判断是否已经执行完毕。

@GetMapping("/async")
public String doAsync() throws InterruptedException {
long start = System.currentTimeMillis();
log.info("方法执行开始：{}", start);
//调用同步方法
syncService.syncEvent();
long syncTime = System.currentTimeMillis();
log.info("同步方法用时：{}", syncTime - start);
//调用异步方法
Future<String> doFutrue = syncService.asyncEvent();
while(true) {
//判断异步任务是否完成
if(doFutrue.isDone()) {
break;
}
Thread.sleep(100);
}
long asyncTime = System.currentTimeMillis();
log.info("异步方法用时：{}", asyncTime - syncTime);
log.info("方法执行完成：{}!",asyncTime);
return "async!!!";
}
此时，控制台输出：
2018-08-16 23:10:57.021 INFO 9072 --- [nio-8080-exec-1] c.l.l.s.c.controller.AsyncController : 方法执行开始：1534431237020
2018-08-16 23:10:58.025 INFO 9072 --- [nio-8080-exec-1] c.l.l.s.c.controller.AsyncController : 同步方法用时：1005
2018-08-16 23:10:59.037 INFO 9072 --- [ oKong-1] c.l.l.s.chapter21.service.SyncService : 异步方法内部线程名称：oKong-1!
2018-08-16 23:10:59.040 INFO 9072 --- [nio-8080-exec-1] c.l.l.s.c.controller.AsyncController : 异步方法用时：1015
2018-08-16 23:10:59.040 INFO 9072 --- [nio-8080-exec-1] c.l.l.s.c.controller.AsyncController : 方法执行完成：1534431239040!
因此，当某个业务功能能够同时拆开一块儿执行时，可利用异步回调机制，可有效的减小程序执行时间，提升效率。

超时处理
对于一些须要异步回调的函数，不能无期限的等待下去，因此通常上须要设置超时时间，超时后可将线程释放，而不至于一直堵塞而占用资源。

对于Future配置超时，很简单，经过get方法便可，具体以下：
//get方法会一直堵塞，直到等待执行完成才返回
//get(long timeout, TimeUnit unit) 在设置时间类未返回结果，会直接排除异常TimeoutException，messages为null
String result = doFutrue.get(60, TimeUnit.SECONDS);//60s
超时后，会抛出异常TimeoutException类，此时可进行统一异常捕获便可。
http://qiniu.xds123.cn/18-8-16/35438012.jpg

总结

本章节主要是讲解了异步请求的使用及相关配置，如超时，异常等处理。在剥离一些和业务无关的操做时，就能够考虑使用异步调用进行其余无关业务操做，以此提供业务的处理效率。或者一些业务场景下可拆分出多个方法进行同步执行又互不影响时，也能够考虑使用异步调用方式提供执行效率。
最后
目前互联网上不少大佬都有SpringBoot系列教程，若有雷同，请多多包涵了。若文中有所错误之处，还望提出，谢谢。
欢迎工做一到五年的Java工程师朋友们加入Java架构开发：798891710

本群提供免费的学习指导 架构资料 以及免费的解答

不懂得问题均可以在本群提出来 以后还会有职业生涯规划以及面试指导
同时你们能够多多关注一下小编公众号：Java架构师秘籍 纯干货 你们一块儿学习进步

最后传播一个好消息，云计算已白菜价，云服务器低至不到300元/年。这里有一份云计算优惠活动列表，来不及解释了，赶忙上车！

---

转自http://blog.51cto.com/13932491/2176269