主线程运行了多个子线程任务，如果出现异常怎么知道问题在哪个子任务中

在Java中，主线程启动多个子线程后，若要定位具体哪个子线程抛出异常，可通过以下几种方式实现：

一、为每个线程设置独立的异常处理器

通过 Thread.setUncaughtExceptionHandler() 为每个线程指定异常处理器，可直接获取异常线程和异常信息：

Thread thread1 = new Thread(() -> {
    throw new RuntimeException("线程1异常");
});

thread1.setUncaughtExceptionHandler((t, e) -> {
    System.err.println("线程 [" + t.getName() + "] 抛出异常: " + e.getMessage());
    e.printStackTrace(); // 打印完整堆栈
});

thread1.start();

关键逻辑：

• UncaughtExceptionHandler 会在线程因未捕获的异常终止时被调用
• 处理器中可获取线程对象 t 和异常对象 e
• 建议为线程设置有意义的名称（thread.setName("订单处理线程")）

二、使用线程池时通过 Future.get() 捕获异常

若使用 ExecutorService 提交任务，可通过 Future.get() 获取异常：

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

try {
    future.get(); // 阻塞等待任务完成，若异常会在此抛出
} catch (ExecutionException e) {
    Throwable cause = e.getCause(); // 获取原始异常
    System.err.println("任务执行失败: " + cause.getMessage());
}

注意事项：

• submit() 方法会将异常封装在 ExecutionException 中
• 调用 get() 时才会抛出异常，若不调用则无法发现异常
• 适用于需要等待任务结果的场景

三、自定义线程工厂统一处理异常

通过自定义线程工厂，为所有创建的线程设置统一的异常处理器：

public class CustomThreadFactory implements ThreadFactory {
    private final String namePrefix;

    public CustomThreadFactory(String namePrefix) {
        this.namePrefix = namePrefix;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setName(namePrefix + "-" + t.getId());
        t.setUncaughtExceptionHandler((thread, ex) -> {
            System.err.println("线程 [" + thread.getName() + "] 异常: " + ex.getMessage());
            ex.printStackTrace();
        });
        return t;
    }
}

// 使用自定义线程工厂创建线程池
ExecutorService executor = Executors.newFixedThreadPool(2, new CustomThreadFactory("订单处理"));

四、使用 CompletableFuture 处理异步异常

CompletableFuture 提供了更灵活的异常处理方式：

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    throw new RuntimeException("异步任务异常");
});

future.exceptionally(ex -> {
    System.err.println("捕获异常: " + ex.getMessage());
    return null;
});

其他常用方法：

• handle()：无论是否异常都会执行
• whenComplete()：类似 handle，但不返回值

五、设置全局默认异常处理器

通过 Thread.setDefaultUncaughtExceptionHandler() 为所有线程设置默认处理器：

Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
    System.err.println("全局捕获 - 线程 [" + t.getName() + "] 异常: " + e.getMessage());
});

// 所有未显式设置处理器的线程都会使用此默认处理器
new Thread(() -> {
    throw new RuntimeException("未处理异常");
}).start();

注意：

• 若线程已设置专属处理器，默认处理器不会生效
• 对守护线程（Daemon Thread）可能不生效

六、结合日志框架增强定位能力

使用 SLF4J/Logback 等日志框架，记录线程上下文信息：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class OrderProcessor implements Runnable {
    private static final Logger logger = LoggerFactory.getLogger(OrderProcessor.class);
    private final Long orderId;

    public OrderProcessor(Long orderId) {
        this.orderId = orderId;
    }

    @Override
    public void run() {
        try {
            // MDC 可绑定上下文信息到日志
            MDC.put("orderId", String.valueOf(orderId));
            processOrder();
        } catch (Exception e) {
            logger.error("处理订单失败", e); // 自动记录线程名和堆栈
        } finally {
            MDC.clear();
        }
    }
}

日志输出示例：

2023-06-15 10:23:45 [订单处理线程-1] ERROR OrderProcessor - 处理订单失败
java.lang.RuntimeException: 库存不足
    at OrderProcessor.processOrder(OrderProcessor.java:25)
    ...

七、使用工具辅助定位

1. VisualVM/YourKit 等工具：

   • 监控线程状态，查看异常堆栈
   • 分析线程 dump 文件（jstack <pid>）

2. AOP 切面拦截：

   @Aspect
   public class ThreadExceptionAspect {
       @Around("execution(* com.example.service.*.*(..))")
       public Object logException(ProceedingJoinPoint joinPoint) throws Throwable {
           try {
               return joinPoint.proceed();
           } catch (Exception e) {
               logger.error("方法 {} 异常", joinPoint.getSignature().getName(), e);
               throw e;
           }
       }
   }
   

八、最佳实践总结

1. 为线程命名：使用 thread.setName() 或自定义线程工厂
2. 显式捕获异常：在 Runnable/Callable 中使用 try-catch
3. 统一异常处理：通过 setUncaughtExceptionHandler 集中处理
4. 使用线程池：结合 Future 主动获取异常
5. 日志增强：
   • 使用 MDC 绑定请求ID、订单ID等上下文信息
   • 配置日志格式包含线程名（%thread）
6. 监控告警：集成 Prometheus/Grafana 监控线程池状态和异常率

通过以上方法，可快速定位多线程环境中的异常来源，提升调试效率。