多个CompletableFuture重复写如何简化，封装，复用，让同事们耳目一新的写法，这里给你答案

已于 2023-05-10 18:14:19 修改
阅读量835 收藏 4
点赞数 1
文章标签： java 开发语言
于 2023-05-10 18:12:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38349413/article/details/130604150
版权

这段时间接到一个校验的需求改动，最开始拿到的代码大致上逻辑思路是如下的，可以分析出来他这个当前已经有了3个校验了，我本次的需求是再加1个校验且本次的校验checkData函数是不能满足的

import cn.hutool.core.collection.CollectionUtil;
import com.example.demo.resp.ResponseDataModel;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;

/**
 * @author Mikey
 * @version 1.0
 * @date 2023/5/10 16:14
 * @description 校验Controller案例
 */
@RestController
@Slf4j
@RequestMapping("/check")
public class CheckRuleController {

    @ApiOperation(value = "校验数据接口", httpMethod = "GET")
    @GetMapping("/checkAllData")
    public ResponseDataModel checkAllData() throws ExecutionException, InterruptedException {
        // 校验1
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            long l1 = System.currentTimeMillis();
            System.out.println("任务1启动！  =====>" + l1);
            // 校验1业务逻辑校验代码
            String result = checkData("1");
            long l2 = System.currentTimeMillis();
            System.out.println("任务1结束，耗时：！  =====>" + (l2 - l1));
            return result;
        });
        // 校验2
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            long l1 = System.currentTimeMillis();
            System.out.println("任务2启动！  =====>" + l1);
            // 校验2业务逻辑校验代码
            String result = checkData("2");
            long l2 = System.currentTimeMillis();
            System.out.println("任务2结束，耗时：！  =====>" + (l2 - l1));
            return result;
        });

        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            long l1 = System.currentTimeMillis();
            System.out.println("任务3启动！  =====>" + l1);
            // 校验3业务逻辑校验代码
            String result = checkData("3");
            long l2 = System.currentTimeMillis();
            System.out.println("任务3结束，耗时：！  =====>" + (l2 - l1));
            return result;
        });
        List<String> futureList = new ArrayList<>();
        futureList.add(future1.get());
        futureList.add(future2.get());
        futureList.add(future3.get());
        List<String> resultList = Arrays.stream(futureList.toArray(new String[futureList.size()])).collect(Collectors.toList());
        return CollectionUtil.isEmpty(resultList) ? ResponseDataModel.ok() : ResponseDataModel.ok(resultList);
    }

    /**
     * 各类型规则进行校验
     * @param type
     * @return
     */
    private String checkData(String type){
        // 伪代码 doSth为你的业务逻辑代码
        String result = StringUtils.EMPTY;
        switch (type){
            case "1":
                //result = doSth1...
                result = "1";
                break;
            case "2":
                //result =  doSth2...
                result = "2";
                break;
            default:
                //result =  doSth default...
                result = "default";
                break;
        }
        return result;
    }

}

按照如上代码思路，再加一个校验或者更多的校验代码就会向如下趋势演化

import cn.hutool.core.collection.CollectionUtil;
import com.example.demo.resp.ResponseDataModel;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;

/**
 * @author Mikey
 * @version 1.0
 * @date 2023/5/10 16:14
 * @description 校验Controller案例
 */
@RestController
@Slf4j
@RequestMapping("/check")
public class CheckRuleController {

    @ApiOperation(value = "校验数据接口", httpMethod = "GET")
    @GetMapping("/checkAllData")
    public ResponseDataModel checkAllData() throws ExecutionException, InterruptedException {
        // 校验1
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            long l1 = System.currentTimeMillis();
            System.out.println("任务1启动！  =====>" + l1);
            // 校验1业务逻辑校验代码
            String result = checkData("1");
            long l2 = System.currentTimeMillis();
            System.out.println("任务1结束，耗时：！  =====>" + (l2 - l1));
            return result;
        });
        // 校验2
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            long l1 = System.currentTimeMillis();
            System.out.println("任务2启动！  =====>" + l1);
            // 校验2业务逻辑校验代码
            String result = checkData("2");
            long l2 = System.currentTimeMillis();
            System.out.println("任务2结束，耗时：！  =====>" + (l2 - l1));
            return result;
        });

        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            long l1 = System.currentTimeMillis();
            System.out.println("任务5启动！  =====>" + l1);
            // 校验3业务逻辑校验代码
            String result = checkData("3");
            long l2 = System.currentTimeMillis();
            System.out.println("任务5结束，耗时：！  =====>" + (l2 - l1));
            return result;
        });
        // 校验4
        CompletableFuture<String> future4 = CompletableFuture.supplyAsync(() -> {
            long l1 = System.currentTimeMillis();
            System.out.println("任务4启动！  =====>" + l1);
            // 校验4业务逻辑校验代码
            String result = newCheckData();
            long l2 = System.currentTimeMillis();
            System.out.println("任务4结束，耗时：！  =====>" + (l2 - l1));
            return result;
        });
        // 校验5
        CompletableFuture<String> future5 = CompletableFuture.supplyAsync(() -> {
            long l1 = System.currentTimeMillis();
            System.out.println("任务5启动！  =====>" + l1);
            // 校验5业务逻辑校验代码
            String result = otherCheckData();
            long l2 = System.currentTimeMillis();
            System.out.println("任务5结束，耗时：！  =====>" + (l2 - l1));
            return result;
        });
        // 校验6
        CompletableFuture<String> future6 = CompletableFuture.supplyAsync(() -> {
            long l1 = System.currentTimeMillis();
            System.out.println("任务6启动！  =====>" + l1);
            // 校验6业务逻辑校验代码
            String result = otherCheckData();
            long l2 = System.currentTimeMillis();
            System.out.println("任务6结束，耗时：！  =====>" + (l2 - l1));
            return result;
        });
        List<String> futureList = new ArrayList<>();
        // 收集异步执行结果
        futureList.add(future1.get());
        futureList.add(future2.get());
        futureList.add(future3.get());
        futureList.add(future4.get());
        futureList.add(future5.get());
        futureList.add(future6.get());
        List<String> resultList = Arrays.stream(futureList.toArray(new String[futureList.size()])).collect(Collectors.toList());
        return CollectionUtil.isEmpty(resultList) ? ResponseDataModel.ok() : ResponseDataModel.ok(resultList);
    }

    /**
     * 各类型规则进行校验
     * @param type
     * @return
     */
    private String checkData(String type){
        // 伪代码 doSth为你的业务逻辑代码
        String result = StringUtils.EMPTY;
        switch (type){
            case "1":
                //result = doSth1...
                result = "1";
                break;
            case "2":
                //result =  doSth2...
                result = "2";
                break;
            default:
                //result =  doSth default...
                result = "default";
                break;
        }
        return result;
    }

    /**
     * 新业务校验规则
     * @return
     */
    private String newCheckData(){
        return "新1";
    }

    /**
     * 其他业务校验规则
     * @return
     */
    private String otherCheckData(){
        return "更多其他校验";
    }
}

到这里，大多数同学们应该都会发起提问，在这里插入图片描述
每次加个校验任务都得写一次CompletableFuture.supplyAsync()、FutureList.add()，代码量虽然蹭蹭往上涨，但都是无效代码，虽然实现了，但我们不做写屎山的攻城狮在这里插入图片描述
接下来进入优化步骤，这边演化的是最终的优化代码版本，其中碰到了很多坎，也是请教了朋友一步步改造，才完成如下代码版本

第一步，每一个校验都要加一个异步，CompletableFuture是一个重复的代码，思考有没办法扔到循环里面，用循环完成异步部署任务
PS：CompletableFuture.supplyAsync(supplier, threadPoolExecutor)可以改用采用自定义线程池配置

    /**
     * 部署所有异步任务
     * @param suppliers
     * @return
     */
    public List<CompletableFuture<String>> buildCompletableFutureList(Supplier... suppliers) {
        List<CompletableFuture<String>> futureList = new ArrayList<>();
        for (Supplier supplier : suppliers) {
            CompletableFuture<String> future = CompletableFuture.supplyAsync(supplier);
            futureList.add(future);
        }
        return futureList;
    }

第二步，根据第一步封装异步部署任务，需要提供参数Supplier的方法，对各校验函数进行改造

 /**
     * 各类型规则进行校验
     *
     * @param type
     * @return
     */
    private Supplier<String> checkData(String type) {
        return () -> {
            // 伪代码 doSth为你的业务逻辑代码
            String result = StringUtils.EMPTY;
            switch (type) {
                case "1":
                    //result = doSth1...
                    result = "1";
                    break;
                case "2":
                    //result =  doSth2...
                    result = "2";
                    break;
                default:
                    //result =  doSth default...
                    result = "default";
                    break;
            }
            return result;
        };
    }

第三步，收集各异步执行结果改造

/**
     * 获取所有异步任务执行结果
     * @param futureList
     * @return
     */
    public List<String> getFutureResultList(List<CompletableFuture<String>> futureList){
        // 收集各异步校验任务
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(futureList.toArray(new CompletableFuture[futureList.size()]));
        // 等待所有任务执行结果
        allFutures.join();
        // 获取所有任务执行结果
        List<String> resultList = new ArrayList<>();
        for(CompletableFuture<String> future: futureList){
            resultList.add(future.join());
        }
        return resultList;
    }

按上述步骤整合后的代码，整体代码更为简洁，提高可读性、代码复用性

import cn.hutool.core.collection.CollectionUtil;
import com.example.demo.resp.ResponseDataModel;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * @author Mikey
 * @version 1.0
 * @date 2023/5/10 16:14
 * @description 校验Controller案例
 */
@RestController
@Slf4j
@RequestMapping("/check")
public class CheckRuleController {

    @ApiOperation(value = "校验数据接口", httpMethod = "GET")
    @GetMapping("/checkAllData")
    public ResponseDataModel checkAllData() throws ExecutionException, InterruptedException {
        List<Supplier<String>> suppliers = new ArrayList<>();
        // 校验1
        suppliers.add(checkData("1"));
        // 校验2
        suppliers.add(checkData("2"));
        // 校验3
        suppliers.add(checkData("3"));
        // 校验4
        suppliers.add(newCheckData());
        // 校验5
        suppliers.add(otherCheckData());
        // 校验6
        suppliers.add(otherCheckData());
        // 部署各异步校验任务
        List<CompletableFuture<String>> futureList = buildCompletableFutureList(suppliers.toArray(new Supplier[suppliers.size()]));
        // 获取所有异步任务执行结果
        List<String> resultList = getFutureResultList(futureList);
        // 响应服务端结果
        return CollectionUtil.isEmpty(resultList) ? ResponseDataModel.ok() : ResponseDataModel.ok(resultList);
    }

    /**
     * 获取所有异步任务执行结果
     * @param futureList
     * @return
     */
    public List<String> getFutureResultList(List<CompletableFuture<String>> futureList){
        // 收集各异步校验任务
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(futureList.toArray(new CompletableFuture[futureList.size()]));
        // 等待所有任务执行结果
        allFutures.join();
        // 获取所有任务执行结果
        List<String> resultList = new ArrayList<>();
        for(CompletableFuture<String> future: futureList){
            resultList.add(future.join());
        }
        return resultList;
    }

    /**
     * 部署所有异步任务
     * @param suppliers
     * @return
     */
    public List<CompletableFuture<String>> buildCompletableFutureList(Supplier... suppliers) {
        List<CompletableFuture<String>> futureList = new ArrayList<>();
        for (Supplier supplier : suppliers) {
            CompletableFuture<String> future = CompletableFuture.supplyAsync(supplier);
            futureList.add(future);
        }
        return futureList;
    }

    /**
     * 各类型规则进行校验
     *
     * @param type
     * @return
     */
    private Supplier<String> checkData(String type) {
        return () -> {
            // 伪代码 doSth为你的业务逻辑代码
            String result = StringUtils.EMPTY;
            switch (type) {
                case "1":
                    //result = doSth1...
                    result = "1";
                    break;
                case "2":
                    //result =  doSth2...
                    result = "2";
                    break;
                default:
                    //result =  doSth default...
                    result = "default";
                    break;
            }
            return result;
        };
    }

    /**
     * 新业务校验规则
     *
     * @return
     */
    private Supplier<String> newCheckData() {
        return () -> {
            return "新1";
        };
    }

    /**
     * 其他业务校验规则
     *
     * @return
     */
    private Supplier<String> otherCheckData() {
        return () -> {
            return "更多其他校验";
        };
    }
}

所谓“道生一，一生二，二生三，三生万物”，还可以考虑几个封装的函数由于使用的业务场景不同，参数类型和数据类型也可能不同，更换为泛型，这样才能让自身实力更加强大
在这里插入图片描述

import cn.hutool.core.collection.CollectionUtil;
import com.example.demo.resp.ResponseDataModel;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * @author Mikey
 * @version 1.0
 * @date 2023/5/10 16:14
 * @description 校验Controller案例
 */
@RestController
@Slf4j
@RequestMapping("/check")
public class CheckRuleController {

    @ApiOperation(value = "校验数据接口", httpMethod = "GET")
    @GetMapping("/checkAllData")
    public ResponseDataModel checkAllData() throws ExecutionException, InterruptedException {
        List<Supplier> suppliers = new ArrayList<>();
        // 校验1
        suppliers.add(checkData("1"));
        // 校验2
        suppliers.add(checkData("2"));
        // 校验3
        suppliers.add(checkData("3"));
        // 校验4
        suppliers.add(newCheckData());
        // 校验5
        suppliers.add(otherCheckData());
        // 校验6
        suppliers.add(otherCheckData());
        // 部署各异步校验任务
        List<CompletableFuture<String>> futureList = buildCompletableFutureList(suppliers.toArray(new Supplier[suppliers.size()]));
        // 获取所有异步任务执行结果
        List<String> resultList = getFutureResultList(futureList);
        // 响应服务端结果
        return CollectionUtil.isEmpty(resultList) ? ResponseDataModel.ok() : ResponseDataModel.ok(resultList);
    }

    /**
     * 获取所有异步任务执行结果
     *
     * @param futureList
     * @return
     */
    public <T> List<T> getFutureResultList(List<CompletableFuture<T>> futureList) {
        // 收集各异步校验任务
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(futureList.toArray(new CompletableFuture[futureList.size()]));
        // 等待所有任务执行结果
        allFutures.join();
        // 获取所有任务执行结果
        List<Object> resultList = new ArrayList<>();
        for (CompletableFuture<T> future : futureList) {
            resultList.add(future.join());
        }
        return (List<T>) resultList;
    }

    /**
     * 部署所有异步任务
     *
     * @param suppliers
     * @return
     */
    public <T> List<CompletableFuture<T>> buildCompletableFutureList(Supplier<T>... suppliers) {
        List<CompletableFuture<T>> futureList = new ArrayList<>();
        for (Supplier supplier : suppliers) {
            CompletableFuture<T> future = CompletableFuture.supplyAsync(supplier);
            futureList.add(future);
        }
        return futureList;
    }

    /**
     * 各类型规则进行校验
     *
     * @param type
     * @return
     */
    private <T> Supplier<T> checkData(String type) {
        return () -> {
            // 伪代码 doSth为你的业务逻辑代码
            String result = StringUtils.EMPTY;
            switch (type) {
                case "1":
                    //result = doSth1...
                    result = "1";
                    break;
                case "2":
                    //result =  doSth2...
                    result = "2";
                    break;
                default:
                    //result =  doSth default...
                    result = "default";
                    break;
            }
            return (T) result;
        };
    }

    /**
     * 新业务校验规则
     *
     * @return
     */
    private <T> Supplier<T> newCheckData() {
        return () -> {
            return (T) "新1";
        };
    }

    /**
     * 其他业务校验规则
     *
     * @return
     */
    private <T> Supplier<T> otherCheckData() {
        return () -> {
            return (T) "更多其他校验";
        };
    }
}

最后就是运行代码，求证自身之道时刻
在这里插入图片描述
如果喜欢我写的文章的同学们，求三连
在这里插入图片描述

李存礼
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java future 重试,使用CompletableFuture重试逻辑
weixin_30412847的博客
02-24 1016
I need to submit a task in an async framework I'm working on, but I need to catch for exceptions, and retry the same task multiple times before "aborting".The code I'm working with is:int retries = 0;...
CompletableFuture取多个任务结果
weixin_49456013的博客
04-26 1847
public class DemoTest { @Test public void test(){ long start = System.currentTimeMillis(); CompletableFuture<List<Integer>> future1 = CompletableFuture.supplyAsync(() -> { List<Integer> ipPmPortFlow
CompletableFuture多线程执行并发任务工具封装
fengchengwu2012的博客
01-17 862
多线程非阻塞
CompletableFuture实现简易版任务超时重试设计
最新发布
compellingMan的博客
03-19 500
众所周知，`CompletableFuture`随着Java8的诞生粉墨登场，这个类提供了非常强大的`Future`的扩展功能，可以大大简化我们进行异步编程时的复杂性以及代码的繁琐性，而且还是函数式的编码方式，可以通过各种静态方法对多个任务进行转换、计算以及组合最终收集；当然也可以进行任务的超时重试，这样就避开了对`spring-retry`以及其他框架的依赖引入，既可以用来学习领悟，也能进行简单的**任务超时重试**处理。
CompletableFuture处理工具类和CompletableFuture异常提取工具类
L'Étranger的博客
05-30 253
CompletableFuture处理工具类
CompletableFuture并发工具类
中文过六级再取名的博客
03-24 701
CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。
java并发系列 - 第30天：JUC中工具类CompletableFuture，必备技能
GitHub质检员
09-02 50
是java8中新增的一个类，算是对Future的一种增强，用起来很方便，也是会经常用到的一个工具类，熟悉一下。
CompletableFuture执行多个异步任务,将结果合并返回
热门推荐
悟能的师兄的专栏
04-10 1万+
Java CompletableFuture执行多个异步任务,将结果合并返回
React教程之封装一个Portal可复用组件的方法
08-28
react的核心之一是组件，下面这篇文章主要给大家介绍了关于React教程之封装一个Portal可复用组件的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧。
vue封装可复用组件confirm,并绑定在vue原型上的示例
10-16
今天小编就为大家分享一篇vue封装可复用组件confirm,并绑定在vue原型上的示例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
vue3 表格组件封装复用
02-27
Vue3 实现表格业务封装，从底层的角度，去带着大家封装一个可编辑的表格。从而在基础的基础上，做一个层次的提升，增加面试通过的几率。帮助大家在开发过程中，提高代码的复用性。
浅谈在Vue-cli里基于axios封装复用请求
08-28
主要介绍了浅谈在Vue-cli里基于axios封装复用请求，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Arduino原型可制造PCB：LED多路复用器-电路方案
04-20
我选择了LED多路复用器作为一个电路，该电路很简单，不会妨碍实现我的主要目标的进展，但又足够复杂，比几个闪烁的LED更有趣和更具挑战性。 我以为我会将原型制作过程分为五个阶段: 第1阶段）取决于Arduino的实验...
Java中CompletableFuture多线程任务异步编排
曹举的个人博客
05-28 3441
今天来简单看一下CompletableFuture多线程任务异步编排 为什么需要CompletableFuture？ 当多线程任务出现了相互依赖，需要按照一定的顺序执行的时候就需要用到CompletableFuture多线程任务异步编排 按照我的理解：CompletableFuture可以分为一下几种情况 1、单任务 2、两任务的编排 3、三任务的编排 4、多任务的编排 ...
CompletableFuture异步执行多任务并返回结果的demo
ghj19900713的博客
12-09 229
/ 获得future1的结果。// 获得future3的结果。// 获得future2的结果。System.out.println("所有任务都完成了，以下是任务结果：");// 使用CompletableFuture的thenApply方法处理每个任务的结果。return "任务1的结果";return "任务2的结果";return "任务3的结果";// 模拟长时间运行的任务1。// 模拟长时间运行的任务2。// 模拟长时间运行的任务3。// 阻塞等待所有任务完成。
CompletableFuture的再次封装
u011767319的博客
07-31 287
CompletableFuture的再次封装
CompletableFuture多任务执行及简单使用场景
来都来了
06-30 4058
CompletableFuture多任务执行
异步调用（CompletableFuture）And Spring超时重试（Retryable）和RestTemplate模版调用方法联合使用
qq_30035133的博客
07-13 3255
接到一个退费回调的需求，当三方回调通知支付平台支付成功时，需要将退费成功结果异步通知到调用方（APP），如果通知失败，需要进行4次重试，采用Http方式通知调用方接口即可。重点已经标出～ 那么接下来就是技术选型了，首先异步怎么处理，立马想到了MQ啊，异步解耦，但是感觉有点杀鸡焉用宰牛刀的感觉，最终还是决定用JDK8升级java.util.concurrent包下Future的完善版Completa...
Java重试的几种写法
果酱 の 博客
08-10 1177
在开发Java应用程序时，经常需要处理一些可能失败的操作，例如数据库连接、网络请求等。为了增加程序的健壮性和容错性，我们可以使用重试机制来尝试多次执行失败的操作。
用java写一个关于CompletableFuture多任务并行执行的方法
03-25
A： import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.stream.Collectors; public class CompletableFutureDemo { public static void executeInParallel(List<Runnable> tasks) { List<CompletableFuture<Void>> futures = tasks.stream() .map(r -> CompletableFuture.runAsync(r)) .collect(Collectors.toList()); CompletableFuture<Void> allFutures = CompletableFuture.allOf( futures.toArray(new CompletableFuture[futures.size()])); try { // Wait for all futures to complete allFutures.get(); } catch (Exception ex) { // Handle exception } } } 这是一个简单的方法，可以在多个任务上并行执行。它使用CompletableFuture类，将每个任务封装在一个CompletableFuture对象中，并使用allOf()方法等待它们全部执行完毕。其中，tasks参数为任务列表，每个任务都是一个Runnable对象。可以在任务中执行各种操作，例如网络调用、计算等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值