面试题：Java 线程池内部任务出异常后，如何知道是哪个线程出了异常？

在 Java 中，当你使用线程池（如 ThreadPoolExecutor 或其更高级别的封装如 Executors.newFixedThreadPool() 等）执行任务时，如果任务内部抛出了未捕获的异常，默认情况下这个异常不会直接反馈给主线程或导致整个应用程序崩溃。

不过，有几种方式可以捕获并处理这些异常，从而识别出是哪个线程出现了问题。

方法 1: 使用 Thread.UncaughtExceptionHandler

虽然每个 Thread 实例都可以设置一个 UncaughtExceptionHandler 来处理未捕获的异常，但在使用线程池的情况下，由于线程是复用的，所以这种方法不是特别适用。不过，如果你确实想要为线程池中的线程设置一个默认的异常处理器，可以通过自定义 ThreadFactory 来实现：

ThreadFactory threadFactory = new ThreadFactory() {
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println("线程 " + t.getName() + " 抛出了未捕获的异常: " + e.getMessage());
            }
        });
        return thread;
    }
};

ExecutorService executorService = Executors.newFixedThreadPool(2, threadFactory);

但是请注意，这种方式只能捕捉到那些在线程生命周期内发生的异常，对于通过 execute() 方法提交的任务，如果它们本身没有被设计成无限循环或者长期运行的任务，那么这种异常处理器可能不会触发。

方法 2: 在 Runnable 或 Callable 内部处理异常

更好的做法是在你提交给线程池的任务内部处理异常。无论是 Runnable 还是 Callable 接口，你都可以在其实现中加入异常处理逻辑：

• 对于 Runnable，你可以直接在 run() 方法中使用 try-catch 块来捕获异常。
• 对于 Callable，它允许返回结果并且可以抛出受检异常，因此更适合需要处理异常的情况。你可以通过 Future.get() 方法获取执行结果或异常。

public class Task implements Callable<String> {
    private final String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        try {
            // 模拟任务逻辑
            if (new Random().nextBoolean()) {
                throw new RuntimeException("模拟异常");
            }
            return name + ": 完成";
        } catch (Exception e) {
            System.out.println(name + " 发生了异常: " + e.getMessage());
            throw e; // 如果你想让调用者也能看到异常，则需要重新抛出
        }
    }
}

// 提交任务并处理异常
ExecutorService executorService = Executors.newFixedThreadPool(2);
Future<String> future = executorService.submit(new Task("Task1"));
try {
    String result = future.get(); // 如果任务抛出异常，这里也会抛出
    System.out.println(result);
} catch (ExecutionException e) {
    System.err.println("任务执行失败: " + e.getCause().getMessage());
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    System.err.println("任务被中断");
}

方法 3: 使用 afterExecute 回调

ThreadPoolExecutor 类提供了一个可以重写的 afterExecute 方法，该方法会在每个任务执行完毕后被调用，并且可以用来检测是否有异常发生。这是监控和记录异常的一种有效方式：

ThreadPoolExecutor executor = new ThreadPoolExecutor(
        2, 2, 0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<>()) {
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t == null && r instanceof Future<?>) {
            try {
                Future<?> future = (Future<?>) r;
                if (future.isDone()) {
                    future.get();
                }
            } catch (CancellationException ce) {
                t = ce;
            } catch (ExecutionException ee) {
                t = ee.getCause();
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt(); // 保留中断状态
            }
        }
        if (t != null) {
            System.out.println("线程池检测到异常: " + t.getMessage());
        }
    }
};

这种方法允许你在任务完成后检查是否有异常，并根据异常信息进行相应的处理。

综上所述，为了知道哪个线程出了异常，最直接的方法是在任务内部处理异常并通过日志或其他手段记录相关信息。此外，利用 ThreadPoolExecutor 的 afterExecute 方法也是一种有效的监控手段。