Java原生方式和使用@Async注解方式实现多线程异步回调

最新推荐文章于 2024-08-16 11:23:16 发布
最新推荐文章于 2024-08-16 11:23:16 发布
阅读量2.6k 收藏 6
点赞数 1
分类专栏： Java 文章标签： java spring boot spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44749491/article/details/126808156
版权

多线程异步回调技术

一、任务代码

1.1 需要执行的任务类

@Component
public class Task {

    public String doTaskOne() throws Exception {
        long start = System.currentTimeMillis();
        Thread.sleep(1000);
        long end = System.currentTimeMillis();
        System.out.println("任务一耗时：" + (end - start) + "毫秒");
        return "任务一的执行结果";
    }

    public String doTaskTwo() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread.sleep(2000);
        long end = System.currentTimeMillis();
        System.out.println("任务二耗时：" + (end - start) + "毫秒");
        return "任务二的执行结果";
    }

    public String doTaskThree() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread.sleep(3000);
        long end = System.currentTimeMillis();
        System.out.println("任务三耗时：" + (end - start) + "毫秒");
        return "任务三的执行结果";
    }

    public String doTaskFour() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread.sleep(4000);
        long end = System.currentTimeMillis();
        System.out.println("任务四耗时：" + (end - start) + "毫秒");
        return "任务四的执行结果";
    }
}

1.2 执行任务的业务类

@Service
public class TaskServiceImpl implements ITaskService {

    @Autowired
    private Task task;
    
    public Map<String, Object> doTaskMethod() throws Exception { 
        //执行任务
        String taskOneResult = task.doTaskOne();
        String taskTwoResult = task.doTaskTwo();
        String taskThreeResult = task.doTaskThree();
        String taskFourResult = task.doTaskFour();
        //返回结果集
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("taskOneResult", taskOneResult);
        resultMap.put("taskTwoResult", taskTwoResult);
        resultMap.put("taskThreeResult", taskThreeResult);
        resultMap.put("taskFourResult", taskFourResult);
        return resultMap;
    }
}

1.3 测试入口(基于SpringBoot)

@SpringBootTest(classes = {Application.class})
public class TestThread {

    @Autowired
    private TaskServiceImpl taskService;

    @Test
    public void test() Exception {
        long start = System.currentTimeMillis();
        Map<String, Object> result = taskService.doTaskMethod();
        long end = System.currentTimeMillis();
        System.out.println("任务总耗时：" + (end - start) + "毫秒");
        System.out.println("执行结果为：");
        System.out.println(result);
    }

}

测试入口的代码五轮使用哪种方式都无需改造。

执行结果如下：

在这里插入图片描述

发现执行四个任务需要的时间为10秒钟，因为所有任务都是依次执行。

平常业务开发中可能经常遇见这种情况，导致查询接口执行特别慢。

我们可以使用多线程异步回调的技术来优化代码，在无法优化sql语句时提升查询性能。

二、原生Java方式

2.1 使用jdk8新增的CompletableFuture类来优化上面的代码

@Service
public class TaskServiceImpl {

    @Autowired
    private Task task;

    public Map<String, Object> doTaskMethod() throws Exception {
        //创建四个CompletableFuture对象，并把四个多线程任务作为参数传递进去
        CompletableFuture<String> completableFutureOne = CompletableFuture.supplyAsync(
        () -> {
            String taskResult = null;
            try {
                taskResult = task.doTaskOne();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return taskResult;
        });

        CompletableFuture<String> completableFutureTwo = CompletableFuture.supplyAsync(
        () -> {
            String taskResult = null;
            try {
                taskResult = task.doTaskTwo();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return taskResult;
        });

        CompletableFuture<String> completableFutureThree = CompletableFuture.supplyAsync(
        () -> {
            String taskResult = null;
            try {
                taskResult = task.doTaskThree();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return taskResult;
        });

        CompletableFuture<String> completableFutureFour = CompletableFuture.supplyAsync(
        () -> {
            String taskResult = null;
            try {
                taskResult = task.doTaskFour();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return taskResult;
        });

        //依次获得任务的执行结果  并返回结果集
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("taskOneResult", CompletableFutureOne.get());
        resultMap.put("taskTwoResult", CompletableFutureTwo.get());
        resultMap.put("taskThreeResult", CompletableFutureThree.get());
        resultMap.put("taskFourResult", CompletableFutureFour.get());

        //如果不考虑获取各任务返回结果，只需要四个异步任务执行完毕即可的话。可以使用如下代码
        //join()必须要写，它可以让线程阻塞在这，等待四个任务都执行完毕
        //要不然任务都没执行完就return resultMap了
        //CompletableFuture.allOf(task1,task2,task3,task4).join();
        
        return resultMap;
    }

}
api解释：

1) 关于lambda表达式创建多线程的解释

创建一个多线程可以使用如下lambda表达式的方式：

Runnable runnable = () -> System.out.println("任务的执行结果");

这个表达式就相当于创建了一个Runnable接口的实现类。->右侧就是run方法的内容。

2) 关于CompletableFuture的解释

字面意思就是可完成的Future。主要是为了解决jdk8之前的Future类带来的弊端。

3) 关于CompletableFuture.supplyAsync()的解释

supplyAsync方法用于创建一个CompletableFuture对象，它的参数接收一个Supplier函数式接口。

该方法创建的CompletableFuture对象会异步执行当前传入的计算任务。

在调用端，可以通过get或join获取任务执行的结果。

4) 关于CompletableFutureOne.get()的解释

可以获取CompletableFuture对象中异步任务的执行结果。

5) 关于CompletableFutureOne.allOf()的解释

异步执行参数里面的异步任务。

6)join()的作用

它可以让线程阻塞在这，等待allOf中的任务都执行完毕

2.2 执行结果

在这里插入图片描述

使用多线程加上CompletableFuture优化后，任务的执行的总时间几乎和任务四的执行时间一致。

大大缩短了任务执行的时间。

同时也能依次获取到异步任务的结果。可以说是非常厉害了。

但是发现上面的代码还是比较的冗余。有没有办法再优化一下。

二、SpringBoot+@Async方式

2.1 开启@Async支持

在SpringBoot启动类上加@EnableAsync注解开启@Async支持

@SpringBootApplication
@EnableAsync
public class Application {

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

}

2.2 改造Task类

@Component
public class Task {

    @Async
    public CompletableFuture doTaskOne() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread.sleep(1000);
        long end = System.currentTimeMillis();
        System.out.println("任务一耗时：" + (end - start) + "毫秒");
        return CompletableFuture.completedFuture("任务一的执行结果");
    }

    @Async
    public CompletableFuture doTaskTwo() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread.sleep(2000);
        long end = System.currentTimeMillis();
        System.out.println("任务二耗时：" + (end - start) + "毫秒");
        return CompletableFuture.completedFuture("任务二的执行结果");
    }

    @Async
    public CompletableFuture doTaskThree() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread.sleep(3000);
        long end = System.currentTimeMillis();
        System.out.println("任务三耗时：" + (end - start) + "毫秒");
        return CompletableFuture.completedFuture("任务三的执行结果");
    }

    @Async
    public CompletableFuture doTaskFour() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread.sleep(4000);
        long end = System.currentTimeMillis();
        System.out.println("任务四耗时：" + (end - start) + "毫秒");
        return CompletableFuture.completedFuture("任务四的执行结果");
    }
}
api解释：

1) 关于@Async

@Async注解能将原来的同步方法变为异步方法。

2) 关于CompletableFuture.completedFuture的解释

completedFuture方法是一个静态方法，作用也是创建一个CompletableFuture对象。

源码如下：

public static <U> CompletableFuture<U> completedFuture(U value) {
return new CompletableFuture<U>((value == null) ? NIL : value);
}

2.3 改造TaskServiceImpl

@Service
public class TaskServiceImpl {

    @Autowired
    private Task task;

    public Map<String, Object> doTaskMethod() throws Exception {
        //执行任务
        CompletableFuture completableFutureOne = task.doTaskOne();
        CompletableFuture completableFutureTwo = task.doTaskTwo();
        CompletableFuture completableFutureThree = task.doTaskThree();
        CompletableFuture completableFutureFour = task.doTaskFour();

        //返回结果集
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("taskOneResult", completableFutureOne.get());
        resultMap.put("taskTwoResult", completableFutureTwo.get());
        resultMap.put("taskThreeResult", completableFutureThree.get());
        resultMap.put("taskFourResult", completableFutureFour.get());

        return resultMap;
    }
}

此时doTaskMethod中就已经清爽很多了。

2.4 执行结果

在这里插入图片描述

发现依旧保持了异步任务的高性能，又让代码更加简洁。还能获取到异步任务的结果。

但是大量使用这种异步任务，对服务器的要求是比较高的。

所以开发中并不需要把所有任务都写成这个样子。

只需要对和上面这些情况类似的情况，就可以使用异步回调的方式来优化。

流水武qin
关注
专栏目录
async/await解决回调函数
YY的博客
11-18 766
async/await解决回调函数
springboot中@Async多线程注解使用
背景模版
07-02 1万+
在没有@Async注解之前我们需要写一个多线程低吗的话需要使用到JDK原生的多线程方法，代码十分冗余，当有了spring的@Async注解后就十分方便了，本次就详细介绍一下@Async注解的使用 1创建线程池 当在一个方法上标注了@Async注解之后，在被调用的时候主线程会主动使用多线程来调用此方法，但是当我们需要线程池来堆多线程进行管理的时候就需要使用到配置类线程池的Bean，如下 @Con...
SpringBoot2对接线程池
iTennis柠檬
12-12 445
SpringBoot2对接线程池 1、配置线程池Bean package com.itennishy.test.config; import java.util.concurrent.ThreadPoolExecutor; import org.springframework.context.annotation.Bean; import org.springframework.context...
科普文：Java基础系列之【@Async异步处理注解的使用和失效场景、以及原理和源码分析】
最新发布
为无为，事无事，味无味。
08-16 936
本文主要介绍了Spring中异步注解的使用、原理及可能碰到的问题，针对每个问题文中也给出了方案。希望通过这篇文章能帮助你彻底掌握@Async注解的使用，知其然并知其所以然！有了Spring AOP整体运行原理作为基础，再看这些基于AOP的应用，简直行云流水。因此还是应正了那句话：你能走多远，就看你的根基有多稳。异步方法建议尽量处理耗时的任务，或者是处理不希望阻断主流程的任务（比如异步记录操作日志）
java 线程通信_Java线程间通信-回调的实现方式
weixin_32139249的博客
02-12 192
Java线程间通信-回调的实现方式Java线程间通信是非常复杂的问题的。线程间通信问题本质上是如何将与线程相关的变量或者对象传递给别的线程，从而实现交互。比如举一个简单例子，有一个多线程的类，用来计算文件的MD5码，当多个这样的线程执行的时候，将每个文件的计算的结果反馈给主线程，并从控制台输出。线程之间的通讯主要靠回调来实现，回调的概念说得抽象了很难理解，等于没说。我就做个比喻：比如，地铁的列车上...
springboot---@Async实现异步调用及异步回调Future
QYHuiiQ
12-16 3万+
异步调用相对的是同步调用。 同步方法调用的时候必须是按照顺序执行的，上一行代码执行完，才会执行下一行。而异步方法调用是相当于多个线程执行，不需要等待上一行代码的执行结果。 首先测试方法同步的情况： controller： package springboot_async.async_test; import org.springframework.beans.factory.annot...
java关于@Async异步调用详细解析附代码
码农研究僧的博客
07-13 4812
异步调用与同步调用其的注解代码如下： 注解可以使用在类型以及方法中 通过value定义其值，默认是空一般这个注解需要配合，起源码如下 主要通过该注解放置在启动类中进行配置启动在启动类中添加如下： 2. 用法 2.1 同步调用 从调用到返回函数结果才能执行下一步，称为同步调用service层 代码： 控制层代码模块： 通过springboot的启动类启动之后 输出如下： 2.2 异步调用 异步调用，执行函数不用等返回结果就可以执行下一步service层 代码： 主要是添加了@Async注解标识这个方法 控制层
SpringBoot 异步使用@Async原理及线程池配置
fwdwqdwq的博客
08-02 987
上面介绍了Spring默认的线程池simpleAsyncTaskExecutor，但是Spring更加推荐我们开发者使用ThreadPoolTaskExecutor类来创建线程池，其本质是对java.util.concurrent.ThreadPoolExecutor的包装。#核心线程池数#最大线程池数#任务队列的容量#非核心线程的存活时间#线程池的前缀名称@Bean//最大线程数//核心线程数//任务队列的大小//线程前缀名//线程存活时间/**...
联合使用Spring的@Transactional和@Async注解的思考
baidu_38827679的博客
03-31 2504
一次使用Spring的@Transactional和@Async注解的思考
Java 异步编程 (5 种异步实现方式详解)
热门推荐
mikechen的互联网架构
09-20 4万+
​ 同步操作如果遇到一个耗时的方法，需要阻塞等待，那么我们有没有办法解决呢？让它异步执行，下面我会详解异步及实现@mikechen ​
Springboot中的@EnableAsync和@Async
Meiko记录
08-13 784
在我们的日常开发中，我们偶尔会遇到在业务层中我们需要同时修改多张表的数据并且需要有序的执行，如果我们用往常的同步的方式，也就是单线程的方式来执行的话，可能会出现执行超时等异常造成请求结果失败，及时成功，前端也需要等待较长时间来获取响应结果，这样不但造成了用户体验差，而且会经常出现请求执行失败的问题，在这里我们一般会采用3种方式来处理，如下所示： 在采用三种方式之前，我们所有来观察一下使用同步的方式实现的结果： 1.我们定义一个TestController,如下所示： @RestController
Java多线程实现回调函数.txt
12-10
Java多线程实现 自定义 的 回调函数. 手写 完成，亲测 完成，可以 直接运行，Demo ,具有一定参考价值，供大家阅读 下载，谢谢
java使用多线程并行处理逻辑后合并处理结果（Async注解方式）
AVATAR
11-10 854
java使用Async注解方式并行执行逻辑方法并将返回结果做处理
Spring中@Async异步回调
Jason
09-06 2248
有一篇我们讲了用java的线程池跑批量任务，虽然也很方便，但是实际开发中，我们大部分都是使用Spring的框架，一个@Async注解就可以实现异步调用，让并发编程变的更简单了，与此同时我们也没办法通过方法的返回值能直接拿到结果了，所以需要用到异步回调，子线程做完之后回调给主线程 项目背景不用多说了，一般都是sping-boot 准备 @EnableAsync添加在启动类或者带@Configuration的都行 创建job 主要是利用Future这个函数处理回调，方法异步执行直接返回该类，任务是否执行完会.
线程、回调的实现
qq_41924554的博客
07-01 417
逻辑梳理 开启线程 关闭线程 线程定义的目的：起线程，正常返回0，不正常非0 回调定义目的：告诉service，数据已经准备好，把数据上传。 （收句柄-->操作句柄-->传递参数） 代码说明: //定义 typedef unsigned long DWORD; typedef void *HANDLE typedef void(*Callback)(int);//回调,定义函数指针结构 typedef void far *LPVOID; #define WINAPI __stdcal
java @Async异步
Little_Arya的博客
10-31 1160
java @Async异步
@Async join
杨航的专栏
03-25 282
直接贴代码 自定义线程池 package com.xh.lawsuit.rest.modular.example; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; impo...
@Async的特殊性，同类中方法嵌套@Async不生效的场景
csdnwenjun的博客
05-07 2070
@Async的嵌套调用
线程池怎么做到主动回调
阿凡提煮鸡蛋
03-01 1121
某些业务场景需要在一个异步操作完成后做一个回调，如果使用Future有个问题，需要主动调用get然后再执行逻辑。但是异步逻辑不知道什么时候结束，所以推荐回调的方式处理比较优雅，本文总结了三种方式可以实现此类需求。 1、CompletableFuture Future可以明确地完成（设定其值和状态），并且可以被用作CompletionStage ，支持有关的功能和它的完成时触发动作。 当两个或多个线程试图complete ， completeExceptionally ，或cancel一个Completabl
Spring @Async注解详解：实现异步调用
在传统的Java应用中，通常需要手动创建线程或使用线程池来实现异步处理，而Spring的@Async注解则简化了这一过程。 1. @Async的异步调用概念 异步调用与同步调用的主要区别在于执行流程。同步调用是顺序执行的，每个...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值