springboot干货——（十六）使用@Async实现异步调用

矫情吗；* 2021-09-26 12:48 536阅读 0赞

异步调用针对的是同步调用，一般在代码中我们使用同步调用相对较多，即请求代码立即返回结果或者说执行代码，异步调用则是指请求之后不会里面返回结果或者是调用代码。

接下来我们用实例来看下什么是同步调用：

新建一个springboot项目后创建对应的task类：

package com.gwd.task;
    
    import java.util.Random;
    
    import org.springframework.stereotype.Component;
    
    /** 
    * @FileName Task.java
    * @Description:TODO
    * @author JackHisen(gu.weidong)
    * @version V1.0
    * @createtime 2018年2月24日 下午2:48:47 
    * 修改历史：
    * 时间           作者          版本        描述
    *====================================================  
    *
    */
    @Component
    public class Task {
    	public static Random random =new Random();
    	
    	public void taskOne() 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 taskTwo() 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 taskThree() throws Exception {
    		System.out.println("开始执行任务三");
    		long start=System.currentTimeMillis();
    		Thread.sleep(random.nextInt(10000));
    		long end=System.currentTimeMillis();
    		System.out.println("任务三执行时间："+(end- start));
    	}
    }

测试类如下：

package com.gwd;
    
    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.SpringRunner;
    import com.gwd.task.Task;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootAsyncApplicationTests {
    	@Autowired
    	private Task task;
    	@Test
    	public void test() throws Exception {
    		task.taskOne();
    		task.taskTwo();
    		task.taskThree();
    	}
    }

测试结果如下：

开始执行任务一
    任务一执行时间：9019
    开始执行任务二
    任务二执行时间：7612
    开始执行任务三
    任务三执行时间：365

从结果上我们不难看出这三个是按顺序执行的。

接下来我们来看看异步调用：

1.为了让@Async注解能够生效，还需要在Spring Boot的主程序中配置@EnableAsync，如下所示：

package com.gwd;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.scheduling.annotation.EnableAsync;
    
    @SpringBootApplication
    @EnableAsync
    public class SpringbootAsyncApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(SpringbootAsyncApplication.class, args);
    	}
    }

2.在Spring Boot中，我们只需要通过使用@Async注解就能简单的将原来的同步函数变为异步函数，Task类改在为如下模式：

package com.gwd.task;
    
    import java.util.Random;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.stereotype.Component;
    
    /** 
    * @FileName Task.java
    * @Description:TODO
    * @author JackHisen(gu.weidong)
    * @version V1.0
    * @createtime 2018年2月24日 下午2:48:47 
    * 修改历史：
    * 时间           作者          版本        描述
    *====================================================  
    *
    */
    @Component
    public class Task {
    	public static Random random =new Random();
    	
    	@Async
    	public void taskOne() throws Exception {
    		System.out.println("开始执行任务一");
    		long start=System.currentTimeMillis();
    		Thread.sleep(random.nextInt(10000));
    		long end=System.currentTimeMillis();
    		System.out.println("任务一执行时间："+(end- start));
    	}
    	
    	@Async
    	public void taskTwo() throws Exception {
    		System.out.println("开始执行任务二");
    		long start=System.currentTimeMillis();
    		Thread.sleep(random.nextInt(10000));
    		long end=System.currentTimeMillis();
    		System.out.println("任务二执行时间："+(end- start));
    	}
    	@Async
    	public void taskThree() throws Exception {
    		System.out.println("开始执行任务三");
    		long start=System.currentTimeMillis();
    		Thread.sleep(random.nextInt(10000));
    		long end=System.currentTimeMillis();
    		System.out.println("任务三执行时间："+(end- start));
    	}
    }

此时可以反复执行单元测试，您可能会遇到各种不同的结果，比如：  
没有任何任务相关的输出  
有部分任务相关的输出  
乱序的任务相关的输出

原因是目前taskOne、taskTwo、taskThree三个函数的时候已经是异步执行了。主程序在异步调用之后，主程序并不会理会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就自动结束了，导致了不完整或是没有输出任务相关内容的情况。

**注： @Async所修饰的函数不要定义为static类型，这样异步调用不会生效**

异步回调

为了让taskOne、taskTwo、taskThree能正常结束，假设我们需要统计一下三个任务并发执行共耗时多少，这就需要等到上述三个函数都完成调动之后记录时间，并计算结果。  
  
那么我们如何判断上述三个异步调用是否已经执行完成呢？我们需要使用Future<T>来返回异步调用的结果，就像如下方式改造task类：

package com.gwd.task;
    
    import java.util.Random;
    import java.util.concurrent.Future;
    
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.AsyncResult;
    import org.springframework.stereotype.Component;
    
    /** 
    * @FileName Task.java
    * @Description:TODO
    * @author JackHisen(gu.weidong)
    * @version V1.0
    * @createtime 2018年2月24日 下午2:48:47 
    * 修改历史：
    * 时间           作者          版本        描述
    *====================================================  
    *
    */
    @Component
    public class Task {
    	public static Random random =new Random();
    	
    	@Async
    	public Future<String> taskOne() throws Exception {
    	    System.out.println("开始做任务一");
    	    long start = System.currentTimeMillis();
    	    Thread.sleep(random.nextInt(10000));
    	    long end = System.currentTimeMillis();
    	    System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
    	    return new AsyncResult<>("任务一完成");
    	}
    	
    	@Async
    	public Future<String> taskTwo() throws Exception {
    		System.out.println("开始执行任务二");
    		long start=System.currentTimeMillis();
    		Thread.sleep(random.nextInt(10000));
    		long end=System.currentTimeMillis();
    		System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
    		return new AsyncResult<>("任务二完成");
    	}
    	@Async
    	public Future<String> taskThree() throws Exception {
    		System.out.println("开始执行任务三");
    		long start=System.currentTimeMillis();
    		Thread.sleep(random.nextInt(10000));
    		long end=System.currentTimeMillis();
    		System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
    		return new AsyncResult<>("任务三完成");
    	}
    }

按照如上方式改造一下其他两个异步函数之后，下面我们改造一下测试用例，让测试在等待完成三个异步调用之后来做一些其他事情。

package com.gwd;
    
    import java.util.concurrent.Future;
    
    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.SpringRunner;
    
    import com.gwd.task.Task;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootAsyncApplicationTests {
    	@Autowired
    	private Task task;
    	@Test
    	public void test() 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(1000);
    		}
    		long end = System.currentTimeMillis();
    
    		System.out.println("任务全部完成，总耗时：" + (end - start) + "毫秒");
    	}
    }

看看我们做了哪些改变：  
  
1.在测试用例一开始记录开始时间  
2.在调用三个异步函数的时候，返回Future<String>类型的结果对象  
3.在调用完三个异步函数之后，开启一个循环，根据返回的Future<String>对象来判断三个异步函数是否都结束了。若都结束，就结束循环；若没有都结束，就等1秒后再判断。  
4.跳出循环之后，根据结束时间 - 开始时间，计算出三个任务并发执行的总耗时。  
执行一下上述的单元测试，可以看到如下结果：

开始执行任务二
    开始做任务一
    开始执行任务三
    完成任务二，耗时：5700毫秒
    完成任务三，耗时：7232毫秒
    完成任务一，耗时：7325毫秒
    任务全部完成，总耗时：8006毫秒

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

原文转自：[Spring Boot中使用@Async实现异步调用][Spring Boot_Async]

[Spring Boot_Async]: http://blog.didispace.com/springbootasync/