ExecutorService.awaitTermination返回true但未捕获任务异常问题排查

我实现了一个InputFilesParser类用于多线程处理文件，每个任务执行时都会抛出异常，但调用waitToFinish()方法时却无法检测到异常，输出显示thrownError始终为null。

解析器类代码 #

public class InputFilesParser {

private ExecutorService executorService;
private volatile Throwable thrownError;

public InputFilesParser(int poolSize) {
        this.executorService = Executors.newFixedThreadPool(poolSize, (r) -> {
            Thread t = new Thread(r);
            t.setUncaughtExceptionHandler((thread, e) -> {
                // 预期在线程结束前被调用
                this.notifyOnException(thread, e);
            });
            return t;
        });
    }

public void parseFile(Path inputFilePath) throws Throwable {
        // 若已有异常，终止后续文件处理
        if (this.thrownError != null) {
            this.waitToFinish();
        }
        this.executorService.execute(() -> {
            // 此处固定抛出异常，预期由上面设置的未捕获异常处理器处理
            this.processFile(inputFilePath);
        });
}

private void processFile(Path inputFilePath) {
    // 修正原代码拼写错误：RuntimeExecption → RuntimeException
    throw new RuntimeException();
}

public void waitToFinish() throws Throwable {
        this.executorService.shutdown();
        while (true) {
            try {
                // awaitTermination返回true时，表示所有任务已完成
                if (this.executorService.awaitTermination(STOP_CHECK_TIMEOUT, TimeUnit.SECONDS)) {
                    synchronized (this) {
                        // 预期所有任务完成后thrownError已被赋值
                        if (this.thrownError != null) {
                            System.out.println("Exception: " + this.thrownError);
                            throw this.thrownError;
                        } else {
                            // 实际输出内容
                            System.out.println("No exception: " + this.thrownError);
                        }
                    }
                    break;
                }
            } catch (InterruptedException e) {
                LOG.info("An interruption occurred", e);
            }
        }
}

private synchronized void notifyOnException(Thread thread, Throwable t) {
    // 仅在首次异常时赋值，确保waitToFinish能感知错误
    if (this.thrownError == null) {
        this.thrownError = t;
    }
}
}

调用代码 #

InputFilesParser ifp = new InputFilesParser(poolSize);
try {
    for (Path f : files) {
        // 此场景下每个文件解析都会触发异常
        ifp.parseFile(f);
    }
    // 预期此处会检测到异常并抛出，但实际未发生
    ifp.waitToFinish();
} catch(Exception e) {
    e.printStackTrace();
}

异常现象 #

尽管任务明确抛出了异常，但调用线程执行waitToFinish()时输出如下：

Thread: Thread-5. No exception: null

这意味着awaitTermination在notifyOnException设置异常前就返回了true，但notifyOnException本应由线程池线程调用。我疑惑是自己对Java机制理解有误，还是Java本身存在问题？

我是否忽略了setUncaughtExceptionHandler的工作逻辑？根据官方文档：

public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)

设置当线程因未捕获异常突然终止时调用的处理器。

线程可通过显式设置未捕获异常处理器，完全控制对未捕获异常的响应逻辑。若未设置该处理器，则线程的ThreadGroup对象会作为默认处理器。

参数说明：
eh - 用作当前线程未捕获异常处理器的对象。若为null，则当前线程无显式处理器。

核心原因：线程池的任务包装机制拦截了异常 #

当使用ExecutorService.execute()提交任务时，线程池会将任务包装在内部类（如ThreadPoolExecutor.Worker）中执行。这个包装类会捕获任务抛出的所有异常，不会将异常传递给线程的未捕获异常处理器——因为异常已经被内部处理，线程并未因未捕获异常而终止，所以你设置的UncaughtExceptionHandler永远不会被触发，thrownError自然始终为null。

解决方案 #

方案1：任务内部主动捕获并通知异常

修改parseFile中的任务提交逻辑，手动捕获异常并调用notifyOnException：

this.executorService.execute(() -> {
    try {
        this.processFile(inputFilePath);
    } catch (Throwable t) {
        this.notifyOnException(Thread.currentThread(), t);
    }
});

方案2：使用submit()替代execute()，通过Future获取异常

若需要追踪每个任务的异常，可改用submit()提交任务并保存Future对象，后续遍历获取异常：

// 类内新增成员变量保存所有任务的Future
private List<Future<Void>> taskFutures = new ArrayList<>();

// 提交任务时改用submit
public void parseFile(Path inputFilePath) throws Throwable {
    if (this.thrownError != null) {
        this.waitToFinish();
    }
    taskFutures.add(executorService.submit(() -> {
        this.processFile(inputFilePath);
        return null;
    }));
}

// 修改waitToFinish方法处理Future中的异常
public void waitToFinish() throws Throwable {
    executorService.shutdown();
    executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
    
    synchronized (this) {
        for (Future<Void> future : taskFutures) {
            try {
                future.get();
            } catch (ExecutionException e) {
                if (thrownError == null) {
                    thrownError = e.getCause();
                }
            }
        }
        
        if (thrownError != null) {
            System.out.println("Exception: " + thrownError);
            throw thrownError;
        } else {
            System.out.println("No exception: " + thrownError);
        }
    }
}

方案3：自定义ThreadPoolExecutor，重写afterExecute方法

线程池的afterExecute方法会在任务完成后触发（无论正常结束还是抛出异常），可在此处统一处理异常：

public InputFilesParser(int poolSize) {
    this.executorService = new ThreadPoolExecutor(poolSize, poolSize,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>()) {
        @Override
        protected void afterExecute(Runnable r, Throwable t) {
            super.afterExecute(r, t);
            // 直接捕获到任务抛出的异常
            if (t != null) {
                notifyOnException(Thread.currentThread(), t);
            } 
            // 若任务被包装为Future，需通过get()获取异常
            else if (r instanceof Future<?>) {
                try {
                    ((Future<?>) r).get();
                } catch (ExecutionException ee) {
                    notifyOnException(Thread.currentThread(), ee.getCause());
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                } catch (CancellationException ce) {
                    notifyOnException(Thread.currentThread(), ce);
                }
            }
        }
    };
}

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