简介

1. CompletableFuture是 Java 并发库中引入的一个类，它提供了强大的异步编程功能，使得开发者能够更容易地处理异步任务、组合多个异步操作以及处理异常。CompletableFuture 可以用于执行耗时的操作，而不会阻塞主线程，从而提高程序的性能。
2. Redisson 是一个基于 Redis 的分布式 Java 对象存储库，它提供了许多分布式系统的构建块，其中之一是分布式锁。Redisson 的分布式锁实现是基于 Redis 的 SETNX 和 WATCH 命令，具有高性能和可靠性。

使用代码

1. 实体类对象

   java
   @Data
   public class DictDto {
   
       /**
        * 交易或结算编号
        */
       private String key;
   
       /**
        * 文件路径
        */
       private String filePath;
   
       /**
        * 错误信息
        */
       private String errorMsg;
   
   }
   

2. 配置RedissonClient

   java
   @Configuration
   public class RedissonConfig {
   
       @Bean
       public RedissonClient redisson(RedisProperties redisProperties) {
           // 配置Redisson
           Config config = new Config();
           SingleServerConfig singleServerConfig = config
                   .useSingleServer()
                   .setAddress("redis://" + redisProperties.getHost() + ":" + redisProperties.getPort());
           if (StrUtil.isNotBlank(redisProperties.getPassword())) {
               singleServerConfig.setPassword(redisProperties.getPassword());
           }
           return Redisson.create(config);
       }
   }   
   

3. 使用CompleTableFuture并行执行并收集错误信息

   java
   // 此处list仅做举例，使用时请替换为自己的集合
   
   @Resource
   private RedissonClient redissonClient;
   
   List<String> list = Lists.newArrayList();
   List<CompletableFuture<DictDto>> pageFutures = list
           .stream()
           .map(entry -> {
               DictDto dict = new DictDto();
               return CompletableFuture.supplyAsync(() -> {
                   // 请根据自己业务需要定义key，建议放在常量中，方便统一管理
                   RLock lock = redissonClient.getLock("XXX");
                   // 此处必须用lock()不能使用tryLock(),否则不能达到加锁的目的
                   lock.lock();
                   try {
                       // 自定义处理
                   } finally {
                       if (lock.isLocked()) {
                           lock.unlock();
                       }
                   }
                   return dict;
               }).exceptionally(throwable -> {
                   // 收集每个线程中的异常信息
                   log.error("确认书生成失败", throwable);
                   dict.setErrorMsg(throwable.getCause().getMessage());
                   return dict;
               });
           })
           .collect(Collectors.toList());
   // 组合CompletableFuture
   CompletableFuture<Void> allFutures = CompletableFuture
           .allOf(pageFutures.toArray(new CompletableFuture[0]));
   allFutures.join();
   List<DictDto> dictDtoList = pageFutures.stream()
           .map(CompletableFuture::join)
           .collect(Collectors.toList());