SpringBoot系列——@Async优雅的异步调用

快来打我* 2023-02-28 15:15 106阅读 0赞

## 前言 ##

众所周知，java的代码是同步顺序执行，当我们需要执行异步操作时我们需要创建一个新线程去执行，以往我们是这样操作的：

/**
         * 任务类
         */
        class Task implements Runnable {
    
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "：异步任务");
            }
        }

//新建线程并执行任务类
            new Thread(new Task()).start();

jdk1.8之后可以使用Lambda 表达式

//新建线程并执行任务类
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "：异步任务");
            }).start();

当然，除了显式的new Thread，我们一般通过线程池获取线程，这里就不再展开

Spring 3.0之后提供了一个**@Async**注解，使用@Async注解进行优雅的异步调用，我们先看一下API对这个注解的定义：[https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/scheduling/annotation/Async.html][https_docs.spring.io_spring_docs_current_javadoc-api_org_springframework_scheduling_annotation_Async.html]

![format_png][]

本文记录在SpringBoot项目中使用@Async注解，实现优雅的异步调用

##  　　代码与测试 ##

项目工程结构

![format_png 1][]

因为要测试事务，所以需要引入

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>

在启动类开启启用异步调用，同时注入ApplicationRunner对象在启动类进行调用测试

package cn.huanzi.qch.springbootasync;
    
    import cn.huanzi.qch.springbootasync.service.TestService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.ApplicationRunner;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.Bean;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.stereotype.Component;
    
    @Component
    @EnableAsync//开启异步调用
    @SpringBootApplication
    public class SpringbootAsyncApplication {
    
        @Autowired
        private TestService testService;
    
        public static void main(String[] args) {
            SpringApplication.run(SpringbootAsyncApplication.class, args);
        }
    
        /**
         * 启动成功
         */
        @Bean
        public ApplicationRunner applicationRunner() {
            return applicationArguments -> {
                long startTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：开始调用异步业务");
                //无返回值
    //            testService.asyncTask();
    
                //有返回值，但主线程不需要用到返回值
    //            Future<String> future = testService.asyncTask("huanzi-qch");
                //有返回值，且主线程需要用到返回值
    //            System.out.println(Thread.currentThread().getName() + "：返回值：" + testService.asyncTask("huanzi-qch").get());
    
                //事务测试，事务正常提交
    //            testService.asyncTaskForTransaction(false);
                //事务测试，模拟异常事务回滚
    //            testService.asyncTaskForTransaction(true);
    
                long endTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：调用异步业务结束，耗时：" + (endTime - startTime));
            };
        }
    }

看一下我们的测试业务类TestService

package cn.huanzi.qch.springbootasync.service;
    
    import java.util.concurrent.Future;
    
    public interface TestService {
        /**
         * 异步调用，无返回值
         */
        void asyncTask();
    
        /**
         * 异步调用，有返回值
         */
        Future<String> asyncTask(String s);
    
        /**
         * 异步调用，无返回值，事务测试
         */
        void asyncTaskForTransaction(Boolean exFlag);
    }

package cn.huanzi.qch.springbootasync.service;
    
    import cn.huanzi.qch.springbootasync.pojo.TbUser;
    import cn.huanzi.qch.springbootasync.repository.TbUserRepository;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.AsyncResult;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    import java.util.concurrent.Future;
    
    @Service
    public class TestServiceImpl implements TestService {
    
        @Autowired
        private TbUserRepository tbUserRepository;
    
        @Async
        @Override
        public void asyncTask() {
            long startTime = System.currentTimeMillis();
            try {
                //模拟耗时
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long endTime = System.currentTimeMillis();
            System.out.println(Thread.currentThread().getName() + "：void asyncTask()，耗时：" + (endTime - startTime));
        }
    
        @Async("asyncTaskExecutor")
        @Override
        public Future<String> asyncTask(String s) {
            long startTime = System.currentTimeMillis();
            try {
                //模拟耗时
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long endTime = System.currentTimeMillis();
            System.out.println(Thread.currentThread().getName() + "：Future<String> asyncTask(String s)，耗时：" + (endTime - startTime));
            return AsyncResult.forValue(s);
        }
    
        @Async("asyncTaskExecutor")
        @Transactional
        @Override
        public void asyncTaskForTransaction(Boolean exFlag) {
            //新增一个用户
            TbUser tbUser = new TbUser();
            tbUser.setUsername("huanzi-qch");
            tbUser.setPassword("123456");
            tbUserRepository.save(tbUser);
    
            if(exFlag){
                //模拟异常
                throw new RuntimeException("模拟异常");
            }
        }
    }

### 　　配置线程池 ###

package cn.huanzi.qch.springbootasync.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.task.AsyncTaskExecutor;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    /**
     * 线程池的配置
     */
    @Configuration
    public class AsyncConfig {
    
        private static final int MAX_POOL_SIZE = 50;
    
        private static final int CORE_POOL_SIZE = 20;
    
        @Bean("asyncTaskExecutor")
        public AsyncTaskExecutor asyncTaskExecutor() {
            ThreadPoolTaskExecutor asyncTaskExecutor = new ThreadPoolTaskExecutor();
            asyncTaskExecutor.setMaxPoolSize(MAX_POOL_SIZE);
            asyncTaskExecutor.setCorePoolSize(CORE_POOL_SIZE);
            asyncTaskExecutor.setThreadNamePrefix("async-task-thread-pool-");
            asyncTaskExecutor.initialize();
            return asyncTaskExecutor;
        }
    }

配置好后，@Async会默认从线程池获取线程，当然也可以显式的指定@Async("asyncTaskExecutor")

### 　　无返回值 ###

/**
         * 启动成功
         */
        @Bean
        public ApplicationRunner applicationRunner() {
            return applicationArguments -> {
                long startTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：开始调用异步业务");
    
                //无返回值
                testService.asyncTask();
    
                long endTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：调用异步业务结束，耗时：" + (endTime - startTime));
            };
        }

![format_png 2][]

### 　　有返回值 ###

有返回值，但主线程不需要用到返回值

/**
         * 启动成功
         */
        @Bean
        public ApplicationRunner applicationRunner() {
            return applicationArguments -> {
                long startTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：开始调用异步业务");//有返回值，但主线程不需要用到返回值
                Future<String> future = testService.asyncTask("huanzi-qch");
    
                long endTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：调用异步业务结束，耗时：" + (endTime - startTime));
            };
        }

![format_png 3][]

有返回值，且主线程需要用到返回值

/**
         * 启动成功
         */
        @Bean
        public ApplicationRunner applicationRunner() {
            return applicationArguments -> {
                long startTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：开始调用异步业务");
    //有返回值，且主线程需要用到返回值
                System.out.println(Thread.currentThread().getName() + "：返回值：" + testService.asyncTask("huanzi-qch").get());
    
                long endTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：调用异步业务结束，耗时：" + (endTime - startTime));
            };
        }

![format_png 4][]

可以发现，有返回值的情况下，虽然异步业务逻辑是由新线程执行，但如果在主线程操作返回值对象，主线程会等待，还是顺序执行

### 　　事务测试 ###

为了方便观察、测试，我们在配置文件中将日志级别设置成debug

#修改日志登记，方便调试
    logging.level.root=debug

事务提交

/**
         * 启动成功
         */
        @Bean
        public ApplicationRunner applicationRunner() {
            return applicationArguments -> {
                long startTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：开始调用异步业务");//事务测试，事务正常提交
                testService.asyncTaskForTransaction(false);
    
                long endTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：调用异步业务结束，耗时：" + (endTime - startTime));
            };
        }

![format_png 5][]

![format_png 6][]

![format_png 7][]

模拟异常，事务回滚

/**
         * 启动成功
         */
        @Bean
        public ApplicationRunner applicationRunner() {
            return applicationArguments -> {
                long startTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：开始调用异步业务");
    //事务测试，模拟异常事务回滚
                testService.asyncTaskForTransaction(true);
    
                long endTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + "：调用异步业务结束，耗时：" + (endTime - startTime));
            };
        }

![format_png 8][]

![format_png 9][]

![format_png 10][]

[https_docs.spring.io_spring_docs_current_javadoc-api_org_springframework_scheduling_annotation_Async.html]: https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/scheduling/annotation/Async.html
[format_png]: /images/20230209/3a83c948f3ae4dc9aefb8a03169a0f8a.png
[format_png 1]: /images/20230209/9a6cccaa464344199b1d5210308167d4.png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM1MzA1NS8yMDE5MDcvMTM1MzA1NS0yMDE5MDcyMzExNTgyNzM2OS0xMzcwNTQ0MzcucG5n?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM1MzA1NS8yMDE5MDcvMTM1MzA1NS0yMDE5MDcyMzEyMDc1MDA2My0xNjM3Mzk0MDg1LnBuZw?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM1MzA1NS8yMDE5MDcvMTM1MzA1NS0yMDE5MDcyMzEyMTAxNDQ3OS0zNTUwMjA2MTQucG5n?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM1MzA1NS8yMDE5MDcvMTM1MzA1NS0yMDE5MDcyMzEyMTI1OTA0OS0xMjY4NzY0OTM3LnBuZw?x-oss-process=image/format,png
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM1MzA1NS8yMDE5MDcvMTM1MzA1NS0yMDE5MDcyMzExNTEzMzA1NS04MDY0MjU4MTYucG5n?x-oss-process=image/format,png
[format_png 7]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM1MzA1NS8yMDE5MDcvMTM1MzA1NS0yMDE5MDcyMzExNTMzMzUyNy01NzM5MjY3OTMucG5n?x-oss-process=image/format,png
[format_png 8]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM1MzA1NS8yMDE5MDcvMTM1MzA1NS0yMDE5MDcyMzEyMTI0OTczOC0xNjQwMDQxMzMyLnBuZw?x-oss-process=image/format,png
[format_png 9]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM1MzA1NS8yMDE5MDcvMTM1MzA1NS0yMDE5MDcyMzExMzY1MzY3MC00ODQ1OTQwMTkucG5n?x-oss-process=image/format,png
[format_png 10]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM1MzA1NS8yMDE5MDcvMTM1MzA1NS0yMDE5MDcyMzExNTQxMjgxMi03NTgwMjM5OTgucG5n?x-oss-process=image/format,png