Spring Boot使用@Async实现异步调用

2023-11-10

1. Spring Boot使用@Async实现异步调用

链接:#link

原文：http://blog.csdn.net/a286352250/article/details/53157822

项目GitHub地址：

https://github.com/FrameReserve/TrainingBoot

Spring Boot（十）使用@Async实现异步调用，标记地址：

https://github.com/FrameReserve/TrainingBoot/releases/tag/0.0.10

1.1. Spring Boot启动类，增加@EnableAsync注解配置：

src/main/java/com/training/SpringBootServlet.java

[java] view plain copy

package com.training;  
  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
import org.springframework.boot.builder.SpringApplicationBuilder;  
import org.springframework.boot.web.support.SpringBootServletInitializer;  
import org.springframework.scheduling.annotation.EnableAsync;  
  
@SpringBootApplication  
@EnableAsync  
public class SpringBootServlet extends SpringBootServletInitializer {  
  
    // jar启动  
    public static void main(String[] args) {  
        SpringApplication.run(SpringBootServlet.class, args);  
    }  
  
    // tomcat war启动  
    @Override  
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {  
        return application.sources(SpringBootServlet.class);  
    }  
  
}

1.2. 测试：

增加异步方法Service，线程休眠：

[java] view plain copy

package com.training.async.service.impl;  
  
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.Service;  
  
import com.training.async.service.DemoAsyncService;  
  
@Service  
public class DemoAsyncServiceImpl implements DemoAsyncService {  
  
    public static Random random =new Random();  
  
    @Async  
    public Future<String> doTaskOne() 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> doTaskTwo() 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> doTaskThree() 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<>("任务三完成");  
    }  
      
}

1.3. 调用异步测试测试，查看控制台输出执行顺序：

[java] view plain copy

package com.training.async.controller;  
  
import io.swagger.annotations.ApiOperation;  
  
import java.util.concurrent.Future;  
  
import javax.annotation.Resource;  
  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;  
import org.springframework.web.bind.annotation.ResponseBody;  
import org.springframework.web.bind.annotation.RestController;  
  
import com.training.async.service.DemoAsyncService;  
import com.training.core.dto.ResultDataDto;  
  
@RestController  
@RequestMapping(value="/async")   
public class DemoAsyncController {  
  
    @Resource  
    private DemoAsyncService demoAsyncService;  
  
    /** 
     * 测试异步方法调用顺序 
     */  
    @ApiOperation(value="测试异步方法调用顺序", notes="getEntityById")  
    @RequestMapping(value = "/getTestDemoAsync", method = RequestMethod.GET)  
    public @ResponseBody ResultDataDto getEntityById() throws Exception {  
          
        long start = System.currentTimeMillis();  
  
        Future<String> task1 = demoAsyncService.doTaskOne();  
        Future<String> task2 = demoAsyncService.doTaskTwo();  
        Future<String> task3 = demoAsyncService.doTaskThree();  
  
        while(true) {  
            if(task1.isDone() && task2.isDone() && task3.isDone()) {  
                // 三个任务都调用完成，退出循环等待  
                break;  
            }  
            Thread.sleep(1000);  
        }  
  
        long end = System.currentTimeMillis();  
  
        System.out.println("任务全部完成，总耗时：" + (end - start) + "毫秒");  
        return ResultDataDto.addSuccess();  
    }  
}

原文：http://blog.csdn.net/v2sking/article/details/72795742

1.4. 什么是异步调用？

异步调用是相对于同步调用而言的，同步调用是指程序按预定顺序一步步执行，每一步必须等到上一步执行完后才能执行，异步调用则无需等待上一步程序执行完即可执行。

1.5. 如何实现异步调用？

多线程，这是很多人第一眼想到的关键词，没错，多线程就是一种实现异步调用的方式。

在非spring目项目中我们要实现异步调用的就是使用多线程方式，可以自己实现Runable接口或者集成Thread类，或者使用jdk1.5以上提供了的Executors线程池。

1.6. StrngBoot中则提供了很方便的方式执行异步调用。

按照官方示例开撸

代码入下

1.6.1. maven依赖：

[java] view plain copy

<parent>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-parent</artifactId>  
    <version>1.5.3.RELEASE</version>  
</parent>  
<dependencies>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
</dependencies>

1.6.2. 启动类：添加@EnableAsync注解

[java] view plain copy

@SpringBootApplication  
@EnableAsync  
public class Application{  
  
    public static void main(String[] args) {  
        SpringApplication.run(Application.class, args);  
    }  
}

1.6.3. Controller

只需在需要异步执行方法上添加@Async注解

[java] view plain copy

@RestController  
@RequestMapping("")  
public class AsyncTaskController {  
      
    @RequestMapping("")  
    public String doTask() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        this.task1();  
        this.task2();  
        this.task3();  
        long currentTimeMillis1 = System.currentTimeMillis();  
        return "task任务总耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms";  
    }  
      
    @Async  
    public void task1() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Thread.sleep(1000);  
        long currentTimeMillis1 = System.currentTimeMillis();  
        System.out.println("task1任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");  
    }  
      
    @Async  
    public void task2() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Thread.sleep(2000);  
        long currentTimeMillis1 = System.currentTimeMillis();  
        System.out.println("task2任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");  
    }  
    @Async  
    public void task3() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Thread.sleep(3000);  
        long currentTimeMillis1 = System.currentTimeMillis();  
        System.out.println("task3任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");  
    }  
}

1.6.4. main函数运行spirngboot项目，启动完成后浏览器访问：

http://localhost:8080/

1.6.5. 控制台：

[html] view plain copy
 
task1任务耗时:1012ms  
task2任务耗时:2009ms  
task3任务耗时:3004ms  
 
等了一段浏览器时候输出入下：

 

[html] view plain copy
 
task任务总耗时:6002ms

1.6.5.1. 异步并没有执行！

难道是代码写错了？反复检查了好几遍，并没有发现什么明显错误，想起spring对@Transactional注解时也有类似问题，spring扫描时具有@Transactional注解方法的类时，是生成一个代理类，由代理类去开启关闭事务，而在同一个类中，方法调用是在类体内执行的，spring无法截获这个方法调用。

1.6.5.2. 豁然开朗，将异步任务单独放到一个类中，调整代码入下：

1.6.6. Controller

[java] view plain copy

@RequestMapping("")  
@RestController  
public class AsyncTaskController {  
      
    @Autowired  
    private AsyncTask asyncTask;  
      
    @RequestMapping("")  
    public String doTask() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        asyncTask.task1();  
        asyncTask.task2();  
        asyncTask.task3();  
        long currentTimeMillis1 = System.currentTimeMillis();  
        return "task任务总耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms";  
          
    }  
}

1.6.7. 异步任务类

[java] view plain copy

@Component  
public class AsyncTask {  
      
    @Async  
    public void task1() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Thread.sleep(1000);  
        long currentTimeMillis1 = System.currentTimeMillis();  
        System.out.println("task1任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");  
    }  
      
    @Async  
    public void task2() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Thread.sleep(2000);  
        long currentTimeMillis1 = System.currentTimeMillis();  
        System.out.println("task2任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");  
    }  
    @Async  
    public void task3() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Thread.sleep(3000);  
        long currentTimeMillis1 = System.currentTimeMillis();  
        System.out.println("task3任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");  
    }  
}

1.6.8. 控制台：

[html] view plain copy

task1任务耗时:1012ms  
task2任务耗时:2009ms  
task3任务耗时:3004ms

访问浏览器结果入下：

[html] view plain copy

task任务总耗时:19ms

1.6.9. 异步调用成功！

1.7. 如何知道三个异步任务什么时候执行完，执行的结果怎样呢？可以采用添加Fature回调方式判断

代码入下：

1.7.1. 异步任务类

[java] view plain copy

@Component  
public class AsyncTask {  
      
    @Async  
    public Future<String> task1() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Thread.sleep(1000);  
        long currentTimeMillis1 = System.currentTimeMillis();  
        System.out.println("task1任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");  
        return new AsyncResult<String>("task1执行完毕");  
    }  
      
    @Async  
    public Future<String> task2() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Thread.sleep(2000);  
        long currentTimeMillis1 = System.currentTimeMillis();  
        System.out.println("task2任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");  
        return new AsyncResult<String>("task2执行完毕");  
    }  
    @Async  
    public Future<String> task3() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Thread.sleep(3000);  
        long currentTimeMillis1 = System.currentTimeMillis();  
        System.out.println("task3任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");  
        return new AsyncResult<String>("task3执行完毕");  
    }  
}

1.7.2. Controller

[java] view plain copy

@RequestMapping("")  
@RestController  
public class AsyncTaskController {  
      
    @Autowired  
    private AsyncTask asyncTask;  
      
    @RequestMapping("")  
    public String doTask() throws InterruptedException{  
        long currentTimeMillis = System.currentTimeMillis();  
        Future<String> task1 = asyncTask.task1();  
        Future<String> task2 = asyncTask.task2();  
        Future<String> task3 = asyncTask.task3();  
        String result = null;  
        for (;;) {  
            if(task1.isDone() && task2.isDone() && task3.isDone()) {  
                // 三个任务都调用完成，退出循环等待  
                break;  
            }  
            Thread.sleep(1000);  
        }  
        long currentTimeMillis1 = System.currentTimeMillis();  
        result = "task任务总耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms";  
        return result;  
    }  
}

1.7.3. 控制台输出：

[html] view plain copy

task1任务耗时:1000ms  
task2任务耗时:2001ms  
task3任务耗时:3001ms

1.7.4. 浏览器输出：

[html] view plain copy

task任务总耗时:4015ms

1.7.5. 异步调用成功，并且在所有任务都完成时程序才返回了结果！

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Async