一. 什么是异步调用？
异步调用是相对于同步调用而言的，同步调用是指程序按预定顺序一步步执行，每一步必须等到上一步执行完后才能执行，异步调用则无需等待上一步程序执行完即可执行。
二. 如何实现异步调用？
多线程，这是很多人第一眼想到的关键词，没错，多线程就是一种实现异步调用的方式。在非spring目项目中我们要实现异步调用的就是使用多线程方式，可以自己实现Runable接口或者集成Thread类，或者使用jdk1.5以上提供了的Executors线程池。在spring 3.x之后，就已经内置了@Async来完美解决这个问题，下面将介绍在springboot中如何使用@Async。
三. 举例说明（无须知道执行结果）：
1、pom.xml中导入必要的依赖：
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.1.RELEASE</version>
</parent>
<dependencies>
<!-- SpringBoot 核心组件 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
</dependencies>
2、写一个springboot的启动类：
启动类里面使用@EnableAsync注解开启功能，自动扫描
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);
}
}
3、建一个service包，然后新建一个UserService类：
- 要在异步任务的类上写@Component
- 在定义异步任务类写@Async（写在类上代表整个类都是异步，在方法加上代表该类异步执行）
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
public class UserService {
@Async
public void sendSms(){
System.out.println("####sendSms#### 2");
IntStream.range(0, 5).forEach(d -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println("####sendSms#### 3");
}
}
4、建一个controller包，然后新建一个IndexController类，用来获取请求：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.jeffrey.service.UserService;
@RestController
public class IndexController {
@Autowired
private UserService userService;
@RequestMapping("/async")
public String async(){
System.out.println("####IndexController#### 1");
userService.sendSms();
System.out.println("####IndexController#### 4");
return "success";
}
}
先注掉@EnableAsync和@Async两个注解，看下同步调用执行的效果。执行结果如下：
####IndexController#### 1
####sendSms#### 2
####sendSms#### 3
####IndexController#### 4
对于sendSms方法，我们并不关注它什么时候执行完，所以可以采用异步的方式去执行。放开@EnableAsync和@Async两个注解，执行结果如下：
####IndexController#### 1
####IndexController#### 4
####sendSms#### 2
####sendSms#### 3
总结：使用了@Async的方法，会被当成是一个子线程，所有整个sendSms方法，会在主线程执行完了之后执行
四. 举例说明（须知道执行结果）：
基于上面例子，这里只贴核心代码
1、启动类
@SpringBootApplication
@EnableAsync //开启异步任务
public class MainApplication {
public static void main(String[] args) {
SpringApplication.run(MainApplication.class, args);
}
}
2、异步类
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;
import java.util.concurrent.Future;
/**
* @ClassName AsyncTestTask
* @Author jeffrey
* @Description 异步任务业务类
**/
@Component
@Async
public class AsyncTestTask {
//获取异步结果
public Future<String> task4() throws InterruptedException{
long begin = System.currentTimeMillis();
Thread.sleep(2000L);
long end = System.currentTimeMillis();
System.out.println("任务4耗时="+(end-begin));
return new AsyncResult<String>("任务4");
}
public Future<String> task5() throws InterruptedException{
long begin = System.currentTimeMillis();
Thread.sleep(3000L);
long end = System.currentTimeMillis();
System.out.println("任务5耗时="+(end-begin));
return new AsyncResult<String>("任务5");
}
public Future<String> task6() throws InterruptedException{
long begin = System.currentTimeMillis();
Thread.sleep(1000L);
long end = System.currentTimeMillis();
System.out.println("任务6耗时="+(end-begin));
return new AsyncResult<String>("任务6");
}
}
3、controller类
import com.ceair.service.AsyncTestTask;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.Future;
/**
* @ClassName UserController
* @Author jeffrey
* @Description User
**/
@RestController
@RequestMapping("/api")
public class UserController {
@Autowired
private AsyncTestTask asyncTestTask;
@GetMapping("userAsyncTask")
public String exeTask() throws InterruptedException{
long begin = System.currentTimeMillis();
Future<String> task4 = asyncTestTask.task4();
Future<String> task5 = asyncTestTask.task5();
Future<String> task6 = asyncTestTask.task6();
//如果都执行往就可以跳出循环,isDone方法如果此任务完成，true
for(;;){
if (task4.isDone() && task5.isDone() && task6.isDone()) {
break;
}
}
long end = System.currentTimeMillis();
long total = end-begin;
System.out.println("执行总耗时="+total);
return String.valueOf(total);
}
}
执行结果如下：
任务6耗时=1000
任务4耗时=2000
任务5耗时=3000
执行总耗时=3012
总结：
从上面示例我们可以看出：如果同步方法，那我们需要6秒，而异步执行，我们只需要3秒左右，这就是异步的作用。
1）要把异步任务封装到类里面，不能直接写到Controller
2）增加Future<String> 返回结果 AsyncResult<String>("task执行完成");
3）如果需要拿到结果 需要判断全部的 task.isDone()
