SpringBoot | 第二十一章:异步开发之异步调用

2018-09-17    来源:importnew

容器云强势上线!快速搭建集群,上万Linux镜像随意使用

前言

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

一点知识

何为异步调用

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

题外话:处理异步同步外,还有一个叫回调。其主要是解决异步方法执行结果的处理方法,比如在希望异步调用结束时返回执行结果,这个时候就可以考虑使用回调机制。

Async异步调用

SpringBoot中使用异步调用是很简单的,只需要使用@Async注解即可实现方法的异步调用。

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

@SpringBootApplication
@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

@RestController
@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!

可以看出,调用异步方法时,是立即返回的,基本没有耗时。

这里有几点需要注意下:

  1. 在默认情况下,未设置TaskExecutor时,默认是使用SimpleAsyncTaskExecutor这个线程池,但此线程不是真正意义上的线程池,因为线程不重用,每次调用都会创建一个新的线程。可通过控制台日志输出可以看出,每次输出线程名都是递增的。
  2. 调用的异步方法,不能为同一个类的方法,简单来说,因为Spring在启动扫描时会为其创建一个代理类,而同类调用时,还是调用本身的代理类的,所以和平常调用是一样的。其他的注解如@Cache等也是一样的道理,说白了,就是Spring的代理机制造成的。

自定义线程池

前面有提到,在默认情况下,系统使用的是默认的SimpleAsyncTaskExecutor进行线程创建。所以一般上我们会自定义线程池来进行线程的复用。

创建一个自定义的ThreadPoolTaskExecutor线程池:
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参数说明:

  1. corePoolSize:线程池维护线程的最少数量
  2. keepAliveSeconds:允许的空闲时间,当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
  3. maxPoolSize:线程池维护线程的最大数量,只有在缓冲队列满了之后才会申请超过核心线程数的线程
  4. queueCapacity:缓存队列
  5. 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<>("异步方法返回值");
}

其中AsyncResultSpring提供的一个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类,此时可进行统一异常捕获即可。

超时异常

参考资料

  1. https://docs.spring.io/spring/docs/4.3.18.RELEASE/spring-framework-reference/htmlsingle/#scheduling-annotation-support
  2. https://www.cnblogs.com/cz123/p/7693064.html

总结

本章节主要是讲解了异步请求的使用及相关配置,如超时,异常等处理。在剥离一些和业务无关的操作时,就可以考虑使用异步调用进行其他无关业务操作,以此提供业务的处理效率。或者一些业务场景下可拆分出多个方法进行同步执行又互不影响时,也可以考虑使用异步调用方式提供执行效率。既然已经讲解了异步相关知识,下一章节就来介绍下定时任务的使用。

最后

目前互联网上很多大佬都有SpringBoot系列教程,如有雷同,请多多包涵了。本文是作者在电脑前一字一句敲的,每一步都是自己实践的。若文中有所错误之处,还望提出,谢谢。

标签: 代码 互联网

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点!
本站所提供的图片等素材,版权归原作者所有,如需使用,请与原作者联系。

上一篇:SpringBoot | 番外:使用小技巧合集

下一篇:SpringBoot | 第二十章:异步开发之异步请求