使用SpringBoot异步注解，等待线程执行结果

业务需求

数据结构：一次数据同步需要同步多个变更，每个变更又包含多个物料。每个物料都要调用一次ERP系统的物料同步接口。

客户希望优化数据同步的速度，将变更中的多个物料同步改成并发调用。例如：一次变更如果要同步1000个物料，可以并发调用1000次物料同步接口。而不是一个个依次调用。

多个变更之间由于存在业务约束，仍然要保证顺序依次挨个处理，不能多线程处理。

实现方案

程序按照顺序查询出所有要处理的变更，循环处理每一个变更。

处理每一个变更的时候，可以使用SpringBoot的异步注解并发调用物料同步接口。

等到一个变更中所有物料都收到同步结果后，再处理下一个变更。

代码实现

首先启动类上要开启异步调用注解

@SpringBootApplication
@EnableScheduling
@EnableAsync
public class DemoApplication {

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

}

主业务类

synItemBom这个方法使用了异步注解，意味着每一个物料的同步是多线程异步调用。他有一个Future类型的返回值，调用get方法时就会等待线程的返回结果了。

package com.purvar.business;

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

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;

/**
 * 本类主要用于演示多线程处理每个受影响物件的方法<br>
 *
 * @author namelessmyth
 * @version 1.0
 * @date 2022/11/9
 */
@Component
public class ThreadDemoFuture {

    /**
     * 处理所有变更的方法，依次挨个调用。
     * @throws Exception
     */
    public void synChanges() throws Exception {
        //所有要处理的变更列表，这里不连数据库了，直接new
        List<String> changes = new ArrayList<>();
        changes.add("change1");
        changes.add("change2");

        //循环依次处理每个变更
        for (String change : changes) {
            synChange(change);
        }
    }

    /**
     * 单个变更处理方法，内部同步物料时为多线程异步处理
     * @throws Exception
     */
    private void synChange(String change) throws Exception {
        List<String> items = new ArrayList<>();
        items.add("item1");
        items.add("item2");
        items.add("item3");

        List<Future<String>> tasks = new ArrayList<>(items.size());
        //循环处理每个影响物件
        for (String item : items) {
            //这个同步物料的方法为异步方法，会开启多线程调用
            Future<String> task = synItemBom(item);
            tasks.add(task);
        }
        List<String> results = new ArrayList<>(tasks.size());
        for (Future<String> task : tasks) {
            //将所有线程的返回结果累加起来
            results.add(task.get());
        }
        if (!results.isEmpty() && results.size() == items.size()) {
            //当前变更的所有物料都处理完成后，进行后续操作。
            doAfter();
        }
    }

    /**
     * 同步一个物料的方法，这里需要调用ERP接口，记录返回值
     * 可以写到一个单独的类里面，这里仅做demo
     * @param itemNumber
     * @return Future<String> 物料同步结果
     * @throws InterruptedException
     */
    @Async
    public Future<String> synItemBom(String itemNumber) throws InterruptedException {
        String result = "未知异常";
        try {
            result = "SAP返回结果";
            //此处模拟调用ERP接口
            Thread.sleep(1000);
        } catch (Exception e) {
            result = e.getMessage();
        }
        return new AsyncResult<String>("处理成功");
    }

    /**
     * 后处理方法
     */
    private void doAfter() {
        //do something
    }

    /**
     * 另一种调用方法，需要测试一下，是不是实际效果还是依次调用的。
     */
    private void synChange2(String change) throws Exception {
        List<String> items = new ArrayList<>();
        items.add("item1");
        items.add("item2");
        items.add("item3");
        List<String> results = new ArrayList<>(items.size());
        //循环处理每个影响物件
        for (String item : items) {
            Future<String> task = synItemBom(item);
            //这里调用get以后，就会等待直到拿到结果。
            results.add(task.get());
        }
        if (!results.isEmpty() && results.size() == items.size()) {
            doAfter();
        }
    }

}

注意事项

如果要改成多线程并发调用，最好首先确认被调用方是否能承受高并发调用。

如果被调用方没有做过性能测试和压力测试，那改成多线程并发调用后，可能会出现新的高并发问题。继而引发更严重的性能问题。

在我的这个实际案例里面，客户希望提高同步速度，在未经任何调研和提供测试报告的前提下，就要求我们改成多线程调用。改成多线程调用之后，处理速度确实加快了。但是当遇到并发量大的情况（大概300个并发以上时）被调用方接口直接崩溃了，各种无响应。

所以优化之前客户嫌弃处理速度太慢，优化之后系统都直接不可用了。最后还是改成了中间表的方案。我们将数据写入中间表，对方系统读取中间表，根据自身能力去做优化处理。