多线程执行异常处理求助：单线程失败不中断其他线程并汇总状态

针对你提出的「固定线程池执行任务，单个任务失败不中断其他任务，所有任务完成后统一更新状态」的需求，提供以下几种可行方案：

方案一：手动遍历Future收集结果（最直接） #

ExecutorService.invokeAll()本身就会等待所有任务完成（无论成功或失败），返回所有任务对应的Future列表。我们只需遍历这些Future，逐个获取执行结果、记录失败情况，最后统一处理状态。

ExecutorService ex = Executors.newFixedThreadPool(3);
List<Callable<Void>> jobs = new ArrayList<>();

// 示例任务：包含一个失败任务
jobs.add(() -> {
    System.out.println("执行任务1");
    return null;
});
jobs.add(() -> {
    System.out.println("执行任务2，模拟失败");
    throw new RuntimeException("任务2执行出错");
});
jobs.add(() -> {
    System.out.println("执行任务3");
    return null;
});

// 提交所有任务并等待完成
List<Future<Void>> futures = ex.invokeAll(jobs);
ex.shutdown(); // 关闭线程池，拒绝新任务
ex.awaitTermination(1, TimeUnit.HOURS); // 等待所有任务结束，可自定义超时时间

// 统计任务执行状态
boolean hasFailure = false;
for (Future<Void> future : futures) {
    try {
        future.get(); // 获取任务结果，失败则抛出异常
    } catch (InterruptedException | ExecutionException e) {
        System.err.println("任务失败原因：" + e.getCause().getMessage());
        hasFailure = true;
    }
}

// 统一更新状态
if (hasFailure) {
    System.out.println("存在任务失败，更新失败状态");
} else {
    System.out.println("所有任务执行成功，更新成功状态");
}

方案二：自定义ThreadPoolExecutor，用afterExecute跟踪状态 #

如果你之前尝试过afterExecute，可以通过自定义线程池，在afterExecute中记录每个任务的执行结果，当所有任务完成时触发统一状态更新。

// 自定义线程池，跟踪任务执行状态
class StatusTrackingThreadPool extends ThreadPoolExecutor {
    private final AtomicInteger completedTaskCount = new AtomicInteger(0);
    private final AtomicInteger failedTaskCount = new AtomicInteger(0);
    private final int totalTasks;
    private final Runnable statusUpdateAction;

    public StatusTrackingThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                    BlockingQueue<Runnable> workQueue, int totalTasks, Runnable statusUpdateAction) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        this.totalTasks = totalTasks;
        this.statusUpdateAction = statusUpdateAction;
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        completedTaskCount.incrementAndGet();

        // 处理任务执行异常
        if (t != null) {
            failedTaskCount.incrementAndGet();
            System.err.println("任务失败：" + t.getMessage());
        } else if (r instanceof Future<?>) {
            // 处理Callable任务（包装为FutureTask的情况）
            try {
                ((Future<?>) r).get();
            } catch (InterruptedException | ExecutionException e) {
                failedTaskCount.incrementAndGet();
                System.err.println("任务失败：" + e.getCause().getMessage());
            }
        }

        // 所有任务完成时触发状态更新
        if (completedTaskCount.get() == totalTasks) {
            statusUpdateAction.run();
        }
    }

    public int getFailedTaskCount() {
        return failedTaskCount.get();
    }
}

// 使用示例
public static void main(String[] args) throws InterruptedException {
    int totalTaskNum = 3;
    StatusTrackingThreadPool executor = new StatusTrackingThreadPool(
            3, 3, 0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(),
            totalTaskNum,
            () -> {
                // 统一更新状态的逻辑
                int failed = executor.getFailedTaskCount();
                if (failed > 0) {
                    System.out.println("共" + failed + "个任务失败，更新失败状态");
                } else {
                    System.out.println("所有任务成功，更新成功状态");
                }
            }
    );

    List<Callable<Void>> jobs = new ArrayList<>();
    jobs.add(() -> {
        System.out.println("执行任务1");
        return null;
    });
    jobs.add(() -> {
        System.out.println("执行任务2，模拟失败");
        throw new RuntimeException("任务2出错");
    });
    jobs.add(() -> {
        System.out.println("执行任务3");
        return null;
    });

    executor.invokeAll(jobs);
    executor.shutdown();
    executor.awaitTermination(1, TimeUnit.HOURS);
}

方案三：使用CompletableFuture（Java 8+ 推荐） #

如果你的项目使用Java 8及以上版本，CompletableFuture提供了更灵活的异步编排能力，可以轻松实现「等待所有任务完成后统一处理」的逻辑。

// 创建固定线程池
ExecutorService threadPool = Executors.newFixedThreadPool(3);

// 定义任务列表
List<CompletableFuture<Void>> taskFutures = new ArrayList<>();
taskFutures.add(CompletableFuture.runAsync(() -> {
    System.out.println("执行任务1");
}, threadPool));
taskFutures.add(CompletableFuture.runAsync(() -> {
    System.out.println("执行任务2，模拟失败");
    throw new RuntimeException("任务2执行失败");
}, threadPool));
taskFutures.add(CompletableFuture.runAsync(() -> {
    System.out.println("执行任务3");
}, threadPool));

// 等待所有任务完成，无论成功失败
CompletableFuture.allOf(taskFutures.toArray(new CompletableFuture[0]))
        .whenComplete((unused, throwable) -> {
            // 统计失败任务数量
            long failedCount = taskFutures.stream()
                    .filter(CompletableFuture::isCompletedExceptionally)
                    .count();
            // 统一更新状态
            if (failedCount > 0) {
                System.out.println("共" + failedCount + "个任务失败，更新失败状态");
            } else {
                System.out.println("所有任务执行成功，更新成功状态");
            }
            // 关闭线程池
            threadPool.shutdown();
        });

// 主线程保持存活，避免异步任务提前终止
try {
    Thread.sleep(3000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

内容的提问来源于stack exchange，提问作者Anjini Nitikka S