java 枚举，反射，CompletableFuture组合实现异步运算

当需要对一组数据进行不同维度的分析时，可使用该方法实现。
我这里简单的举例，实际遇到的场景不会这么简单：
给定两个整数，起始数字，结束数字，根据不同的业务规则，进行运算。
规则1：统计两个数之间的整数之和；
规则2：统计两个数之间的偶数；
…

根据上面的描述可知满足“对一组数据进行不同维度的分析”，所以可以使用CompletableFuture进行异步运算。
现在开始代码实现
创建各个实现类，实现业务规则：
创建CalcSum.java,实现规则1：

public class CalcSum implements Runnable {
    int startNum;
    int endNum;

    public CalcSum(int startNum, int endNum) {
        this.startNum = startNum;
        this.endNum = endNum;
    }

    @Override
    public void run() {
        System.out.println("Start Calculate.....");
        if (startNum > endNum) {
            System.out.println("error:endNum < startNum.");
        }
        int sum = 0;
        for (int i = startNum; i <= endNum; i++) {
            sum += i;
        }
        System.out.println("End Calculate.....,sum = " + sum);
    }
}

创建FindEvenNum.java,实现规则2：

public class FindEvenNum implements Runnable {
    int startNum;
    int endNum;

    public FindEvenNum(int startNum, int endNum) {
        this.startNum = startNum;
        this.endNum = endNum;
    }

    @Override
    public void run() {
        System.out.println("Start FindEvenNum.....");
        if (startNum > endNum) {
            System.out.println("error:endNum < startNum.");
        }
        List<Integer> evenNum = new ArrayList<>();
        for (int i = startNum; i <= endNum; i++) {
            if (i % 2 == 0) {
                evenNum.add(i);
            }
        }
        System.out.println("End FindEvenNum....." + evenNum);
    }
}

将业务实现类放进枚举类中：

public enum RunEnum {
    AAA(1, FindEvenNum.class),
    BBB(2, CalcSum.class);
    private final int index;
    private final Class<?> runClass;

    RunEnum(int index, Class<?> runClass) {
        this.index = index;
        this.runClass = runClass;
    }

    public static List<Class<?>> getAllRunClass() {
        List<Class<?>> list = new ArrayList<>();
        list.add(RunEnum.AAA.runClass);
        list.add(RunEnum.BBB.runClass);
        return list;
    }
}

使用反射获取实现类实例，并用CompletableFuture异步执行。

public class CompletableFutureDemo {
    public static void CompletableFutureCoordinateEnum(){
        ForkJoinPool pool = new ForkJoinPool();
        List<CompletableFuture<Void>> futureList = new ArrayList<>();
        List<Class<?>> allRunClass = RunEnum.getAllRunClass();
        allRunClass.forEach(runClass -> {
            try {
                Constructor<?> constructor = runClass.getConstructor(int.class, int.class);
                Object instance = constructor.newInstance(1, 20);
                CompletableFuture<Void> future = CompletableFuture.runAsync((Runnable) instance, pool);
                futureList.add(future);
            } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
                e.printStackTrace();
            }
            System.out.println(runClass.getName());
        });
        futureList.forEach(future -> {
            try {
                future.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
    }
    
    public static void main(String[] a){
        CompletableFutureCoordinateEnum();
    }
}

执行main方法，执行结果：