Java捕获子线程异常以及主线程感知子线程异常

主线程能直接捕获子线程的异常吗？

Java 的线程是独立执行的，每个线程都有自己的执行栈和方法调用。try-catch 块是基于当前线程的调用栈工作的。主线程的 try-catch 只能捕获发生在它自己线程内的异常，而子线程运行在另一个独立的调用栈上，其内部抛出的异常不会传播到主线程的调用栈中。

代码示例证明：

public class MainThreadCannotCatch {
    public static void main(String[] args) {
        try {
            // 主线程启动一个子线程
            Thread childThread = new Thread(() -> {
                // 这个异常发生在子线程内部
                throw new RuntimeException("子线程内部异常！");
            });
            childThread.start();

            // 主线程等待一下子线程结束（即使等待，也捕获不到）
            Thread.sleep(1000);

            System.out.println("主线程正常结束。");

        } catch (Exception e) { 
            // 这里的 catch 块只会捕获主线程自己的异常（如 InterruptedException）
            // 绝对捕获不到上面子线程抛出的 RuntimeException!
            System.out.println("主线程捕获到异常: " + e.getMessage());
        }
    }
}

输出：

Exception in thread "Thread-0" java.lang.RuntimeException: 子线程内部异常！
	at MainThreadCannotCatch.lambda$main$0(MainThreadCannotCatch.java:8)
	at java.lang.Thread.run(Thread.java:748)
主线程正常结束。

可以看到，子线程异常导致线程崩溃并打印了栈轨迹，而主线程的 catch 块完全没有起作用，主线程正常执行完毕。

为每个线程设置未捕获异常处理器 (UncaughtExceptionHandler)

这是最推荐和标准的方式。你可以为单个线程或所有线程设置一个处理器，当线程因未捕获异常而即将终止时，JVM 会回调这个处理器。

public class UncaughtExceptionHandlerDemo {
    public static void main(String[] args) {
        // 创建一个线程
        Thread childThread = new Thread(() -> {
            System.out.println("子线程开始运行...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 模拟一个运行时异常
            throw new RuntimeException("子线程发生未知错误！");
        });

        // 为单个线程设置未捕获异常处理器
        childThread.setUncaughtExceptionHandler((thread, throwable) -> {
            // 这里是在主线程中定义逻辑，但由JVM在子线程终止前调用
            System.err.println("线程 '" + thread.getName() + “‘ 抛出了异常: ” + throwable.getMessage());
            // 这里可以进行日志记录、报警、清理等操作
            // 注意：这个处理逻辑是在发生异常的线程上下文中执行的，而不是主线程。
        });

        // 也可以设置全局默认的处理器，捕获所有线程未处理的异常
        Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
            System.err.println("[全局捕获器] 线程 " + thread.getName() + " 出错了: " + throwable.getMessage());
        });

        childThread.start();

        try {
            // 主线程等待子线程结束，以便观察输出
            childThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("主线程结束。");
    }
}

使用 Future 和 ExecutorService（最佳实践）

通过线程池提交任务（submit() 方法）会返回一个 Future 对象。调用 Future.get() 方法时，主线程会阻塞等待子线程执行完成，并且子线程中的任何异常都会被包装成 ExecutionException 重新抛出，从而可以在主线程中被捕获。

import java.util.concurrent.*;

public class FutureAndExecutorDemo {
    public static void main(String[] args) {
        // 创建一个线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 提交任务，得到 Future 对象
        Future<?> future = executor.submit(() -> {
            System.out.println("通过ExecutorService提交的任务开始执行...");
            throw new RuntimeException("任务执行失败！");
        });

        try {
            // 主线程在这里阻塞，等待任务执行结果
            future.get(); // 这一行会抛出 ExecutionException
        } catch (InterruptedException e) {
            // 处理中断异常
            e.printStackTrace();
        } catch (ExecutionException e) {
            // 这里才是关键！捕获由子线程异常包装而来的 ExecutionException
            // 通过 e.getCause() 获取子线程中抛出的原始异常
            Throwable originalException = e.getCause();
            System.out.println("主线程捕获到子线程的异常: " + originalException.getMessage());
            originalException.printStackTrace();
        } finally {
            // 关闭线程池
            executor.shutdown();
        }
    }
}

这是生产环境中最常用、最可控的方式，因为它结合了线程池管理和完善的异常处理机制。

在 run() 方法内部自行 try-catch

在最源头（run 方法内部）处理掉所有异常，防止异常抛出到线程机制中。

public class InternalTryCatch {
    public static void main(String[] args) {
        Thread childThread = new Thread(() -> {
            try {
                // 将所有业务逻辑放在try块中
                System.out.println("子线程工作...");
                throw new RuntimeException("内部错误");
            } catch (Exception e) {
                // 在线程内部直接处理异常
                System.out.println("子线程自己处理了异常: " + e.getMessage());
                // 可以在这里将异常信息通过共享变量、回调接口等方式传递回主线程
            }
        });

        childThread.start();
    }
}

总结与对比

对于需要从主线程感知子线程异常的场景，优先选择 ExecutorService 和 Future。如果只是想进行最后的日志记录或清理，则使用 UncaughtExceptionHandler。

如何在多个子线程中捕获异常并引发主线程异常？