springboot异步调用@Async

小鱼儿 2022-03-15 05:40 463阅读 0赞

### 文章目录 ###

*   *   *  一、异步调用和同步调用的比较
         *  二、注解
         *  三、实例
         *   *  1、在启动类中开启异步—@EnabledAsync
             *  2、注册异步组件，在组件中标注异步方法—@Component、@Async
             *  3、测试用例:注入异步组件——@Autowired
             *  4、运行测试用例

### 一、异步调用和同步调用的比较 ###

*  同步调用是指程序按照顺序依次执行，每一行的程序必须等上一行程序执行完成之后才能执行；异步调用是指程序在顺序执行时，不等待异步调用的语句返回结果就执行后面的程序。
 *  同步调用执行时间比较长，执行效率比较差。异步调用可以实现并发执行，减少执行时间，提高执行效率。

### 二、注解 ###

springboot实现异步调用需要4个注解：

1.  @EnabledAsync 开启异步
2.  @Component 注册异步组件
3.  @Async 标注异步方法
4.  @Autowired 注入异步组件

### 三、实例 ###

#### 1、在启动类中开启异步—@EnabledAsync ####

**Application.java**

package com.gui.restful;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.scheduling.annotation.EnableAsync;
    
    @SpringBootApplication
    @EnableAsync//开启异步
    public class Application {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Application.class, args);
    	}
    
    }

#### 2、注册异步组件，在组件中标注异步方法—@Component、@Async ####

**Task.java**

注册异步组件，这个异步组件里有三个异步方法。  
我们用Future 返回异步调用的结果

package com.gui.restful;
    
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.AsyncResult;
    import org.springframework.stereotype.Component;
    
    import java.util.Random;
    import java.util.concurrent.Future;
    
    @Component//注册异步组件
    public class Task {
        Random random=new Random();
    
        @Async//标注异步方法
        public Future<String> taskOne() throws Exception{
            System.out.println("taskOne-start");
            long start=System.currentTimeMillis();
            Thread.sleep(3000);
            long end=System.currentTimeMillis();
            System.out.println("taskOne-end，耗时"+(end-start)+"毫秒");
            return new AsyncResult<>("task1完成");
        }
    
        @Async//标注异步方法
        public Future<String> taskTwo() throws Exception{
            System.out.println("taskTwo-start");
            long start=System.currentTimeMillis();
            Thread.sleep(3000);
            long end=System.currentTimeMillis();
            System.out.println("taskTwo-end，耗时"+(end-start)+"毫秒");
            return new AsyncResult<>("task2完成");
        }
    
        @Async//标注异步方法
        public Future<String> taskThree() throws Exception{
            System.out.println("taskThree-start");
            long start=System.currentTimeMillis();
            Thread.sleep(3000);
            long end=System.currentTimeMillis();
            System.out.println("taskThree-end，耗时"+(end-start)+"毫秒");
            return new AsyncResult<>("task3完成");
        }
    
    }

#### 3、测试用例:注入异步组件——@Autowired ####

**TaskTest.java**

package com.gui.restful;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import java.util.concurrent.Future;
    
    @SpringBootTest(classes =Application.class)
    @RunWith(SpringJUnit4ClassRunner.class)
    public class TaskTest {
    
        @Autowired//注入异步组件
        private Task task;
    
        @Test
        public void taskOne() throws Exception{
            long start=System.currentTimeMillis();
    
            Future<String> task1 = task.taskOne();
            Future<String> task2 = task.taskTwo();
            Future<String> task3 = task.taskThree();
    
            while(true){
                if(task1.isDone()&&task2.isDone()&&task3.isDone()){
                    break;
                }
                Thread.sleep(10);
            }
            long end=System.currentTimeMillis();
            System.out.println("总任务花费时间"+(end-start)+"毫秒");
        }
    }

**测试用例实现的效果：**  
1、记录开始时间  
2、调用三个异步函数，返回Future类型的结果对象  
3、在调用完三个异步函数之后，开启一个循环，根据返回的Future对象来判断三个异步函数是否都结束了。若都结束，就结束循环；若没有都结束，就等1秒后再判断。  
4、跳出循环之后，根据结束时间 - 开始时间，计算出三个任务并发执行的总耗时。

增加这个循环才能保证异步函数执行完成。

#### 4、运行测试用例 ####

运行测试用例TaskTest.java，有如下结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hqdTIy_size_16_color_FFFFFF_t_70]  
可以看到，通过异步调用，让三个任务并发运行。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hqdTIy_size_16_color_FFFFFF_t_70]: /images/20220315/ed6f0d24906043bbbe43976a341a6ac6.png