如何通过UncaughtExceptionHandler捕获线程池中的未处理异常？

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.lang.Thread.UncaughtExceptionHandler;

public class UncaughtExceptionExample {

    public static void main(String[] args) {
        // 创建一个自定义的异常处理器
        UncaughtExceptionHandler handler = (t, e) -> {
            System.err.println("Thread " + t.getName() + " threw an exception: " + e.getMessage());
            // 在这里添加你自己的异常处理逻辑，例如记录日志、发送警报等
        };

        // 设置默认的异常处理器
        Thread.setDefaultUncaughtExceptionHandler(handler);

        // 创建一个线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskNumber = i;
            executor.submit(() -> {
                // 模拟一个可能抛出异常的任务
                if (taskNumber % 2 == 0) {
                    throw new RuntimeException("Task " + taskNumber + " failed!");
                } else {
                    System.out.println("Task " + taskNumber + " completed successfully.");
                }
            });
        }

        executor.shutdown();
    }
}

import java.util.concurrent.*;
import java.lang.Thread.UncaughtExceptionHandler;

public class ThreadPoolExceptionHandler {

    public static void main(String[] args) {
        // 创建第一个线程池及其异常处理器
        UncaughtExceptionHandler handler1 = (t, e) -> {
            System.err.println("ThreadPool1: Thread " + t.getName() + " threw an exception: " + e.getMessage());
        };

        ThreadFactory threadFactory1 = r -> {
            Thread thread = new Thread(r);
            thread.setUncaughtExceptionHandler(handler1);
            return thread;
        };

        ExecutorService executor1 = Executors.newFixedThreadPool(5, threadFactory1);

        // 创建第二个线程池及其异常处理器
        UncaughtExceptionHandler handler2 = (t, e) -> {
            System.err.println("ThreadPool2: Thread " + t.getName() + " threw an exception: " + e.getMessage());
        };

        ThreadFactory threadFactory2 = r -> {
            Thread thread = new Thread(r);
            thread.setUncaughtExceptionHandler(handler2);
            return thread;
        };

        ExecutorService executor2 = Executors.newFixedThreadPool(5, threadFactory2);

        // 提交任务到线程池，模拟异常
        executor1.submit(() -> { throw new RuntimeException("Exception in ThreadPool1"); });
        executor2.submit(() -> { throw new RuntimeException("Exception in ThreadPool2"); });

        executor1.shutdown();
        executor2.shutdown();
    }
}

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

import java.util.concurrent.*;

public class LoggingExceptionHandler {

    private static final Logger logger = LoggerFactory.getLogger(LoggingExceptionHandler.class);

    public static void main(String[] args) {
        UncaughtExceptionHandler handler = (t, e) -> {
            logger.error("Thread {} threw an exception: ", t.getName(), e);
            // 可以添加更多处理逻辑，例如发送警报
        };

        ThreadFactory threadFactory = r -> {
            Thread thread = new Thread(r);
            thread.setUncaughtExceptionHandler(handler);
            return thread;
        };

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

        executor.submit(() -> {
            throw new RuntimeException("Simulated exception for logging.");
        });

        executor.shutdown();
    }
}

import java.util.concurrent.*;

public class FutureExceptionHandler {

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

        Future<String> future = executor.submit(() -> {
            throw new RuntimeException("Exception from Future task.");
        });

        try {
            String result = future.get(); // 可能会抛出 ExecutionException
            System.out.println("Result: " + result);
        } catch (InterruptedException e) {
            System.err.println("Task interrupted: " + e.getMessage());
        } catch (ExecutionException e) {
            System.err.println("Task failed: " + e.getMessage());
            Throwable cause = e.getCause(); // 获取原始异常
            if (cause != null) {
                System.err.println("Cause: " + cause.getMessage());
            }
        } finally {
            executor.shutdown();
        }
    }
}