java多线程优化接口调用时间的问题

先描述一下业务场景，在一个业务调用的过程中，开始的时候是需要执行A模块和B模块，最后返回，随着业务的增加，A和B模块无法满足实际业务需求，随着业务的增加，慢慢衍生出C，D，E。。。。。。，随着模块的增多，调用的流程也越来越长，后面用户反馈，等待时间过久，需要对代码进行优化。

 分析代码

实际值发现代码的调用A，B，C，D模块之间是没有相互依赖关系的，但是E模块需要依赖前面模块的返回值，经短暂的讨论后，我们决定使用多线程解决这个问题。假设T(A)为执行A模块的时间，原本的总时间T(总)=T(A)+T(B)+T(C)+T(D)+T(E)，现在的总时间T(总)=MAX（T(A)，T(B)，T(C)，T(D))+T(E)

 CompletableFuture

简介

CompletableFuture是Java 8中引入的异步编程工具，它可以方便地进行异步任务的处理，实现任务之间的串联和组合，以及异常的处理等。

CompletableFuture类使用起来非常方便，支持链式调用和函数式编程风格。我们可以在一个CompletableFuture实例中执行一个异步任务，并设置任务结束后的回调函数。同时，也可以利用CompletableFuture提供的方法来串联多个异步任务。

CompletableFuture还支持多个任务的并行处理，可以使用它的allOf和anyOf方法来实现多个异步任务的并行执行。

总之，CompletableFuture是Java 8中非常有用的异步编程工具，可以大大简化异步任务的处理，提高代码的可读性和可维护性。

 主要涉及api接口

thenApply：

提交的任务类型需遵从Function签名，也就是有入参和返回值，其中入参为前置任务的结果

 demo（sleep模拟业务执行）

import java.util.concurrent.CompletableFuture;

public class Test {
    public static void test1() {
        // 模块A
        try {
            System.out.println("模块A");
            Thread.sleep(3000);
            Integer a = 1;
            // 模块B
            System.out.println("模块B");
            Thread.sleep(6000);
            Integer b = 2;
            // 模块C
            System.out.println("模块C");
            Integer c = a + b;
            System.out.println("result: " + c);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public static void test2() {
        CompletableFuture<Integer> future1
                = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("模块A");
                Thread.sleep(3000);
                return 1;
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        CompletableFuture<Integer> future2
                = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("模块B");
                Thread.sleep(6000);
                return 2;
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        CompletableFuture<Integer> future3
                = future1.thenCombine(future2, (r1, r2) -> {
            // 执行最后的代码
            System.out.println("模块C");
            return r1 + r2;
        });
        System.out.println("result: " + future3.join());
    }

    public static void main(String[] args) {
        long start1 = System.currentTimeMillis();
        test1();
        System.out.println("串行共用时" + (System.currentTimeMillis() - start1) + "ms");
        System.out.println("=====================================================");
        long start2 = System.currentTimeMillis();
        test2();
        System.out.println("并行共用时" + (System.currentTimeMillis() - start2) + "ms");
    }
}

运行结果