在Java中如何捕获并处理多线程异常

在Java多线程开发中，线程内部抛出的未捕获异常不会传递到主线程，常规的try-catch语句也无法直接捕获其他线程中抛出的异常，因此需要特定的机制来处理多线程场景下的异常问题。

单个线程的异常捕获：UncaughtExceptionHandler

Java提供了Thread.UncaughtExceptionHandler接口，用于处理线程中未被捕获的异常。每个线程都可以设置一个自定义的异常处理器，当线程因未捕获异常终止时，会回调该处理器的uncaughtException方法。

首先定义自定义异常处理器：

public class CustomExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("线程" + t.getName() + "抛出未捕获异常：");
        e.printStackTrace();
    }
}

然后为线程设置该处理器：

public class ThreadExceptionDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            // 模拟线程内抛出异常
            throw new RuntimeException("线程执行出错");
        });
        // 设置自定义异常处理器
        thread.setUncaughtExceptionHandler(new CustomExceptionHandler());
        thread.start();
    }
}

如果需要为所有线程设置默认的异常处理器，可以调用Thread.setDefaultUncaughtExceptionHandler方法，所有未单独设置处理器的线程都会使用这个默认处理器。

线程池场景下的异常处理

使用线程池执行任务时，直接提交Runnable任务抛出的异常也无法通过外部try-catch捕获，需要根据提交任务的方式选择不同的处理方案。

提交Callable任务

通过submit方法提交Callable任务，任务抛出的异常会被封装到返回的Future对象中，调用Future.get()方法时可以捕获到异常。

import java.util.concurrent.*;

public class ThreadPoolExceptionDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        // 提交Callable任务
        Future<String> future = executor.submit(() -> {
            throw new RuntimeException("Callable任务执行出错");
        });
        try {
            // 获取任务结果，此时会抛出执行过程中的异常
            future.get();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (ExecutionException e) {
            System.out.println("捕获到任务执行异常：");
            e.getCause().printStackTrace();
        }
        executor.shutdown();
    }
}

自定义线程池的线程工厂

如果需要处理线程池中Runnable任务的异常，可以自定义线程工厂，为线程池中的线程统一设置UncaughtExceptionHandler。

import java.util.concurrent.*;

public class ThreadPoolFactoryDemo {
    public static void main(String[] args) {
        ThreadFactory threadFactory = r -> {
            Thread thread = new Thread(r);
            thread.setUncaughtExceptionHandler((t, e) -> {
                System.out.println("线程池线程" + t.getName() + "抛出异常：");
                e.printStackTrace();
            });
            return thread;
        };
        ExecutorService executor = Executors.newFixedThreadPool(2, threadFactory);
        executor.execute(() -> {
            throw new RuntimeException("Runnable任务执行出错");
        });
        executor.shutdown();
    }
}

不同处理方式的适用场景

可以根据实际开发需求选择合适的异常处理方式：

• 如果是单个独立线程，直接设置UncaughtExceptionHandler即可，实现简单，针对性强。
• 如果线程池需要获取任务执行结果或者处理任务异常，优先使用Callable配合Future的方式，逻辑更清晰。
• 如果线程池主要是执行不需要返回结果的Runnable任务，自定义线程工厂统一设置异常处理器可以减少重复代码。

需要注意，线程池的execute方法提交的Runnable任务，如果未设置线程的异常处理器，异常会被线程池吞掉，不会主动抛出，因此一定要做好异常处理，避免问题排查困难。

Java多线程线程异常捕获UncaughtExceptionHandler线程池异常处理修改时间：2026-06-04 03:22:03