ExecutorService异常处理方法

在使用ExecutorService时，异常处理是一个重要的方面，因为未捕获的异常可能会导致线程池中的线程意外终止，从而影响应用程序的稳定性和性能。以下是一些处理ExecutorService中异常的方法：

1. 使用Future捕获异常

当你提交一个任务给ExecutorService时，可以使用submit方法返回一个Future对象。通过调用Future.get()方法，你可以捕获任务执行过程中抛出的异常。

ExecutorService executorService = Executors.newFixedThreadPool(10);

Future<?> future = executorService.submit(() -> {
    // 你的任务代码
    throw new RuntimeException("任务执行出错");
});

try {
    future.get(); // 这将抛出任务中抛出的异常
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    // 处理中断异常
} catch (ExecutionException e) {
    Throwable cause = e.getCause();
    // 处理任务执行过程中抛出的异常
    cause.printStackTrace();
}

executorService.shutdown();

2. 使用ThreadFactory自定义线程

你可以通过自定义ThreadFactory来为线程池中的线程设置一个UncaughtExceptionHandler，这样当线程因未捕获的异常而终止时，可以执行一些清理工作或记录日志。

ThreadFactory threadFactory = runnable -> {
    Thread thread = new Thread(runnable);
    thread.setUncaughtExceptionHandler((t, e) -> {
        // 处理未捕获的异常
        e.printStackTrace();
    });
    return thread;
};

ExecutorService executorService = Executors.newFixedThreadPool(10, threadFactory);

executorService.submit(() -> {
    // 你的任务代码
    throw new RuntimeException("任务执行出错");
});

executorService.shutdown();

3. 使用ThreadPoolExecutor的自定义afterExecute方法

如果你使用的是ThreadPoolExecutor，可以重写afterExecute方法来处理任务执行后的异常。

ThreadPoolExecutor executorService = new ThreadPoolExecutor(
    10, 20, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>()) {
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t == null && r instanceof java.util.concurrent.Future<?>) {
            try {
                java.util.concurrent.Future<?> future = (java.util.concurrent.Future<?>) r;
                if (future.isDone()) {
                    future.get();
                }
            } catch (CancellationException ce) {
                t = ce;
            } catch (ExecutionException ee) {
                t = ee.getCause();
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt(); // ignore/reset
            }
        }
        if (t != null) {
            // 处理任务执行过程中抛出的异常
            t.printStackTrace();
        }
    }
};

executorService.submit(() -> {
    // 你的任务代码
    throw new RuntimeException("任务执行出错");
});

executorService.shutdown();

4. 使用CompletableFuture

CompletableFuture提供了更灵活的异常处理机制。你可以使用exceptionally、handle或whenComplete方法来处理异常。

ExecutorService executorService = Executors.newFixedThreadPool(10);

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 你的任务代码
    throw new RuntimeException("任务执行出错");
}, executorService);

future.exceptionally(ex -> {
    // 处理异常
    ex.printStackTrace();
    return null;
});

executorService.shutdown();

通过这些方法，你可以有效地处理ExecutorService中的异常，确保应用程序的稳定性和可靠性。