CompletableFuture多线程执行并发任务工具封装

1. 工具类封装

public class ParallelTaskFactory {

    /**
     * 存储消费型任务
     */
    private final   List<CompletableFuture<Void>>    consumerTaskList = new CopyOnWriteArrayList<>();

    /**
     * 存储供给型任务
     */
    private final  List<CompletableFuture<Object>>  supplyTaskList = new CopyOnWriteArrayList<>();


    /**
     * 添加消费型任务
     * @param task
     */
    public  void  addVoidTask(IExecutorVoidTask  task){
        consumerTaskList.add(CompletableFuture.runAsync(task::doRun));
    }

    /**
     * 执行消费型任务
     */
    @SuppressWarnings("unchecked")
    public  void   doVoidTasks(){
        if(!consumerTaskList.isEmpty()){
            CompletableFuture<Void>[] completableFutures = consumerTaskList.toArray(new CompletableFuture[0]);
            /// 全部并行执行结束时结束任务
            CompletableFuture.allOf(completableFutures).join();
        }
    }

    /**
     * 添加供给型任务
     * @param task
     */
    public   void  addSupplyTask(IExecutorSupplyTask task){
        supplyTaskList.add( CompletableFuture.supplyAsync(task::doRun));
    }


    /**
     * 执行供给型任务
     */
    @SuppressWarnings("unchecked")
    public List<Object>  doSupplyTasks(){
        List<Object>  list = new ArrayList<>();
        if(!supplyTaskList.isEmpty()) {
            CompletableFuture<Object>[] completableFutures = supplyTaskList.toArray(new CompletableFuture[0]);
            /// 全部并行执行结束时结束任务
            CompletableFuture.allOf(completableFutures).join();

            Arrays.stream(completableFutures).forEach(c->{
                try {
                    Object o = c.get();
                    list.add(o);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        return list;
    }

    @FunctionalInterface
    public  interface IExecutorVoidTask {
        /**
         * 执行消费任务
         */
        void  doRun();
    }

    @FunctionalInterface
    public  interface IExecutorSupplyTask {
        /**  执行供给任务
         * @return
         */
        Object  doRun();
    }
}

2. 调用测试

多线程调用远程接口

    public  String   testThread(Integer num){
        if(ObjectUtils.isEmpty(num)){
            num = 1;
        }
        long s = System.currentTimeMillis();
        ParallelTaskFactory parallelTaskFactory  = new ParallelTaskFactory();
        for (int i = 0; i < num; i++) {
            parallelTaskFactory.addSupplyTask(() -> {
                ResponseEntity<String> sout = restTemplate.getForEntity("http://127.0.0.1:8888/thread/msg?name="+Thread.currentThread().getName(), String.class);
                return sout.getBody();
            });
        }
        List<Object> list = parallelTaskFactory.doSupplyTasks();
        for (Object o : list) {
            LOGGER.info("多线程请求接口响应  {}：",o);
        }
        long e = System.currentTimeMillis();
        return  SDF.format(new Date())+"--线程执行完毕testThread,共耗时："+(e-s)+"毫秒";
    }