springboot异步调用@Async

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

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

二、注解

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，有如下结果：

可以看到，通过异步调用，让三个任务并发运行。