如何使用GPars并行处理列表并将结果收集至Map？

嘿，这个问题我之前折腾GPars的时候也遇到过！其实不用纠结有没有现成的collectEntriesParallel，咱们完全可以用现有的collectParallel来曲线救国，思路超简单——先让每个元素并行生成键值对条目，再把这些条目集合转换成Map就行，效率一点不打折扣。

核心思路 #

GPars的collectParallel负责并行遍历集合并生成中间结果，我们只需要让每个元素的处理逻辑返回键值对条目（比如Map.Entry对象，或者Groovy里的小Map），最后把这些中间结果一次性转换成目标Map就好。这一步转换是串行的，但只是简单的数据整理，完全不会影响整体并行处理的效率。

Groovy 代码示例 #

Groovy里的实现更简洁，利用语言本身的语法糖可以快速完成：

import groovyx.gpars.GParsPool

// 待处理的原始列表
def dataList = ['user_001', 'user_002', 'user_003', 'user_004', 'user_005']

// 模拟耗时操作：比如查询数据库、调用外部API等
def fetchUserInfo(String userId) {
    // 随机休眠0-1秒模拟耗时
    sleep(new Random().nextInt(1000))
    // 返回模拟的用户信息作为Map的value
    return [name: "User_${userId.toUpperCase()}", age: new Random().nextInt(30) + 20]
}

// 用GPars池实现并行处理
GParsPool.withPool {
    // 第一步：并行生成键值对条目集合
    def keyValueEntries = dataList.collectParallel { userId ->
        // 返回一个Entry对象，键是userId，值是耗时操作的结果
        new AbstractMap.SimpleEntry(userId, fetchUserInfo(userId))
    }
    
    // 第二步：将条目集合转换为目标Map
    def userInfoMap = keyValueEntries.collectEntries()
    
    // 打印结果
    println("最终收集的Map：\n${userInfoMap}")
}

如果你喜欢更简洁的写法，也可以直接返回小Map再合并：

GParsPool.withPool {
    def userInfoMap = dataList.collectParallel { userId ->
        [(userId): fetchUserInfo(userId)] // 返回单个键值对的小Map
    }.inject([:]) { acc, entryMap -> acc << entryMap }
}

Java 代码示例 #

如果是在Java环境中使用GPars，思路完全一致，只是语法上稍微繁琐一点：

import groovyx.gpars.GParsPool;
import java.util.AbstractMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.stream.Collectors;

public class ParallelMapCollector {
    public static void main(String[] args) {
        List<String> dataList = List.of("user_001", "user_002", "user_003", "user_004");

        // 模拟耗时操作
        Map<String, Object> fetchUserInfo(String userId) {
            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("操作被中断", e);
            }
            return Map.of(
                    "name", "User_" + userId.toUpperCase(),
                    "age", new Random().nextInt(30) + 20
            );
        }

        // 启动GPars并行池
        GParsPool.withPool(() -> {
            // 并行生成Entry列表
            List<Map.Entry<String, Map<String, Object>>> entries = GParsPool.collectParallel(
                    dataList,
                    userId -> new AbstractMap.SimpleEntry<>(userId, fetchUserInfo(userId))
            );

            // 转换为最终Map
            Map<String, Map<String, Object>> userInfoMap = entries.stream()
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

            System.out.println("最终收集的Map：");
            userInfoMap.forEach((k, v) -> System.out.println(k + ": " + v));
        });
    }
}

注意事项 #

• 线程安全：这种方式完全不用担心并发问题，因为每个线程只处理自己的元素并生成独立的键值对条目，最终的Map合并是串行执行的，不会出现并发修改Map的情况。
• 池大小配置：如果需要控制并行线程数，可以在withPool里指定参数，比如GParsPool.withPool(4) { ... }来限制最多4个并行线程。

内容的提问来源于stack exchange，提问作者Raibaz