17370845950

使用Callable+Future可捕获任务异常，重写afterExecute实现全局监控，通过ThreadFactory设置UncaughtExceptionHandler防止异常丢失，封装Runnable实现灵活处理。

在Java中使用线程池时，异常处理容易被忽略，导致异常“静默”消失，难以排查问题。要正确捕获并处理线程池中的异常，需要理解任务类型（Runnable 或 Callable）以及线程池的执行方式。

1. 使用 Callable 替代 Runnable 获取异常

Runnable 的 run 方法不抛出检查异常，一旦发生异常会直接终止任务且不会传递出来。而 Callable 可以通过返回 Future 对象来获取执行结果或异常。

示例：

ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(() -> {
    throw new RuntimeException("任务执行失败");
});

try {
    String result = future.get(); // 此处会抛出 ExecutionException
} catch (ExecutionException e) {
    Throwable cause = e.getCause(); // 获取原始异常
    System.out.println("捕获异常：" + cause.getMessage());
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}
executor.shutdown();

2. 重写 ThreadPoolExecutor 的 afterExecute 方法

ThreadPoolExecutor 提供了钩子方法 afterExecute，在任务执行完成后调用，可用于统一捕获未处理的异常。

说明：该方法在任务正常结束或抛出异常后都会执行，可以结合 Thread.currentThread().getUncaughtExceptionHandler 判断异常情况。

示例：

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, 4, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>()
) {
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t != null) {
            System.err.println("捕获线程池任务异常：" + t);
        } else if (r instanceof Future) {
            try {
                ((Future) r).get();
            } catch (CancellationException ce) {
                t = ce;
            } catch (ExecutionException ee) {
                t = ee.getCause();
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
            }
            if (t != null) {
                System.err.println("通过 Future 捕获异常：" + t.getMessage());
            }
        }
    }
};

3. 为线程池设置未捕获异常处理器

可以通过 ThreadFactory 设置每个线程的 UncaughtExceptionHandler，用于处理未被捕获的运行时异常。

说明：此方法适用于 Runnable 任务中发生的异常，无法通过返回值感知的情况。

示例：

ThreadFactory factory = r -> {
    Thread t = new Thread(r);
    t.setUncaughtExceptionHandler((thread, exception) ->
        System.err.println("线程 " + thread.getName() + " 发生异常：" + exception.getMessage())
    );
    return t;
};

ExecutorService executor = Executors.newFixedThreadPool(2, factory);
executor.submit(() -> {
    throw new RuntimeException("模拟运行时异常");
});

4. 封装 Runnable 增加异常处理逻辑

在提交任务前手动包装 Runnable，添加 try-catch 块，实现细粒度控制。

优点：灵活，可针对不同任务定制处理策略。

示例：

public class ExceptionHandlingRunnable implements Runnable {
    private final Runnable task;

    public ExceptionHandlingRunnable(Runnable task) {
        this.task = task;
    }

    @Override
    public void run() {
        try {
            task.run();
        } catch (Exception e) {
            System.err.println("任务中捕获异常：" + e.getMessage());
            // 可记录日志、通知监控系统等
        }
    }
}

// 使用
executor.submit(new ExceptionHandlingRunnable(() -> {
    throw new RuntimeException("测试异常");
}));

基本上就这些。关键是根据任务类型选择合适的异常捕获方式：Callable + Future 最直观，afterExecute 适合全局监控，UncaughtExceptionHandler 防止异常丢失，封装 Runnable 则更灵活可控。