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

在 Java 线程池中，如果任务执行过程中抛出异常，默认情况下异常会被线程池捕获并记录，但不会直接告诉你具体是哪个线程出了问题。为了定位异常发生的线程和任务，可以通过以下几种方式来实现：

---

1. 使用 Thread.setUncaughtExceptionHandler 设置线程的异常处理器

可以为线程池中的每个线程设置一个自定义的 UncaughtExceptionHandler，当线程抛出未捕获的异常时，会调用该处理器。

示例：

import java.util.concurrent.*;

public class ThreadPoolExceptionHandler {
    public static void main(String[] args) {
        ThreadFactory threadFactory = r -> {
            Thread thread = new Thread(r);
            thread.setUncaughtExceptionHandler((t, e) -> {
                System.err.println("线程 " + t.getName() + " 抛出异常: " + e.getMessage());
            });
            return thread;
        };

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

        executor.execute(() -> {
            throw new RuntimeException("任务1异常");
        });

        executor.execute(() -> {
            throw new RuntimeException("任务2异常");
        });

        executor.shutdown();
    }
}

输出：

线程 pool-1-thread-1 抛出异常: 任务1异常
线程 pool-1-thread-2 抛出异常: 任务2异常

---

2. 在任务中捕获异常并记录

在任务代码中显式捕获异常，并记录线程信息和异常信息。

示例：

import java.util.concurrent.*;

public class TaskExceptionHandling {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.execute(() -> {
            try {
                throw new RuntimeException("任务1异常");
            } catch (Exception e) {
                System.err.println("线程 " + Thread.currentThread().getName() + " 抛出异常: " + e.getMessage());
            }
        });

        executor.execute(() -> {
            try {
                throw new RuntimeException("任务2异常");
            } catch (Exception e) {
                System.err.println("线程 " + Thread.currentThread().getName() + " 抛出异常: " + e.getMessage());
            }
        });

        executor.shutdown();
    }
}

输出：

线程 pool-1-thread-1 抛出异常: 任务1异常
线程 pool-1-thread-2 抛出异常: 任务2异常

---

3. 使用 Future 获取任务执行结果

如果使用 submit() 提交任务，返回的 Future 对象可以捕获任务执行过程中的异常。

示例：

import java.util.concurrent.*;

public class FutureExceptionHandling {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Future<?> future1 = executor.submit(() -> {
            throw new RuntimeException("任务1异常");
        });

        Future<?> future2 = executor.submit(() -> {
            throw new RuntimeException("任务2异常");
        });

        try {
            future1.get();
        } catch (Exception e) {
            System.err.println("任务1抛出异常: " + e.getCause().getMessage());
        }

        try {
            future2.get();
        } catch (Exception e) {
            System.err.println("任务2抛出异常: " + e.getCause().getMessage());
        }

        executor.shutdown();
    }
}

输出：

任务1抛出异常: 任务1异常
任务2抛出异常: 任务2异常

---

4. 自定义线程池的 afterExecute 方法

通过继承 ThreadPoolExecutor 并重写 afterExecute 方法，可以在任务执行完成后检查异常。

示例：

import java.util.concurrent.*;

public class CustomThreadPool extends ThreadPoolExecutor {
    public CustomThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t != null) {
            System.err.println("线程 " + Thread.currentThread().getName() + " 抛出异常: " + t.getMessage());
        }
    }

    public static void main(String[] args) {
        ExecutorService executor = new CustomThreadPool(2, 2, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());

        executor.execute(() -> {
            throw new RuntimeException("任务1异常");
        });

        executor.execute(() -> {
            throw new RuntimeException("任务2异常");
        });

        executor.shutdown();
    }
}

输出：

线程 pool-1-thread-1 抛出异常: 任务1异常
线程 pool-1-thread-2 抛出异常: 任务2异常

---

总结

• UncaughtExceptionHandler：适合为线程池中的线程设置全局异常处理器。
• 任务内捕获异常：适合在任务代码中显式处理异常。
• Future：适合需要获取任务执行结果的场景。
• 自定义线程池：适合需要扩展线程池行为的场景。