如何并行处理ArrayList中的字符串元素且不因异常终止程序？

要实现并行处理列表元素、同时隔离单个元素的异常（不终止程序），可以用以下几种Java常用方案：

方法一：使用ExecutorService（手动线程池） #

这种方式能精细控制线程资源，每个元素的校验任务独立执行，异常被单独捕获，不会扩散到其他任务。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ParallelValidation {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("element1");
        list.add("element2"); // 模拟会触发异常的元素
        list.add("element1");

        // 根据业务场景调整线程池大小，比如CPU核心数+1
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (String element : list) {
            executor.submit(() -> {
                try {
                    // 调用你的校验逻辑
                    validateElement(element);
                } catch (Exception e) {
                    // 单独处理异常，比如打日志、记录错误
                    System.err.printf("校验元素「%s」失败: %s%n", element, e.getMessage());
                }
            });
        }

        // 关闭线程池，不再接受新任务
        executor.shutdown();
        // 可选：等待所有任务执行完成
        // executor.awaitTermination(5, TimeUnit.MINUTES);
    }

    private static void validateElement(String element) throws Exception {
        // 模拟校验规则：特定元素抛出异常
        if ("element2".equals(element)) {
            throw new IllegalArgumentException("元素不符合校验规则");
        }
        System.out.printf("元素「%s」校验通过%n", element);
    }
}

方法二：使用并行流（Parallel Stream） #

并行流简化了并行处理的代码写法，但必须在元素处理逻辑内部捕获异常，否则未捕获的异常会终止整个流的执行。

import java.util.ArrayList;
import java.util.List;

public class ParallelStreamValidation {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("element1");
        list.add("element2");
        list.add("element1");

        list.parallelStream().forEach(element -> {
            try {
                validateElement(element);
            } catch (Exception e) {
                System.err.printf("校验元素「%s」失败: %s%n", element, e.getMessage());
            }
        });
    }

    private static void validateElement(String element) throws Exception {
        if ("element2".equals(element)) {
            throw new IllegalArgumentException("元素不符合校验规则");
        }
        System.out.printf("元素「%s」校验通过%n", element);
    }
}

方法三：使用CompletableFuture（异步任务组合） #

如果需要收集校验结果（比如区分成功/失败的元素），CompletableFuture的异步组合能力会更灵活。

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

public class CompletableFutureValidation {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("element1");
        list.add("element2");
        list.add("element1");

        // 为每个元素创建异步校验任务
        List<CompletableFuture<Void>> futures = list.stream()
                .map(element -> CompletableFuture.runAsync(() -> {
                    try {
                        validateElement(element);
                    } catch (Exception e) {
                        System.err.printf("校验元素「%s」失败: %s%n", element, e.getMessage());
                    }
                }))
                .collect(Collectors.toList());

        // 等待所有异步任务执行完成
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
    }

    private static void validateElement(String element) throws Exception {
        if ("element2".equals(element)) {
            throw new IllegalArgumentException("元素不符合校验规则");
        }
        System.out.printf("元素「%s」校验通过%n", element);
    }
}

关键注意事项 #

• 异常必须局部捕获：所有方案的核心都是在单个元素的处理逻辑内捕获异常，避免异常扩散导致线程或整个程序终止。
• 线程池选型：如果是高频并行任务，建议自定义线程池（而非依赖并行流的默认ForkJoinPool），避免与其他并行任务抢占资源。
• 性能调优：线程池大小建议根据CPU核心数调整（比如Runtime.getRuntime().availableProcessors() + 1），减少上下文切换开销。

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