关于异步多线程

方法一:利用线程池或@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");
}
}

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

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

需要注意的是，@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);
}
}

2. 定义消息消费者，用于从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;
}
}

3. 在另一个类中调用消息生产者发送任务，并处理消息消费者返回的结果：

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类中，调用消息生产者发送任务，并等待一段时间，以便消息消费者处理完任务并返回结果。然后处理消息消费者返回的结果。

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