SpingBoot异步执行

最新推荐文章于 2023-05-16 09:17:38 发布
最新推荐文章于 2023-05-16 09:17:38 发布
阅读量159 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xzh109/article/details/104005467
版权

异步任务常用场景

  • 发送消息
  • 发送邮件
  • App消息推送
  • 节省运维凌晨发布任务时间提供效率

示例：
springboot启动类加上@EnableAsync注解，异步线程任务开关
异步任务：

@Component
public class TestAsyncTask {

    @Async
    public Future<String> doTask1() throws Exception {
        long start = System.currentTimeMillis();
        Thread.sleep(1000);
        long end = System.currentTimeMillis();
        System.out.println("任务 1 耗时：" + (end - start) + " ms");
        return new AsyncResult<>("666");
    }

    @Async
    public Future<String> doTask2() throws Exception {
        long start = System.currentTimeMillis();
        Thread.sleep(800);
        long end = System.currentTimeMillis();
        System.out.println("任务 2 耗时：" + (end - start) + " ms");
        return new AsyncResult<>("666");
    }

    @Async
    public Future<String> doTask3() throws Exception {
        long start = System.currentTimeMillis();
        Thread.sleep(600);
        long end = System.currentTimeMillis();
        System.out.println("任务 3 耗时：" + (end - start) + " ms");
        return new AsyncResult<>("666");
    }
}

执行异步任务

@RestController
@RequestMapping("task")
public class DoTask {

    @Autowired
    private TestAsyncTask asyncTask;

    @RequestMapping("testAsync")
    public String execAsyncTask() throws Exception {

        long start = System.currentTimeMillis();

        Future<String> a = asyncTask.doTask1();
        Future<String> b = asyncTask.doTask2();
        Future<String> c = asyncTask.doTask3();

        while (true) {
            if (a.isDone() && b.isDone() && c.isDone()) {
                break;
            }
        }

        long end = System.currentTimeMillis();

        String times = "任务全部完成，总耗时：" + (end - start) + " ms";
        System.out.println(times);
        System.out.println(a);
        return times;
    }
}

输出结果
是大多数
异步执行用时少于同步执行

异步方法与同步方法执行过程
TestService

@Service
public class TestService {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Async
    public void asyncMethod() {
        sleep();
        logger.info("异步方法内部线程名称：{}", Thread.currentThread().getName());
    }

    public void syncMethod() {
        sleep();
    }

    private void sleep() {
        try {
            logger.info("睡眠开始");
            TimeUnit.SECONDS.sleep(2);
            logger.info("睡眠结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

TestController

@RestController
public class TestController {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private TestService testService;

    @GetMapping("async")
    public void testAsync() {
        long start = System.currentTimeMillis();
        logger.info("异步方法开始");

        testService.asyncMethod();

        logger.info("异步方法结束");
        long end = System.currentTimeMillis();
        logger.info("总耗时：{} ms", end - start);
    }

    @GetMapping("sync")
    public void testSync() {
        long start = System.currentTimeMillis();
        logger.info("同步方法开始");

        testService.syncMethod();

        logger.info("同步方法结束");
        long end = System.currentTimeMillis();
        logger.info("总耗时：{} ms", end - start);
    }
}

访问http://localhost:8080/async同步执行结果：

15:29:44.559  INFO 5476 --- [nio-8080-exec-1] c.e.demo.controller.TestController       : 同步方法开始
15:29:44.577  INFO 5476 --- [nio-8080-exec-1] com.example.demo.service.TestService     : 睡眠开始
15:29:46.579  INFO 5476 --- [nio-8080-exec-1] com.example.demo.service.TestService     : 睡眠结束
15:29:46.580  INFO 5476 --- [nio-8080-exec-1] c.e.demo.controller.TestController       : 同步方法结束
15:29:46.580  INFO 5476 --- [nio-8080-exec-1] c.e.demo.controller.TestController       : 总耗时：2021 ms

访问http://localhost:8080/sync，异步执行结果

15:29:58.169  INFO 5476 --- [nio-8080-exec-3] c.e.demo.controller.TestController       : 异步方法开始
15:29:58.186  INFO 5476 --- [nio-8080-exec-3] c.e.demo.controller.TestController       : 异步方法结束
15:29:58.187  INFO 5476 --- [nio-8080-exec-3] c.e.demo.controller.TestController       : 总耗时：18 ms
15:29:58.195  INFO 5476 --- [         task-1] com.example.demo.service.TestService     : 睡眠开始
15:30:00.196  INFO 5476 --- [         task-1] com.example.demo.service.TestService     : 睡眠结束
15:30:00.196  INFO 5476 --- [         task-1] com.example.demo.service.TestService     : 异步方法内部线程名称：task-1

弊端：每次执行异步任务都需要新建一个线程。每次线程的创建与销毁会造成不必要的开销。可使用自定义线程池

添加线程池配置类
@Configuration
public class AsyncPoolConfig {

    @Bean
    public ThreadPoolTaskExecutor asyncThreadPoolTaskExecutor(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程数，默认为1
        executor.setCorePoolSize(20);
        //线程池最大线程数。只有当核心线程都被用完并且缓冲队列满后，才会开始申超过请核心线程数的线程，默认值为Integer.MAX_VALUE
        executor.setMaxPoolSize(200);
        //缓冲队列
        executor.setQueueCapacity(25);
        //超出核心线程数的线程的空闲时候的最大存活时间
        executor.setKeepAliveSeconds(200);
        //线程名字前缀
        executor.setThreadNamePrefix("asyncThread");
        //是否等待全部线程执行完毕才关闭线程池。默认false
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //setWaitForTasksToCompleteOnShutdown的等待时长，默认为0，不等待
        executor.setAwaitTerminationSeconds(60);
        //线程的处理策略 默认为abortPolicy
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        executor.initialize();
        return executor;
    }
}

修改TestService
@async加上线程池名称
@Async("asyncThreadPoolTaskExecutor")
再次运行http://localhost:8080/async ，结果：

15:45:56.975  INFO 1340 --- [nio-8080-exec-1] c.e.demo.controller.TestController       : 异步方法开始
15:45:56.987  INFO 1340 --- [nio-8080-exec-1] c.e.demo.controller.TestController       : 异步方法结束
15:45:56.988  INFO 1340 --- [nio-8080-exec-1] c.e.demo.controller.TestController       : 总耗时：12 ms
15:45:57.003  INFO 1340 --- [   asyncThread1] com.example.demo.service.TestService     : 睡眠开始
15:45:59.005  INFO 1340 --- [   asyncThread1] com.example.demo.service.TestService     : 睡眠结束
15:45:59.005  INFO 1340 --- [   asyncThread1] com.example.demo.service.TestService     : 异步方法内部线程名称：asyncThread1

异步回调

若异步方法有返回值，可使用Future接收回调值

@Async("asyncThreadPoolTaskExecutor")
public Future<String> asyncMethod() {
    sleep();
    logger.info("异步方法内部线程名称：{}", Thread.currentThread().getName());
    return new AsyncResult<>("hello async");
}

AsyncResult为Spring实现的Future实现类
在这里插入图片描述

@GetMapping("async")
public String testAsync() throws Exception {
    long start = System.currentTimeMillis();
    logger.info("异步方法开始");

    Future<String> stringFuture = testService.asyncMethod();
    String result = stringFuture.get();
    logger.info("异步方法返回值：{}", result);
    
    logger.info("异步方法结束");

    long end = System.currentTimeMillis();
    logger.info("总耗时：{} ms", end - start);
    return stringFuture.get();
}

通过future的get方法获取异步调用的返回值

在这里插入图片描述
通过返回结果我们可以看出Future的get方法为阻塞方法，只有当异步方法返回内容了，程序才会继续往下执行。get还有一个get(long timeout, TimeUnit unit)重载方法，我们可以通过这个重载方法设置超时时间，即异步方法在设定时间内没有返回值的话，直接抛出java.util.concurrent.TimeoutException异常。
比如设置超时时间为60秒：
String result = stringFuture.get(60, TimeUnit.SECONDS);

_zh@xia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解SpringBoot中异步请求和异步调用(看完这一篇就够了)
08-26
主要介绍了SpringBoot中异步请求和异步调用问题，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
SpringBoot使用异步调用
xiao-啸
03-03 1529
SpringBoot使用异步调用
springBoot异步执行方法@Async
liuhao0610的博客
09-15 234
@Async是在有一些耗时比较长的方法需要使用异步调用 步骤 1.在spring boot的启动类上标注@EnableAsync（扫描到就行） 2.建一个异步处理的类 @Component public class AsyncTest { @Async public void asyncTest(){ try { Thread.sleep(5000); } catch (InterruptedException e) {
SpringBoot异步执行
Mr_chen的博客
11-20 291
SpringBoot异步执行 前言（异步执行的引入） 案例github地址（如果有用点个star呗） https://github.com/chenxiban/SpringBoot-Asyn.git 通常情况下，用户在对我们服务器发送请求获取结果时，其实并不关心我们服务器端是如何处理的，而只关 心是否能快速获取结果（例：比如我们在淘宝提交一个订单，这时我们只会关心订单有没有快速的提交成 功，并...
SpringBoot项目里，如何做异步计算，异步计算超时和异常处理？
Alex抱着爆米花的博客
03-01 525
SpringBoot项目里，如何做异步计算，异步计算超时和异常处理？
springboot 异步调用的实现方法
08-26
Spring Boot 框架提供了多种方式来实现异步调用，异步调用是指在程序执行时无需等待执行的返回值可继续执行后面的代码，提高了执行效率。下面将详细介绍 Spring Boot异步调用的实现方法。 1. 同步调用 vs 异步调用 ...
SpringBoot异步
05-28
- **@Async注解**：用于标记一个方法为异步执行。被注解的方法会由Spring的TaskExecutor执行，而不是由调用它的线程执行。 3. **配置异步处理** 在Spring Boot应用中，可以通过`@EnableAsync`注解开启异步支持，...
SpringBoot异步任务使用方法详解
08-19
SpringBoot异步任务使用方法详解 SpringBoot异步任务使用方法详解是基于Java的SpringBoot框架中的一种异步任务处理机制。该机制允许开发者在SpringBoot应用程序中执行异步任务，以提高应用程序的性能和响应速度。 ...
Springboot中异步
01-06
个人看法：我们不使用springboot异步，也可以实现异步，但这时我们自己要建立一个全局的线程池，在调用方法时，还要使用新线程包装一下。这样最终效果虽一样，但过程要麻烦些，后面维护也麻烦些。所以推荐使用...
SpringBoot异步方法捕捉异常详解
08-25
`@EnableAsync`在配置类上启用异步方法的支持，而`@Async`则标记在我们希望异步执行的方法上。 在没有返回值的异步方法中，我们可以自定义一个异常捕获配置类，如`AsyncExceptionConfig`，并实现`AsyncConfigurer`...
Spring Boot 之异步执行方法
WANGXIAN2014的博客
09-20 157
前言： 最近的时候遇到一个需求，就是当服务器接到请求并不需要任务执行完成才返回结果，可以立即返回结果，让任务异步的去执行。开始考虑是直接启一个新的线程去执行任务或者把任务提交到一个线程池去执行，这两种方法都是可以的。但是Spring 这么强大，肯定有什么更简单的方法，就 google 了一下，还真有呢。就是使用 @EnableAsync 和 @Async 这两个注解就 ok 了。 ...
SpringBoot（十三）异步任务
m0_65992672的博客
04-28 3744
SpringBoot（十三）异步任务
ThreadPoolTaskExecutor线程池和@Async异步执行
鞠晓健
12-14 3480
ThreadPoolExecutor
SpringBoot 8种异步实现方式
huang714的专栏
05-16 7121
首先先看一个常见的用户下单的场景：什么是异步？在同步操作中，执行到发送短信的时候，我们必须等待这个方法彻底执行完才能执行赠送积分这个操作，如果赠送积分这个动作执行时间较长，发送短信需要等待，这就是典型的同步场景。实际上，发送短信和赠送积分没有任何的依赖关系，通过异步，我们可以实现赠送积分和发送短信这两个操作能够同时进行，比如：这就是所谓的异步，是不是非常简单，下面就说说异步的几种实现方式吧。/**
Spring Boot线程池：@Async和ThreadPoolTaskExecutor的使用和区别
weixin_46485607的博客
04-19 1610
线程池
springboot执行异步任务
weixin_61503139的博客
03-24 664
java异步执行业务
SpringBoot 如何异步编程，老鸟们都这么玩的
飘渺Jam的博客
12-01 2938
大家好，我是飘渺。今天继续给大家带来SpringBoot老鸟系列的第六篇，来聊聊在SpringBoot项目中如何实现异步编程。 老鸟系列文章导读： 1. SpringBoot 如何统一后端返回格式？老鸟们都是这样玩的！ 2. SpringBoot 如何进行参数校验？老鸟们都是这么玩的！ 3. SpringBoot 如何生成接口文档，老鸟们都这么玩的！ 4. SpringBoot 如何进行对象复制，老鸟们都这么玩的！ 5. SpringBoot 生成接口文档，我用smart-doc 6. SpringBoot
springboot异步执行
最新发布
09-02
在Spring Boot中，您可以通过使用异步执行来提高应用程序的性能和响应能力。Spring Boot提供了多种方式来实现异步执行，下面是其中几种常用的方法： 1. 使用@Async注解：在Spring Boot中，可以使用@Async注解将方法标记为异步执行。首先，在主类上添加@EnableAsync注解以启用异步执行功能。然后，在需要异步执行的方法上添加@Async注解。这样，当调用该方法时，Spring会将其放入线程池中并立即返回，而不会阻塞主线程。 ```java @SpringBootApplication @EnableAsync public class YourApplication { public static void main(String[] args) { SpringApplication.run(YourApplication.class, args); } } ``` ```java @Service public class YourService { @Async public void yourAsyncMethod() { // 异步执行的逻辑 } } ``` 2. 使用CompletableFuture：CompletableFuture是Java 8中引入的一个异步编程工具类，可以很方便地实现异步执行。在Spring Boot中，您可以将CompletableFuture与@Async一起使用来实现异步执行。 ```java @Service public class YourService { @Async public CompletableFuture<Result> yourAsyncMethod() { // 异步执行的逻辑 return CompletableFuture.completedFuture(result); } } ``` 3. 使用ThreadPoolTaskExecutor：如果您需要更多的控制权，您可以自定义一个ThreadPoolTaskExecutor来管理异步任务的线程池。在应用程序配置文件中进行配置，然后在需要异步执行的方法上使用@Async注解。 ```java @Configuration @EnableAsync public class AsyncConfig implements AsyncConfigurer { @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(10); executor.setMaxPoolSize(20); executor.setQueueCapacity(30); executor.initialize(); return executor; } } ``` ```java @Service public class YourService { @Async public void yourAsyncMethod() { // 异步执行的逻辑 } } ``` 通过以上方法，您可以在Spring Boot应用程序中实现异步执行，并提升应用程序的性能和响应能力。请根据您的具体需求选择适合的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值