Java 8命令行应用多线程改造咨询：ExecutorService等选型

问题背景 #

现有单线程方法extractPrimeNumbers(long[] numbers)，接收长整型数组并返回素数集合，计划改造为4线程并行执行以提升百万级数组的处理效率。

1. ExecutorService vs Fork/Join：元素完全独立场景的选型 #

对于元素完全独立的计算场景，ExecutorService（线程池） 更简单直接，上手成本低；Fork/Join则更适合递归拆分的分治任务（如大任务拆分为小任务、合并小任务结果）。

如果需求仅为固定4线程处理，用ExecutorService.newFixedThreadPool(4)即可快速实现，代码简洁易懂；Fork/Join虽能完成需求，但需要编写RecursiveTask/RecursiveAction类，对于简单的独立元素计算属于过度设计。

示例代码（ExecutorService实现）：

private static boolean isPrime(long num) {
    if (num <= 1) return false;
    for (long i = 2; i <= Math.sqrt(num); i++) {
        if (num % i == 0) return false;
    }
    return true;
}

public static Set<Long> extractPrimeNumbersParallel(long[] numbers) throws InterruptedException, ExecutionException {
    ExecutorService executor = Executors.newFixedThreadPool(4);
    List<Future<Set<Long>>> futures = new ArrayList<>();
    
    // 分片分配任务
    int chunkSize = (int) Math.ceil((double) numbers.length / 4);
    for (int i = 0; i < numbers.length; i += chunkSize) {
        int end = Math.min(i + chunkSize, numbers.length);
        long[] chunk = Arrays.copyOfRange(numbers, i, end);
        futures.add(executor.submit(() -> {
            Set<Long> localPrimes = new HashSet<>();
            for (long num : chunk) {
                if (isPrime(num)) {
                    localPrimes.add(num);
                }
            }
            return localPrimes;
        }));
    }
    
    Set<Long> result = new HashSet<>();
    for (Future<Set<Long>> future : futures) {
        result.addAll(future.get());
    }
    executor.shutdown();
    return result;
}

2. 百万级数组：分片还是单元素任务？ #

必须按分片分配任务，不能将每个元素作为独立任务。任务的创建、调度、上下文切换存在固定开销，百万级单元素任务会耗尽线程池调度能力，反而比单线程处理更慢。

合理的分片逻辑：将数组拆分为4份（对应4线程），分片大小按数组长度/线程数向上取整即可。例如百万级数组，每个分片约25万元素，既能充分利用CPU，又能将调度开销降至最低。

3. 线程安全结果集：本地集合合并更优 #

是的，各线程维护本地非线程安全集合（如HashSet），最后合并结果的性能远高于直接使用线程安全集合（如ConcurrentSkipListSet或Collections.synchronizedSet）。

原因是线程安全集合的每一次add操作都存在锁开销，百万级元素的累计开销极大；而本地集合无锁操作，最终一次合并的成本可忽略不计。上述ExecutorService示例已采用该思路：每个任务返回独立的HashSet，主线程统一合并所有结果。

4. Spliterator的应用价值：数组分区与并行流 #

Spliterator是Java 8引入的数据源拆分迭代器，可用于数组分区，结合并行流能更优雅地实现并行计算。

Java数组并行流基于Spliterator实现，无需手动编写线程池或Fork/Join代码，底层会自动处理分片与线程调度（默认使用ForkJoinPool，也可指定线程数）。

示例代码（并行流+自定义线程数）：

public static Set<Long> extractPrimeNumbersParallelStream(long[] numbers) {
    ForkJoinPool forkJoinPool = new ForkJoinPool(4);
    try {
        return forkJoinPool.submit(() -> 
            Arrays.stream(numbers)
                  .parallel()
                  .filter(PrimeUtils::isPrime)
                  .boxed()
                  .collect(Collectors.toSet())
        ).get();
    } catch (InterruptedException | ExecutionException e) {
        throw new RuntimeException(e);
    } finally {
        forkJoinPool.shutdown();
    }
}

并行流内部通过Spliterator将数组拆分为多个分片，分配给不同线程处理后合并结果。若无需自定义复杂分区逻辑，直接使用并行流即可，代码最简洁。

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