JAVA线程池异常丢失的原因分析与自定义异常捕获方案

大家好，今天我们来聊聊Java线程池中异常丢失的问题。这是一个在并发编程中经常被忽视，但又非常关键的问题。如果不了解其背后的原理，很容易导致程序在运行时出现一些难以追踪的bug。

线程池异常丢失的常见场景

在Java中，使用线程池ExecutorService提交任务时，主要有两种方式：execute(Runnable)和submit(Callable)。这两种方式处理异常的方式有所不同，也是导致异常丢失的主要原因。

使用 execute(Runnable) 提交任务：

execute() 方法接受一个 Runnable 接口，Runnable 接口的 run() 方法没有声明抛出任何已检查异常。这意味着如果在 run() 方法内部抛出了一个未捕获的异常，JVM 会直接将异常打印到控制台（如果配置了），但不会向上层调用者抛出。线程池会默默地吞噬这个异常，导致我们无法感知任务执行失败。
```
ExecutorService executor = Executors.newFixedThreadPool(1);
executor.execute(() -> {
    System.out.println("Task started.");
    throw new RuntimeException("Something went wrong in Runnable task!");
});

executor.shutdown();
try {
    executor.awaitTermination(1, TimeUnit.MINUTES);
} catch (InterruptedException e) {
    e.printStackTrace();
}
```
在这个例子中，RuntimeException 会被抛出，但线程池并不会将它传递给主线程，导致我们无法在主线程中处理这个异常。
使用 submit(Callable) 提交任务：

submit() 方法接受一个 Callable 接口，Callable 接口的 call() 方法声明可以抛出异常。submit() 方法会返回一个 Future 对象，我们可以通过 Future.get() 方法获取任务的执行结果。但是，即使 call() 方法内部抛出了异常，这个异常也不会立即被抛出。只有当我们调用 Future.get() 方法时，异常才会被封装成 ExecutionException 抛出。如果忘记调用 Future.get()，异常也会被丢失。
```
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<?> future = executor.submit(() -> {
    System.out.println("Task started.");
    throw new Exception("Something went wrong in Callable task!");
    //return "Task completed.";
});

executor.shutdown();
try {
    executor.awaitTermination(1, TimeUnit.MINUTES);
} catch (InterruptedException e) {
    e.printStackTrace();
}

// 忘记调用 future.get()，异常将会被丢失
// try {
//     future.get(); // 调用 get() 方法会抛出 ExecutionException
// } catch (InterruptedException | ExecutionException e) {
//     e.printStackTrace();
// }
```
在这个例子中，Exception 会被抛出，但只有当我们调用 future.get() 方法时，才能捕获到这个异常。如果注释掉 future.get() 的调用，异常将会被丢失。
线程池内部异常处理机制：

线程池内部的线程在执行任务时，如果遇到未捕获的异常，默认情况下会调用 Thread.UncaughtExceptionHandler 来处理异常。如果线程没有设置 UncaughtExceptionHandler，那么异常会被 JVM 打印到控制台，然后线程结束。这也就解释了为什么即使异常被抛出，主线程也无法感知到。

为什么会发生异常丢失？

Runnable.run() 方法的限制： Runnable.run() 方法的设计不允许抛出已检查异常，这使得我们无法在方法签名中声明可能抛出的异常，也无法强制调用者处理异常。
Future.get() 的延迟性： Future.get() 方法只有在调用时才会抛出异常，这使得我们很容易忘记调用 get() 方法，从而导致异常丢失。
线程池的异常处理机制： 线程池内部的异常处理机制默认只是简单地打印异常信息，而不会将异常传递给主线程。

自定义异常捕获方案

为了避免异常丢失，我们需要自定义异常捕获方案。以下是一些常用的方法：

使用 try-catch 块捕获异常：

最简单的方法是在 Runnable.run() 或 Callable.call() 方法中使用 try-catch 块捕获异常，并将异常信息记录到日志中。

ExecutorService executor = Executors.newFixedThreadPool(1);
executor.execute(() -> {
    try {
        System.out.println("Task started.");
        throw new RuntimeException("Something went wrong in Runnable task!");
    } catch (Exception e) {
        System.err.println("Exception caught in Runnable: " + e.getMessage());
        // 记录日志
    }
});

这种方法简单易用，但需要在每个任务中都添加 try-catch 块，代码冗余。

自定义 ThreadFactory：

我们可以通过自定义 ThreadFactory 来设置线程的 UncaughtExceptionHandler，从而在线程抛出未捕获的异常时，执行自定义的异常处理逻辑。

class MyThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setUncaughtExceptionHandler((t, e) -> {
            System.err.println("Uncaught exception in thread " + t.getName() + ": " + e.getMessage());
            // 记录日志
        });
        return thread;
    }
}

ExecutorService executor = Executors.newFixedThreadPool(1, new MyThreadFactory());
executor.execute(() -> {
    System.out.println("Task started.");
    throw new RuntimeException("Something went wrong in Runnable task!");
});

这种方法可以集中处理所有线程的未捕获异常，避免了在每个任务中都添加 try-catch 块的冗余。

使用 Future.get() 获取异常：

在使用 submit(Callable) 提交任务时，一定要调用 Future.get() 方法获取任务的执行结果。如果在 call() 方法内部抛出了异常，Future.get() 方法会抛出 ExecutionException，我们可以捕获这个异常并进行处理。

ExecutorService executor = Executors.newFixedThreadPool(1);
Future<?> future = executor.submit(() -> {
    System.out.println("Task started.");
    throw new Exception("Something went wrong in Callable task!");
    //return "Task completed.";
});

executor.shutdown();
try {
    executor.awaitTermination(1, TimeUnit.MINUTES);
} catch (InterruptedException e) {
    e.printStackTrace();
}

try {
    future.get(); // 调用 get() 方法会抛出 ExecutionException
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
    //处理异常
}

这种方法可以确保我们能够捕获到 Callable 任务中抛出的异常。

自定义 ThreadPoolExecutor：

可以通过继承 ThreadPoolExecutor 并重写 afterExecute 方法，该方法在每个任务执行完毕后被调用，可以用来处理任务执行过程中抛出的异常。

class MyThreadPoolExecutor extends ThreadPoolExecutor {

   public MyThreadPoolExecutor(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 && r instanceof Future<?>) {
           try {
               Future<?> future = (Future<?>) r;
               if (future.isDone()) {
                   future.get(); // 获取 Future 的结果，如果任务抛出异常，这里会抛出 ExecutionException
               }
           } catch (InterruptedException | ExecutionException e) {
               t = e;
           }
       }
       if (t != null) {
           System.err.println("Exception in thread pool: " + t.getMessage());
           // 处理异常
       }
   }
}

public class Main {
   public static void main(String[] args) {
       MyThreadPoolExecutor executor = new MyThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
       executor.execute(() -> {
           System.out.println("Task started.");
           throw new RuntimeException("Something went wrong in Runnable task!");
       });

       executor.shutdown();
       try {
           executor.awaitTermination(1, TimeUnit.MINUTES);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}

在这个例子中，afterExecute 方法会检查任务是否是 Future 类型，如果是，则调用 Future.get() 方法获取任务的执行结果。如果任务抛出异常，Future.get() 方法会抛出 ExecutionException，我们可以捕获这个异常并进行处理。同时，也处理直接抛出的异常Throwable t。这种方式适用于统一处理线程池中所有任务的异常。

不同方案的比较

方案	优点	缺点	适用场景
`try-catch` 块	简单易用	代码冗余，需要在每个任务中都添加 `try-catch` 块	适用于简单的任务，或者只需要对特定任务进行异常处理的场景
自定义 `ThreadFactory`	可以集中处理所有线程的未捕获异常，避免了在每个任务中都添加 `try-catch` 块的冗余	无法区分不同任务的异常，所有异常都由同一个 `UncaughtExceptionHandler` 处理	适用于需要统一处理所有线程的未捕获异常，但不需要区分不同任务的异常的场景
`Future.get()`	可以确保我们能够捕获到 `Callable` 任务中抛出的异常	需要显式地调用 `Future.get()` 方法，容易忘记调用	适用于使用 `submit(Callable)` 提交任务，并且需要确保能够捕获到任务中抛出的异常的场景
自定义 `ThreadPoolExecutor`	可以统一处理线程池中所有任务的异常，避免了在每个任务中都添加 `try-catch` 块的冗余，并且可以区分不同任务的异常（通过 `Future` 对象）	需要继承 `ThreadPoolExecutor` 并重写 `afterExecute` 方法，代码相对复杂	适用于需要统一处理线程池中所有任务的异常，并且需要区分不同任务的异常的场景，例如需要根据异常类型进行不同的处理，或者需要将异常信息记录到日志中

最佳实践

优先使用 submit(Callable) 提交任务： Callable 接口允许抛出异常，并且可以通过 Future.get() 方法捕获异常，比 Runnable 接口更安全。
始终调用 Future.get() 方法： 无论任务是否成功完成，都应该调用 Future.get() 方法，以确保能够捕获到任务中抛出的异常。
使用自定义 ThreadFactory 或 ThreadPoolExecutor： 如果需要统一处理所有线程的未捕获异常，或者需要区分不同任务的异常，可以使用自定义 ThreadFactory 或 ThreadPoolExecutor。
记录异常信息： 无论使用哪种方法捕获异常，都应该将异常信息记录到日志中，以便于排查问题。
考虑异常处理策略： 根据业务需求，制定合适的异常处理策略。例如，可以重试失败的任务，或者将任务添加到死信队列中。

代码示例：综合方案

下面是一个综合的示例，展示了如何使用自定义 ThreadPoolExecutor 和 Future.get() 方法来捕获和处理异常。

import java.util.concurrent.*;

class MyThreadPoolExecutor extends ThreadPoolExecutor {

    public MyThreadPoolExecutor(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 && r instanceof Future<?>) {
            try {
                Future<?> future = (Future<?>) r;
                if (future.isDone()) {
                    future.get(); // 获取 Future 的结果，如果任务抛出异常，这里会抛出 ExecutionException
                }
            } catch (InterruptedException | ExecutionException e) {
                t = e;
            }
        }
        if (t != null) {
            System.err.println("Exception in thread pool: " + t.getMessage());
            // 记录日志
            // 可以根据异常类型进行不同的处理，例如重试任务或者将任务添加到死信队列
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThreadPoolExecutor executor = new MyThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());

        Future<?> future = executor.submit(() -> {
            System.out.println("Task started.");
            throw new Exception("Something went wrong in Callable task!");
            //return "Task completed.";
        });

        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

总结：关注异常，做好处理

总结一下，Java线程池异常丢失是一个常见的问题，但通过了解其背后的原理，并使用合适的异常捕获方案，我们可以有效地避免这个问题。关键在于，要认识到线程池对异常的默认处理行为，并主动地采取措施来捕获和处理异常，保证程序的健壮性。选择合适的方案取决于具体的业务需求和代码复杂度。