SpringBoot实现异步调用的几种方式

原创 已于 2023-06-14 17:26:55 修改 · 7.9k 阅读 · 31 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

于 2023-06-07 22:18:53 首次发布

一、使用 CompletableFuture 实现异步任务

CompletableFuture 是 Java 8 新增的一个异步编程工具，它可以方便地实现异步任务。使用 CompletableFuture 需要满足以下条件：

  1. 异步任务的返回值类型必须是 CompletableFuture 类型；

  2. 在异步任务中使用 CompletableFuture.supplyAsync() 或 CompletableFuture.runAsync() 方法来创建异步任务；

  3. 在主线程中使用 CompletableFuture.get() 方法获取异步任务的返回结果。

我们创建一个服务类，里面包含了异步方法和普通方法。

import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步服务类
 */
@Service
public class AsyncService {


    /**
     * 普通任务操作1
     */
    public String task1() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成1";
    }

    /**
     * 普通任务操作2
     */
    public String task2() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        return "任务执行完成2";
    }

    /**
     * 普通任务操作3
     */
    public String task3() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成3";
    }

    /**
     * 异步操作1
     */
    public CompletableFuture<String> asyncTask1() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "异步任务执行完成1";
        });
    }

    /**
     * 异步操作2
     */
    public CompletableFuture<String> asyncTask2() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "异步任务执行完成2";
        });
    }

    /**
     * 异步操作3
     */
    public CompletableFuture<String> asyncTask3() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "异步任务执行完成3";
        });
    }
}

我们先测试普通方法的情况，看看最后耗时

import cn.hutool.core.date.StopWatch;
import com.example.quartzdemo.service.AsyncService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步处理测试
 */
@SpringBootTest
public class AsyncTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    void test1() throws InterruptedException {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();

        // 异步操作
       /* CompletableFuture<String> completableFuture1 = asyncService.asyncTask1();
        CompletableFuture<String> completableFuture2 = asyncService.asyncTask2();
        CompletableFuture<String> completableFuture3 = asyncService.asyncTask3();

        System.out.println(completableFuture1.get());
        System.out.println(completableFuture2.get());
        System.out.println(completableFuture3.get());*/

        // 同步操作
        System.out.println(asyncService.task1());
        System.out.println(asyncService.task2());
        System.out.println(asyncService.task3());

        stopWatch.stop();
        System.out.println("耗时:" + stopWatch.getTotalTimeMillis());
    }
}

程序执行的结果:

任务执行完成1
任务执行完成2
任务执行完成3
耗时:8008

我们可以发现，普通同步方法是按顺序一个个操作的，各个方法不会同时处理。下面我们把这些操作换成异步的方法测试。

import cn.hutool.core.date.StopWatch;
import com.example.quartzdemo.service.AsyncService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步处理测试
 */
@SpringBootTest
public class AsyncTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    void test1() throws InterruptedException, ExecutionException {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();

        // 异步操作
        CompletableFuture<String> completableFuture1 = asyncService.asyncTask1();
        CompletableFuture<String> completableFuture2 = asyncService.asyncTask2();
        CompletableFuture<String> completableFuture3 = asyncService.asyncTask3();

        System.out.println(completableFuture1.get());
        System.out.println(completableFuture2.get());
        System.out.println(completableFuture3.get());

        // 同步操作
        /*System.out.println(asyncService.task1());
        System.out.println(asyncService.task2());
        System.out.println(asyncService.task3());*/

        stopWatch.stop();
        System.out.println("耗时:" + stopWatch.getTotalTimeMillis());
    }
}

程序执行结果:

异步任务执行完成1
异步任务执行完成2
异步任务执行完成3
耗时:3008

发现几个方法是异步同时进行的，没有先后的顺序，大大提高了程序执行效率。

二、基于注解 @Async实现异步任务

@Async 注解是 Spring 提供的一种轻量级异步方法实现方式，它可以标记在方法上，用来告诉 Spring 这个方法是一个异步方法，Spring 会将这个方法的执行放在异步线程中进行。使用 @Async 注解需要满足以下条件：

  1. 需要在 Spring Boot 主类上添加 @EnableAsync 注解启用异步功能；

  2. 需要在异步方法上添加 @Async 注解。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
// 主类上加上这个注解,开启异步功能
@EnableAsync
public class QuartzDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(QuartzDemoApplication.class, args);
    }

}

修改测试的服务层

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步服务类
 */
@Service
public class AsyncService {


    /**
     * 同步任务操作1
     */
    public String task1() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成1";
    }

    /**
     * 同步任务操作2
     */
    public String task2() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        return "任务执行完成2";
    }

    /**
     * 同步任务操作3
     */
    public String task3() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成3";
    }


    /**
     * 异步操作1
     */
    @Async
    public Future<String> asyncTask1() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        TimeUnit.SECONDS.sleep(3);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task1任务耗时:" + (currentTimeMillis1 - currentTimeMillis) + "ms");
        return new AsyncResult<>("task1完成");
    }

    /**
     * 异步操作2
     */
    @Async
    public Future<String> asyncTask2() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        TimeUnit.SECONDS.sleep(2);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task1任务耗时:" + (currentTimeMillis1 - currentTimeMillis) + "ms");
        return new AsyncResult<>("task2完成");
    }

    /**
     * 异步操作3
     */
    @Async
    public Future<String> asyncTask3() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        TimeUnit.SECONDS.sleep(3);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task1任务耗时:" + (currentTimeMillis1 - currentTimeMillis) + "ms");
        return new AsyncResult<>("task3完成");
    }

}

创建一个测试类

import com.example.quartzdemo.service.AsyncService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion:
 */
@RestController
public class AsyncController {

    @Autowired
    private AsyncService asyncService;


    /**
     * 测试异步
     */
    @RequestMapping("/async")
    public String testAsync() throws InterruptedException, ExecutionException {
        long currentTimeMillis = System.currentTimeMillis();

        Future<String> task1 = asyncService.asyncTask1();
        Future<String> task2 = asyncService.asyncTask2();
        Future<String> task3 = asyncService.asyncTask3();
        while (true) {
            if (task1.isDone() && task2.isDone() && task3.isDone()) {
                // 三个任务都调用完成，退出循环等待
                break;
            }
        }
        System.out.println(task1.get());
        System.out.println(task2.get());
        System.out.println(task3.get());
        long currentTimeMillis1 = System.currentTimeMillis();
        return "task任务总耗时:" + (currentTimeMillis1 - currentTimeMillis) + "ms";
    }
}

执行测试方法

task1任务耗时:2006ms
task1任务耗时:3011ms
task1任务耗时:3011ms
task1完成
task2完成
task3完成

三、使用 TaskExecutor 实现异步任务

TaskExecutor 是 Spring 提供的一个接口，它定义了一个方法 execute()，用来执行异步任务。使用 TaskExecutor 需要满足以下条件：

  1. 需要在 Spring 配置文件中配置一个 TaskExecutor 实例；

  2. 在异步方法中调用 TaskExecutor 实例的 execute() 方法来执行异步任务。

创建一个异步配置类

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步处理配置类
 */
@Configuration
public class AsyncConfig implements AsyncConfigurer {

    @Bean(name = "asyncExecutor")
    public TaskExecutor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }

    @Override
    public Executor getAsyncExecutor() {
        return asyncExecutor();
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

修改下服务类，我们使用自定义的异步配置

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步服务类
 */
@Service
public class AsyncService {

    @Autowired
    @Qualifier("asyncExecutor")
    private TaskExecutor taskExecutor;


    /**
     * 同步任务操作1
     */
    public String task1() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成1";
    }

    /**
     * 同步任务操作2
     */
    public String task2() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        return "任务执行完成2";
    }

    /**
     * 同步任务操作3
     */
    public String task3() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成3";
    }


    /**
     * 异步操作1
     */
    @Async
    public void asyncTask1() {
        taskExecutor.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println("异步任务执行完成1");
    }

    /**
     * 异步操作2
     */
    @Async
    public void asyncTask2() throws InterruptedException {
        taskExecutor.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println("异步任务执行完成2");
    }

    /**
     * 异步操作3
     */
    @Async
    public void asyncTask3() throws InterruptedException {
        taskExecutor.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println("异步任务执行完成3");
    }
    
}

测试类进行测试

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步处理测试
 */
@SpringBootTest
public class AsyncTest {
    
    @Autowired
    @Qualifier("asyncExecutor")
    private TaskExecutor taskExecutor;


    @Test
    void test1() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();

        // 异步操作
       /* asyncService.asyncTask1();
        asyncService.asyncTask2();
        asyncService.asyncTask3();*/
        taskExecutor.execute(() -> System.out.println("异步任务"));

        // 同步操作
        /*System.out.println(asyncService.task1());
        System.out.println(asyncService.task2());
        System.out.println(asyncService.task3());*/

        stopWatch.stop();
        System.out.println("耗时:" + stopWatch.getTotalTimeMillis());
    }
}
耗时:6
异步任务执行完成3
异步任务执行完成1
异步任务执行完成2

SpringBoot中的异步调用
小软的博客
04-22 7636
有时候我们不止希望异步执行任务，还希望任务执行完成后会有一个返回值，在java中提供了Future泛型接口，用来接收任务执行结果，springboot也提供了此类支持，使用实现了ListenableFuture接口的类如AsyncResult来作为返回值的载体。是一个计数器，线程完成一个记录一个，计数器递减。有时候，根据需求需要制定一些多线程的。的计数器，有兴趣可以了解一下。
SpringBoot实现异步调用的方法
m0_74823892的博客
02-15 727
方法优点缺点。
SpringBoot之异步方法
qq_43654581的博客
04-28 9097
异步方法
详解Spring Boot 异步执行方法
08-27
主要介绍了Spring Boot 异步执行方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot异步调用方法
行知致简的专栏
04-23 7124
SpringBoot异步调用方法 一、spring boot--使用异步请求，提高系统的吞吐量 https://blog.youkuaiyun.com/liuchuanhong1/article/details/78744138 1.使用Callable来实现 2. 通过WebAsyncTask，也能实现异步调用 这种方式和上面的callable方式最大的区别就是，WebAsyncTask支持...
SpringBoot使用异步调用
xiao-啸
03-03 2083
SpringBoot使用异步调用
详解springboot中使用异步的常用两种方式及其比较
08-25
使用 @Async 注解的方式简单易用，但需要遵守一定的规则和限制，例如不能在本类中异步调用、不能有返回值等。 使用 CompletableFuture 的方式更加灵活，可以实现更加复杂的异步处理逻辑，但是需要手动处理异步任务...
Java 实现异步的几种方式
fei飞来了
07-24 1018
/ 核心线程数// 最大线程数// 队列大小// 线程前缀名每种方案的选择取决于具体的应用场景、复杂度和性能要求。简单的异步任务可能仅需使用Future和Callable，而复杂的异步流程控制和跨服务通信则可能更适合采用CompletableFuture或消息队列。
SpringBoot非官方教程 | 第二十三篇： 异步方法
晓风的博客
05-04 858
转载请标明出处： http://blog.youkuaiyun.com/forezp/article/details/71024169 本文出自方志朋的博客 这篇文章主要介绍在springboot 使用异步方法，去请求github api.创建工程在pom文件引入相关依赖： org.springframework.boot spring-boot-
SpringBoot：@Async实现异步方法调用
zp_zhang的博客
12-25 659
一，@Async注解     @Async是SprngBoot框架提供的框架内部已经整合好的异步调用方式。在入口处开启异步调用按钮，然后在调用方法上直接添加该注解，就可以自动实现异步调用。 二，异步发送类 package com.gupao.springboot.test.controller; import lombok.extern.slf4j.Slf4j; import org.s...
springboot 异步调用的实现方法
08-26
主要介绍了springboot 异步调用的实现方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解SpringBoot中异步请求和异步调用(看完这一篇就够了)
08-26
主要介绍了SpringBoot中异步请求和异步调用问题，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
spring boot中使用@Async实现异步调用任务
08-31
本篇文章主要介绍了spring boot中使用@Async实现异步调用任务，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring boot实现异步调用
weixin_34357887的博客
05-08 174
今天在这里学习下使用springboot的异步调用async 首先使用@EnableAsync开启异步功能 /** * @author fengzp * @date 17/5/8 * @email fengzp@gzyitop.com * @company 广州易站通计算机科技有限公司 */ @SpringBootApplication @EnableAsync public class ...
springboot 异步方法
weixin_43931625的博客
09-19 330
springboot 异步方法 作用：在一个方法内调用异步方法，原方法不阻塞继续运行，异步方法可异步执行 ************************************ 使用示例 *********************** 创建异步线程池 @Configuration @EnableAsync public class TaskExecutorC...
springboot异步方法
yonghutwo的专栏
12-02 246
方式一：main 方法 开启 @EnableAsync，方法上加 @Async 总结 1 使用了@Async的方法，会被当成是一个子线程，会在主线程执行完了之后执行， 可以看到 controller 先执行完成然后返回状态，接着 方法才开始执行。 2 同一个类中，一个方法调用另外一个有@Async的方法，注解是不会生效的！ 方式二：线程成开线程执行 @Autowired private ThreadPoolTaskScheduler threadPoolTaskScheduler; .
Springboot 异步的几种方法
最新发布
08-06
### 三级标题：使用 `@Async` 注解实现异步方法调用 Spring Boot 提供了 `@Async` 注解用于将方法标记为异步执行。通过在方法上添加该注解，可以实现非阻塞调用，提高并发处理能力。需要注意的是，异步方法必须是 `public` 且不能为 `final`，以确保 Spring AOP 能够生成代理对象[^1]。 ```java @Service public class AsyncService { @Async public void executeAsyncTask() { System.out.println("异步任务开始执行"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("异步任务执行完成"); } } ``` ### 三级标题：启用异步支持并配置线程池 为了激活 Spring 的异步任务执行功能，需要在主配置类或启动类上添加 `@EnableAsync` 注解。默认情况下，Spring 使用 `SimpleAsyncTaskExecutor`，但由于其线程不重用的特性，建议自定义线程池以提升性能和资源管理能力。可以通过实现 `AsyncConfigurerSupport` 接口并重写 `getAsyncExecutor` 方法来配置线程池[^1]。 ```java @Configuration @EnableAsync public class AsyncConfig extends AsyncConfigurerSupport { @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(5); executor.setMaxPoolSize(10); executor.setQueueCapacity(100); executor.setThreadNamePrefix("Custom-Async-Executor-"); executor.initialize(); return executor; } } ``` ### 三级标题：事件驱动的异步处理 Spring Boot 支持通过事件机制实现异步处理，适用于需要在不阻塞主线程的情况下执行后台任务的场景。通过发布和监听自定义事件，可以实现松耦合的异步通信[^3]。 ```java @Component public class AsyncEventHandler { @EventListener public void handleEvent(CustomEvent event) { System.out.println("事件内容: " + event.getMessage()); } } @Service public class EventPublisher { @Autowired private ApplicationEventPublisher eventPublisher; public void publishEvent(String message) { eventPublisher.publishEvent(new CustomEvent(this, message)); } } public class CustomEvent extends ApplicationEvent { private String message; public CustomEvent(Object source, String message) { super(source); this.message = message; } public String getMessage() { return message; } } ``` ### 三级标题：响应式编程实现异步非阻塞处理 对于需要非阻塞 I/O 的场景，可以使用 Spring WebFlux 实现响应式异步处理。通过返回 `Mono` 或 `Flux` 类型，可以构建高性能的异步响应式应用，适用于高并发和流式数据处理[^2]。 ```java @RestController public class ReactiveController { @GetMapping("/reactive") public Mono<String> reactiveMethod() { return Mono.fromSupplier(() -> { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } return "响应式异步任务完成"; }); } } ``` ### 三级标题：异步调用外部服务 在异步调用外部服务的场景中，可以使用 `WebClient` 实现非阻塞 HTTP 请求。`WebClient` 是 Spring WebFlux 提供的响应式客户端，适用于高并发环境下的异步远程调用[^3]。 ```java @Configuration public class WebClientConfig { @Bean public WebClient webClient() { return WebClient.builder() .baseUrl("https://api.example.com") .build(); } } @Service public class WebService { @Autowired private WebClient webClient; public void fetchData() { webClient.get() .uri("/data") .retrieve() .bodyToMono(String.class) .subscribe(response -> System.out.println("响应数据: " + response)); } } ``` ### 三级标题：异步任务异常处理 异步任务中的异常处理需要特别注意，可以通过实现 `AsyncConfigurerSupport` 并重写 `getAsyncUncaughtExceptionHandler` 方法来定义全局异常处理器。这样可以确保异步任务中的异常能够被正确捕获和处理[^2]。 ```java @Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { return new AsyncUncaughtExceptionHandler() { @Override public void handleUncaughtException(Throwable ex, Method method, Object... params) { System.err.println("发生异常的方法: " + method.getName()); System.err.println("异常信息: " + ex.getMessage()); } }; } ``` ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qinxun2008081

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值