SpringBoot 集成异步调用Async

最新推荐文章于 2024-09-15 09:47:04 发布
最新推荐文章于 2024-09-15 09:47:04 发布
阅读量88 收藏
点赞数
文章标签： java 测试
原文链接：https://my.oschina.net/sdlvzg/blog/1594632
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

什么是”异步调用”与”同步调用”

“同步调用”就是程序按照一定的顺序依次执行，，每一行程序代码必须等上一行代码执行完毕才能执行；”异步调用”则是只要上一行代码执行，无需等待结果的返回就开始执行本身任务。 
通常情况下，”同步调用”执行程序所花费的时间比较多，执行效率比较差。所以，在代码本身不存在依赖关系的话，我们可以考虑通过”异步调用”的方式来并发执行。

下面通过两个简单的案例向大家介绍一个同步调用与异步调用的不同，编写下代码时必须先创建一个Maven项目，并引入spring-boot-starter-web，SpringBoot版本为1.5.9.

同步调用

定义Task类，创建三个处理函数分别模拟三个执行任务的操作

package org.lvgang;

import org.springframework.stereotype.Component;

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

创建Controller进行测试

package org.lvgang;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

创建SpringBoot启动类

package org.lvgang;

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

/**
 * SpringBoot Main
 */
@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

运行结果

    启动项目之后，在浏览器中访问以下联接：http://localhost:8080/task

    控制台输出

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

    浏览器输出

        task任务总耗时:6001ms

    通过输入的信息可以看出task1,task2,task3是顺序的执行完了

异步调用

定义Task类，创建三个处理函数分别模拟三个执行任务的操作

package org.lvgang;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@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");
    }
}

在Spring Boot中，我们只需要通过使用@Async注解就能简单的将原来的同步函数变为异步函数

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

创建Controller进行测试

package org.lvgang;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("asynctask")
public class AsyncTaskController {

    @Autowired  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";
    }


}

创建SpringBoot启动类

package org.lvgang;

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

/**
 * SpringBoot Main
 */
@SpringBootApplication
@EnableAsync
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

为了让@Async注解能够生效，还需要在Spring Boot的主程序中配置@EnableAsync

运行结果

    启动项目之后，在浏览器中访问以下联接：http://localhost:8080/asynctask

    控制台输出

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

    浏览器输出

        task任务总耗时:4ms

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

    此时可以反复执行单元测试，您可能会遇到各种不同的结果，比如：

  • 没有任何任务相关的输出
  • 有部分任务相关的输出
  • 乱序的任务相关的输出

异步回调

为了让task1,task2,task3能正常结束，假设我们需要统计一下三个任务并发执行共耗时多少，这就需要等到上述三个函数都完成调动之后记录时间，并计算结果。

那么我们如何判断上述三个异步调用是否已经执行完成呢？我们需要使用Future<T>来返回异步调用的结果，就像如下方式改造task1,task2,task3函数：

package org.lvgang;

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

import java.util.concurrent.Future;

@Component
public class FutureAsyncTask {

    @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("task2任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
        return   new AsyncResult<String>("task3任务完成");
    }
}

创建Controller进行测试

package org.lvgang;

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.Future;

@RestController
@RequestMapping("futureasynctask")
public class FutureAsyncTaskController {

    @Autowired  FutureAsyncTask futureAsyncTask;
    @RequestMapping("")
    public String doTask() throws InterruptedException{
        long currentTimeMillis = System.currentTimeMillis();
        Future<String> task1 = futureAsyncTask.task1();
        Future<String> task2 = futureAsyncTask.task2();
        Future<String> task3 = futureAsyncTask.task3();

        while(true) {
            if(task1.isDone() && task2.isDone() && task3.isDone()) {
                // 三个任务都调用完成，退出循环等待
                break;
            }
            Thread.sleep(1000);
        }

        long currentTimeMillis1 = System.currentTimeMillis();
        return "task任务总耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms";
    }
}

运行结果

    启动项目之后，在浏览器中访问以下联接：http://localhost:8080/futureasynctask

    控制台输出

        task1任务耗时:1000ms
        task2任务耗时:2000ms
        task2任务耗时:3000ms

    浏览器输出

        task任务总耗时:4003ms

可以看到，通过异步调用，让任务一、二、三并发执行，有效的减少了程序的总运行时间，并完可以看到三个任务都已经完成，并返回了结果。

转载于:https://my.oschina.net/sdlvzg/blog/1594632

weixin_33871366
关注
actuator与spring-core依赖冲突问题
qq_41336791的博客
07-24 1223
Error starting ApplicationContext. To display the conditions report re-run your application with ‘debug’ enabled. 2020-07-24 13:23:47.176 ERROR 10256 — [ restartedMain] o.s.b.d.LoggingFailureAnalysisReporter : APPLICATION FAILED TO START Description:
彻底弄懂Spring Schedule加载和执行流程
前往JAVA架构的路上
06-24 4137
Spring Scheduled Spring定时任务源码分析 入口，启用定时任务注解 @EnableScheduling @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Import(SchedulingConfiguration.class) @Documented public @interface EnableScheduling { } org.springframework.scheduling.annotat
org.springframework.scheduling.annotation.EnableAsync
CarloPan的博客
01-03 849
org.springframework.scheduling.annotation.EnableAsync @Import(value={AsyncConfigurationSelector.class}) @Target(value={TYPE}) @Retention(value=RUNTIME) @Documented # capability： 才能，能力; 容量; 性能; 生产率; # execution: 执行，执行命令; 成功，奏效，效果; # asynchronous：异步的; ...
已解决org.springframework.web.method.annotation.MethodArgumentTypeMismatchException异常的正确解决方法，亲测有效！！！
小明的Java问道之路
02-10 4427
已解决org.springframework.web.method.annotation.MethodArgumentTypeMismatchException异常的正确解决方法，亲测有效！！！
细数Spring Boot 中容易中招的那些坑
极客星云-CSDN博客
02-18 5000
本篇博文会不时整理总结更新Spring Boot 学习和开发中遇到的一些坑，并提供出解决方案，希望可以帮到不小心落入深坑的你。 0x00 No Beans of ‘XXXProperties’ type found 解决方案: 添加 @Component 注解实体类即可 0x01 Spring Boot Configuration Annotation Processor...
Spring Boot集成教程之异步调用Async
08-27
总结起来，Spring Boot的异步调用功能通过`@Async`注解提供了一种简单且高效的方式来并行执行任务，避免了因为单一耗时操作导致的阻塞。它利用了Spring的并发支持，如线程池，使得开发者无需直接处理多线程的复杂性...
grpc-java springboot 同步异步调用 demo
卤小蛋学编程
03-21 2444
近期学习 grpc-java，从 demo 入手，进行学习 grpc 的基础知识暂不整理，后续有时间再整理一波，这一篇主要是记录一个简单的 grpc 使用 springboot 创建的 demo。 我整个 demo 分成三个 Project ： grpc-springboot-demo-api：用于存放 proto 文件 grpc-springboot-demo-server：服务端编码 grpc-springboot-demo-consumer：客户端编码 demo-api（proto） 创建一个.
springboot整合dubbo实现异步调用
weixin_47534571的博客
10-26 1390
springboot整合dubbo实现异步调用一 provider端二 consumer端三 结果 一 provider端 与正常dobbu使用一样,只是设置service属性async=ture @Service(version = "1.0",group = "hehe",async = true) public class UserServiceImpl implements UserService { @Override public String test1() {
Springboot集成Async异步调用
zhutian0991的博客
03-24 388
前言 在业务开发过程中，有时会遇到非核心的业务，如记录日志或发送短信等。有时也会遇到一次性要处理多个任务，再将多个任务处理结果进行返回。如果做同步处理时，会比较耗时，对于接口而言，响应速度慢一方面会影响用户体验，另一方面如果是服务间调用，可能会出现超时的情况。这种情况我们可以采用异步处理的方式，提高主流程的性能。 集成方法 1、springboot启动类添加@EnableAsync注解 @SpringBootApplication @EnableAsync public class Application
springboot中异步线程调用问题
沐宇熙IT成长之路
01-31 1万+
1.原始线程总结 我们在使用多线程的时候，往往需要创建Thread类，或者实现Runnable接口，如果要使用到线程池，我们还需要来创建Executors。 2.spring线程 只要要@EnableAsync就可以使用多线程。使用@Async就可以定义一个线程任务。通过spring给我们提供的ThreadPoolTaskExecutor就可以使用线程池。 3.使用 3.1 新建spri...
The method‘s class, org.springframework.beans.factory.config.ConfigurableListableBeanFactory,
道阻且长,行则将至 行而不辍,未来可期
02-25 3167
前言 The method's class, org.springframework.beans.factory.config.ConfigurableListableBeanFactory, is available from the following locations: jar:file:/D:/work/Mavenrepo/org/springframework/spring-beans/5.1.8.RELEASE/spring-beans-5.1.8.RELEASE.jar!/or...
关于应用集成：同步与异步通信模式之间的比较
weixin_33860147的博客
04-19 251
什么是应用集成？ 应用集成（或企业应用集成）是指在企业IT环境中，对来自不同应用程序之间的流程和数据共享的能力。对于各种规模的企业，应用集成已成为连接各类不同的应用程序，实现他们之间的相互协作，从而帮助企业内部提高整体业务效率，增强可扩展性，降低IT成本的关键能力。 但是，在构建应用集成解决方案之前，了解不同的集成层次，尤其是在应用集成环境中如何交换消息（即数据）是至关重要的。本文概述了从高到低四...
spring boot--使用异步请求，提高系统的吞吐量
牛奋lch
12-07 2万+
前言： 在我们的实际生产中，常常会遇到下面的这种情况，某个请求非常耗时(大约5s返回)，当大量的访问该请求的时候，再请求其他服务时，会造成没有连接使用的情况，造成这种现象的主要原因是，我们的容器(tomcat)中线程的数量是一定的，例如500个，当这500个线程都用来请求服务的时候，再有请求进来，就没有多余的连接可用了，只能拒绝连接。要是我们在请求耗时服务的时候，能够异步请求(请求到contro
Spring Boot使用@Async实现异步调用
我的博客
06-10 526
1. Spring Boot使用@Async实现异步调用 链接:#link 原文：http://blog.csdn.net/a286352250/article/details/53157822 项目GitHub地址 ： https://github.com/FrameReserve/TrainingBoot Spring Boot（十）使用@Async实现异步调用 ，标记地址： https://...
谨慎使用Spring 配置标签之任务配置标签
enumlin
04-25 2491
1.导火线最近都会规律的收到阿里云预警的短信报警，于是，对线上的服务进行了健康度排查，至于排查的方法或者过程不是这里讨论的重点，需要知道的小伙子们，可以看看沈剑和李彦鹏大神的一些干货。这里就不多说了，经过一些列的排查得到的结论是，我们的服务器在一些业务高发的时间段不断的创建/销毁线程，导致内存和CUP的使用率非常的嗨！2.定位问题经过上面得到的信息进行分析，发现既然是一个小问题影响的，真是悔不当初...
spring boot-执行Async任务时，使用自定义的线程池
热门推荐
牛奋lch
03-20 3万+
在前面的博客中，http://blog.csdn.net/liuchuanhong1/article/details/54605697 我们使用了spring boot的异步操作，当时，我们使用的是默认的线程池，但是，如果我们想根据项目来定制自己的线程池了，下面就来说说，如何定制线程池！ 一、增加配置属性类 package com.chhliu.springboot.async.con...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1124
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 179
");
Spring Boot异步调用@Async实战教程
在Spring Boot集成教程中，异步调用Async功能对于提升应用程序性能和用户体验至关重要。当我们遇到项目中的耗时操作，如网络请求、数据库查询或复杂的计算任务，如果这些操作阻塞了主线程，会导致应用程序响应变慢。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值