240
世界上有2种人,一种懂二进制,另一种不懂二进制。

关于异步多线程

方法一:利用线程池或@Async注解

使用@Async注解,可以实现多个方法并行执行,然后将它们的返回结果进行处理。@Async注解会使被标注的方法在调用时,将任务提交给一个线程池中的线程去执行,不会阻塞主线程。

下面是一个简单的示例,演示如何使用@Async注解来处理多个方法的返回结果:

  1. 创建一个异步服务类,用于处理多个方法并行执行:

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

@Service
public class AsyncService {

@Async
public CompletableFuture<String> method1() {
// 模拟耗时操作
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return CompletableFuture.completedFuture("Result from method1");
}

@Async
public CompletableFuture<String> method2() {
// 模拟耗时操作
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
return CompletableFuture.completedFuture("Result from method2");
}

@Async
public CompletableFuture<String> method3() {
// 模拟耗时操作
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return CompletableFuture.completedFuture("Result from method3");
}
}

  1. 在另一个类中调用这些异步方法并处理返回结果:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

@Component
public class AsyncMethodCaller {

@Autowired
private AsyncService asyncService;

public void callAsyncMethods() throws ExecutionException, InterruptedException {
// 并行调用三个异步方法
CompletableFuture<String> future1 = asyncService.method1();
CompletableFuture<String> future2 = asyncService.method2();
CompletableFuture<String> future3 = asyncService.method3();

// 等待所有异步方法执行完毕
CompletableFuture.allOf(future1, future2, future3).join();

// 获取异步方法的返回结果
String result1 = future1.get();
String result2 = future2.get();
String result3 = future3.get();

// 处理返回结果
System.out.println("Result from method1: " + result1);
System.out.println("Result from method2: " + result2);
System.out.println("Result from method3: " + result3);
}
}

在上面的示例中,AsyncService类中的三个方法都添加了@Async注解,使它们能够并行执行。然后在AsyncMethodCaller类中,调用这些异步方法并等待它们的执行结果,最后处理返回结果。

需要注意的是,@Async注解需要和@EnableAsync注解一起使用,以开启Spring的异步支持。在Spring Boot应用中,只需要在配置类上添加@EnableAsync注解即可。另外,异步方法的返回值类型可以使用CompletableFuture来包装异步结果,以便更方便地处理返回结果

方法二:使用消息中间件RabbitMQ

使用消息中间件可以实现异步处理多个方法并处理它们的返回结果。消息中间件可以将任务发布到消息队列中,然后多个消费者(处理器)可以并行地从队列中取出任务进行处理。处理完成后,可以将处理结果发送到另一个队列,或者使用其他方式进行处理。

下面是一个简单的示例,演示如何使用消息中间件实现异步处理多个方法并处理返回结果。这里以RabbitMQ作为消息中间件为例:

  1. 定义消息生产者,用于将任务发布到RabbitMQ的消息队列中:

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MessageProducer {

@Autowired
private RabbitTemplate rabbitTemplate;

public void sendMessage(String message) {
rabbitTemplate.convertAndSend("my_queue", message);
}
}

  1. 定义消息消费者,用于从RabbitMQ的消息队列中接收任务并处理:

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class MessageConsumer {

@RabbitListener(queues = "my_queue")
public String handleMessage(String message) {
// 在这里处理任务,可以调用相应的异步方法并获取返回结果
// 模拟耗时操作
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Result from handleMessage: " + message;
}
}

  1. 在另一个类中调用消息生产者发送任务,并处理消息消费者返回的结果:
复制代码
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MessageProcessing {

    @Autowired
    private MessageProducer messageProducer;

    public void processMessages() {
        // 发送任务到消息队列
        messageProducer.sendMessage("Task 1");
        messageProducer.sendMessage("Task 2");
        messageProducer.sendMessage("Task 3");

        // 在这里处理消息消费者返回的结果,可以使用回调函数或异步方式处理
        // 等待一段时间,以便消息消费者处理完任务并返回结果
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 处理消息消费者返回的结果
        // 这里假设消息消费者的返回结果已经存储在某个地方,例如数据库中
        String result1 = "Result from handleMessage: Task 1";
        String result2 = "Result from handleMessage: Task 2";
        String result3 = "Result from handleMessage: Task 3";

        // 处理返回结果
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
    }
}
复制代码

 

在上面的示例中,MessageProducer类用于将任务发送到RabbitMQ的消息队列中,MessageConsumer类作为消息消费者,从队列中接收任务并处理,并返回处理结果。在MessageProcessing类中,调用消息生产者发送任务,并等待一段时间,以便消息消费者处理完任务并返回结果。然后处理消息消费者返回的结果。

通过消息中间件实现异步处理可以更好地解耦任务的生产和消费,提高系统的可扩展性和灵活性。同时,消息中间件还可以实现任务的持久化,确保任务不会丢失,以及实现任务的重试机制,增加系统的健壮性。

posted @   _Origin  阅读(52)  评论(1编辑  收藏  举报
相关博文:
阅读排行:
· 没有源码,如何修改代码逻辑?
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· 百万级群聊的设计实践
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
点击右上角即可分享
微信分享提示