Spring异步处理——@Async注解

浅浅的花香味﹌ 2024-02-20 10:48 46阅读 0赞

#### 一、简介 ####

@Async是spring框架中十分好用的异步写法：

1，在方法上使用该@Async注解，申明该方法是一个异步任务；

2，在类上面使用该@Async注解，申明该类中的所有方法都是异步任务；

3，使用此注解的方法的类对象，必须是spring管理下的bean对象；

4，要想使用异步任务，需要在主类上开启异步配置，即，**配置上@EnableAsync注解**；

**@Async注解工作原理**  
就是在调用被注解的方法时，Spring会将该方法的执行转移到线程池中的一个线程进行处理。执行完成后，方法的返回值将通过Future或CompletableFuture进行封装，以便获取方法的返回结果。

**@Async 注解适用于以下场景，并具有以下优势：**

*  网络请求：在处理网络请求时，可以使用 @Async 注解将请求发送和响应处理分离，提高系统的并发处理能力。
 *  耗时计算：对于需要耗费大量时间的计算任务，可以使用 @Async 注解将计算过程放在后台执行，避免阻塞主线程，提高系统的响应速度。
 *  并行处理：通过 @Async 注解，可以同时执行多个任务，将多个相互独立的任务并行处理，从而减少整体处理时间。
 *  响应能力提升：使用异步编程可以避免阻塞主线程，提高系统的并发能力和响应能力，增强用户体验。
 *  代码简化：使用 @Async 注解可以简化编程模型，将异步执行的逻辑与业务逻辑分离，使代码更清晰、易于维护。

异步执行通过将任务分解为多个并发执行的子任务，可以充分利用系统资源，提高系统的吞吐量和并发处理能力，从而提升系统的性能和响应能力。@Async 注解简化了异步编程的实现，使开发人员能够更方便地使用异步处理机制。同时，它还可以使代码更易于阅读和维护，提高开发效率。

#### 二、 同步与异步理解 ####

1、\*\*同步：\*\*同步就是整个处理过程顺序执行，当各个过程都执行完毕，并返回结果  
2、异步：异步调用则是只是发送调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执行下面的流程。  
\*\*例如：\*\*在某个调用中，需要顺序调用 A, B, C三个过程方法；如他们都是同步调用，则需要将他们都顺序执行完毕之后，方算作过程执行完毕； 如B为一个异步的调用方法，则在执行完A之后，调用B，并不等待B完成，而是执行开始调用C，待C执行完毕之后，就意味着这个过程执行完毕了。在Java中，一般在处理类似的场景之时，都是基于创建独立的线程去完成相应的异步调用逻辑，通过主线程和不同的业务子线程之间的执行流程，从而在启动独立的线程之后，主线程继续执行而不会产生停滞等待的情况。

##### 1、同步调用 #####

下面通过一个简单示例来直观的理解什么是同步调用：  
1、定义Task类，创建三个处理函数分别模拟三个执行任务的操作，操作消耗时间随机取（10秒内）

@Component
    public class Task {
        
     
        public static Random random =new Random();
     
        public void doTaskOne() throws Exception {
        
            System.out.println("开始做任务一");
            long start = System.currentTimeMillis();
            Thread.sleep(random.nextInt(10000));
            long end = System.currentTimeMillis();
            System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
        }
     
        public void doTaskTwo() throws Exception {
        
            System.out.println("开始做任务二");
            long start = System.currentTimeMillis();
            Thread.sleep(random.nextInt(10000));
            long end = System.currentTimeMillis();
            System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
        }
     
        public void doTaskThree() throws Exception {
        
            System.out.println("开始做任务三");
            long start = System.currentTimeMillis();
            Thread.sleep(random.nextInt(10000));
            long end = System.currentTimeMillis();
            System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
        }
     
    }

2、在单元测试用例中，注入Task对象，并在测试用例中执行doTaskOne、doTaskTwo、doTaskThree三个函数。

@RunWith(SpringJUnit4ClassRunner.class)
    @SpringApplicationConfiguration(classes = Application.class)
    public class ApplicationTests {
        
     
        @Autowired
        private Task task;
     
        @Test
        public void test() throws Exception {
        
            task.doTaskOne();
            task.doTaskTwo();
            task.doTaskThree();
        }
     
    }

**3、执行单元测试，可以看到类似如下输出：**  
开始做任务一  
完成任务一，耗时：4256毫秒

开始做任务二  
完成任务二，耗时：4957毫秒

开始做任务三  
完成任务三，耗时：7173毫秒

**任务一、任务二、任务三顺序的执行完了，换言之doTaskOne、doTaskTwo、doTaskThree三个函数顺序的执行完成。**

##### 2、 异步调用 #####

上述的同步调用虽然顺利的执行完了三个任务，但是可以看到执行时间比较长，若这三个任务本身之间不存在依赖关系，可以并发执行的话，同步调用在执行效率方面就比较差，可以考虑通过异步调用的方式来并发执行。  
在Spring Boot中，我们只需要通过使用\*\*@Async注解\*\*就能简单的将原来的同步函数变为异步函数，Task类改在为如下模式：

public static Random random = new Random();
     
        @Async
        public Future<String> doTaskOne() throws Exception {
        
            System.out.println("开始做任务1");
            long start = System.currentTimeMillis();
            Thread.sleep(random.nextInt(10000));
            long end = System.currentTimeMillis();
            System.out.println("完成任务1，耗时：" + (end - start) + "毫秒");
            return new AsyncResult<>("任务1完成");
        }
     
        @Async
        public Future<String> doTaskTwo() throws Exception {
        
            System.out.println("开始做任务2");
            long start = System.currentTimeMillis();
            Thread.sleep(random.nextInt(10000));
            long end = System.currentTimeMillis();
            System.out.println("完成任务2，耗时：" + (end - start) + "毫秒");
            return new AsyncResult<>("任务2完成");
        }
     
        @Async
        public Future<String> doTaskThree() throws Exception {
        
            System.out.println("开始做任务3");
            long start = System.currentTimeMillis();
            Thread.sleep(random.nextInt(10000));
            long end = System.currentTimeMillis();
            System.out.println("完成任务3，耗时：" + (end - start) + "毫秒");
            return new AsyncResult<>("任务3完成");
        }

**看看我们做了哪些改变：**

1、在测试用例一开始记录开始时间  
2、在调用三个异步函数的时候，返回Future类型的结果对象  
3、在调用完三个异步函数之后，开启一个循环，根据返回的Future对象来判断三个异步函数是否都结束了。若都结束，就结束循环；若没有都结束，就等1秒后再判断

开始做任务一
    开始做任务二
    开始做任务三
    完成任务三，耗时：37毫秒
    完成任务二，耗时：3661毫秒
    完成任务一，耗时：7149毫秒
    任务全部完成，总耗时：8025毫秒

**可以看到，通过异步调用，让任务一、二、三并发执行，有效的减少了程序的总运行时间**

#### 三、@Async的使用 ####

1、使用@Async注解时要先在启动类上添加@EnableAsync注解

// 基于Java配置的启用方式：
    @Configuration  
    @EnableAsync  
    public class SpringAsyncConfig {
         ... }  
     
    // Spring boot启用：
    @EnableAsync
    @EnableTransactionManagement
    public class SettlementApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(SettlementApplication.class, args);
        }
    }

2、添加@Async注解  
1）无返回值的调用方法

/**
        * 带参数的异步调用 异步方法可以传入参数
        *  对于返回值是void，异常会被AsyncUncaughtExceptionHandler处理掉
        * @param s
        */
       @Async
       public void asyncInvokeWithException(String s) {
        
           log.info("asyncInvokeWithParameter, parementer={}", s);
           throw new IllegalArgumentException(s);
       }

2）Future返回值

@Async("MyExecutor")
    public Future<Map<Long, List>> queryMap(List ids) {
        
        List<> result = businessService.queryMap(ids);
        ..............
        Map<Long, List> resultMap = Maps.newHashMap();
        ...
        return new AsyncResult<>(resultMap);
    }

#### 四、@Async的线程池问题 ####

##### 1、Spring默认线程池 #####

1、@Async注解在使用时，如果不指定线程池的名称，则使用spring默认的线程池，spring默认的线程池为**SimpleAsyncTaskExecutor**  
**2、方法上一旦标记了这个@Async注解，当其它线程调用这个方法时，就会开启一个新的子线程去异步处理该业务逻辑。**

spring的默认线程池配置为
     
        默认核心线程数：8
        
        最大线程数：Integet.MAX_VALUE
     
        队列使用LinkedBlockingQueue
     
        容量是：Integet.MAX_VALUE
     
        空闲线程保留时间：60s
     
        线程池拒绝策略：AbortPolicy

可以看到，他对最大线程数没有限制，也就是会无限多的创建线程

##### 2、自定义线程池 #####

1、编写配置文件

spring:
      task:
        execution:
          pool:
            max-size: 6
            core-size: 3
            keep-alive: 3s
            queue-capacity: 1000
            thread-name-prefix: name

2、编写配置类

@Configuration
    @Data
    public class ExecutorConfig{
        
        /**
         * 核心线程
         */
        private int corePoolSize;
        /**
         * 最大线程
         */
        private int maxPoolSize;
        /**
         * 队列容量
         */
        private int queueCapacity;
        /**
         * 保持时间
         */
        private int keepAliveSeconds;
        /**
         * 名称前缀
         */
        private String preFix;
     
        @Bean("MyExecutor")
        public Executor myExecutor() {
        
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(corePoolSize);
            executor.setMaxPoolSize(maxPoolSize);
            executor.setQueueCapacity(queueCapacity);
            executor.setKeepAliveSeconds(keepAliveSeconds);
            executor.setThreadNamePrefix(preFix);
            executor.setRejectedExecutionHandler( new ThreadPoolExecutor.AbortPolicy());
            executor.initialize();
            return executor;
        }
    }

3、使用@Async注解并指定自定义线程池

@Component
    public class MyAsyncTask {
        
         @Async("MyExecutor") //使用自定义的线程池(执行器)
        public void asyncCpsItemImportTask(Long platformId, String jsonList){
        
            //...具体业务逻辑
        }
    }

#### 五、@Async的事务与异常处理 ####

1.由于@Async注解由于是异步执行的，在其进行数据库的操作之时，外层的事务控制将无法进行事务管理。**可以把@Transactional注解放到内部的需要进行事务的方法上，来实现事务管理**。

2.同样由于异步的关系，@Async方法中的抛出的异常无法被外部的try…catch捕获，因此**要把try…catch写到异步方法内**