Spring Boot中使用@Async异步任务吞异常问题的根因分析 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Spring Boot @Async 异步任务异常吞噬问题深度剖析

大家好！今天我们来深入探讨一个在 Spring Boot 异步编程中经常遇到的问题：@Async 异步任务异常被吞噬。这个问题看似简单，但其根源往往比较隐蔽，如果不加以重视，可能会导致程序在出现异常时无法及时发现和处理，造成数据不一致，甚至系统崩溃。

1. 什么是“异常吞噬”？

“异常吞噬”是指程序在执行过程中抛出了异常，但是由于某种原因，这个异常没有被正确地捕获和处理，导致程序继续执行，好像异常根本没有发生过一样。在异步任务中，由于任务运行在独立的线程中，如果主线程没有正确地处理子线程抛出的异常，就很容易出现异常吞噬的情况。

2. @Async 的基本原理

在 Spring Boot 中，使用 @Async 注解可以方便地将一个方法声明为异步方法。Spring 会使用线程池来执行这些异步方法，从而实现并发执行。

@Service
public class AsyncService {

    @Async
    public void asyncTask(String taskName) {
        System.out.println("开始执行异步任务：" + taskName + "，线程：" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000); // 模拟耗时操作
            if (taskName.equals("Task3")) {
                throw new RuntimeException("任务 Task3 执行失败!");
            }
            System.out.println("异步任务：" + taskName + " 执行完成，线程：" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("异步任务：" + taskName + " 被中断，线程：" + Thread.currentThread().getName());
        }
    }
}

@SpringBootApplication
@EnableAsync
public class AsyncApplication implements CommandLineRunner {

    @Autowired
    private AsyncService asyncService;

    public static void main(String[] args) {
        SpringApplication.run(AsyncApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        asyncService.asyncTask("Task1");
        asyncService.asyncTask("Task2");
        asyncService.asyncTask("Task3");
        System.out.println("主线程继续执行...");
        Thread.sleep(5000); // 确保异步任务有足够的时间执行完成
    }
}

这段代码中，asyncTask 方法被 @Async 注解标记，因此 Spring 会将其异步执行。AsyncApplication 实现了 CommandLineRunner 接口，在应用启动后会调用 run 方法，启动三个异步任务。其中 Task3 会抛出一个运行时异常。

3. 异常吞噬的几种常见情况和根因分析

3.1 默认的异常处理机制：无作为

默认情况下，@Async 异步任务抛出的异常会被 Spring 内部的 SimpleAsyncTaskExecutor（或者你配置的其他 TaskExecutor）捕获，但仅仅会打印到日志中，并不会向主线程抛出。这意味着，主线程无法感知到异步任务的失败，从而无法进行相应的处理。

根因： SimpleAsyncTaskExecutor 的 execute 方法中，捕获了 Runnable 的 run 方法中抛出的任何异常，然后仅仅打印到日志，没有做进一步处理。

示例： 在上面的代码中，Task3 会抛出异常，但如果你运行这段代码，你会发现主线程会继续执行，而异常只是在控制台中打印出来，并没有中断主线程的执行。

解决方法： 这是最常见的情况，也是最容易被忽略的情况。解决的办法就是自定义异常处理机制，稍后我们会详细介绍。

3.2 使用 Future 但未正确处理 ExecutionException

可以通过返回 Future 对象的方式来获取异步任务的执行结果。但是，如果异步任务抛出了异常，Future.get() 方法会抛出一个 ExecutionException，这个异常包装了异步任务中抛出的原始异常。如果主线程没有正确地处理 ExecutionException，那么原始异常就会被吞噬。

根因： Future.get() 方法会将异步任务中抛出的异常包装成 ExecutionException，如果主线程只捕获了 Exception，而没有具体处理 ExecutionException，或者直接忽略了 ExecutionException，那么原始异常就会丢失。

示例：

@Service
public class AsyncService {

    @Async
    public Future<String> asyncTaskWithFuture(String taskName) {
        System.out.println("开始执行异步任务：" + taskName + "，线程：" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000); // 模拟耗时操作
            if (taskName.equals("Task3")) {
                throw new RuntimeException("任务 Task3 执行失败!");
            }
            System.out.println("异步任务：" + taskName + " 执行完成，线程：" + Thread.currentThread().getName());
            return new AsyncResult<>("Task " + taskName + " 完成");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("异步任务：" + taskName + " 被中断，线程：" + Thread.currentThread().getName());
            return new AsyncResult<>(new RuntimeException("Task " + taskName + " 被中断"));
        }
    }
}

@SpringBootApplication
@EnableAsync
public class AsyncApplication implements CommandLineRunner {

    @Autowired
    private AsyncService asyncService;

    public static void main(String[] args) {
        SpringApplication.run(AsyncApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        Future<String> future1 = asyncService.asyncTaskWithFuture("Task1");
        Future<String> future2 = asyncService.asyncTaskWithFuture("Task2");
        Future<String> future3 = asyncService.asyncTaskWithFuture("Task3");

        try {
            System.out.println("Task1 result: " + future1.get());
            System.out.println("Task2 result: " + future2.get());
            System.out.println("Task3 result: " + future3.get()); // 这里会抛出 ExecutionException
        } catch (Exception e) {
            System.err.println("捕获到异常: " + e.getMessage()); // 只能看到 ExecutionException 的 message
            // e.getCause() 可以获取原始异常
        }

        System.out.println("主线程继续执行...");
        Thread.sleep(5000); // 确保异步任务有足够的时间执行完成
    }
}

在上面的代码中，Task3 会抛出异常，future3.get() 会抛出 ExecutionException。如果只捕获 Exception，那么只能看到 ExecutionException 的 message，而无法获取到原始的 RuntimeException。

解决方法： 需要捕获 ExecutionException，并使用 ExecutionException.getCause() 方法来获取原始异常。

3.3 使用 CompletableFuture 但未正确处理异常

CompletableFuture 是 Java 8 引入的更强大的异步编程工具。它提供了更丰富的 API 来处理异步任务的结果和异常。但是，如果在使用 CompletableFuture 时没有正确地处理异常，同样会导致异常吞噬。

根因： CompletableFuture 提供了多种方式来处理异常，例如 exceptionally、handle、whenComplete 等。如果这些方法使用不当，可能会导致异常被忽略。例如，如果使用 exceptionally 方法，但是返回了 null，那么原始异常就被吞噬了。

示例：

@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> asyncTaskWithCompletableFuture(String taskName) {
        System.out.println("开始执行异步任务：" + taskName + "，线程：" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000); // 模拟耗时操作
            if (taskName.equals("Task3")) {
                throw new RuntimeException("任务 Task3 执行失败!");
            }
            System.out.println("异步任务：" + taskName + " 执行完成，线程：" + Thread.currentThread().getName());
            return CompletableFuture.completedFuture("Task " + taskName + " 完成");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("异步任务：" + taskName + " 被中断，线程：" + Thread.currentThread().getName());
            return CompletableFuture.failedFuture(new RuntimeException("Task " + taskName + " 被中断"));
        }
    }
}

@SpringBootApplication
@EnableAsync
public class AsyncApplication implements CommandLineRunner {

    @Autowired
    private AsyncService asyncService;

    public static void main(String[] args) {
        SpringApplication.run(AsyncApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        CompletableFuture<String> future1 = asyncService.asyncTaskWithCompletableFuture("Task1");
        CompletableFuture<String> future2 = asyncService.asyncTaskWithCompletableFuture("Task2");
        CompletableFuture<String> future3 = asyncService.asyncTaskWithCompletableFuture("Task3");

        try {
            System.out.println("Task1 result: " + future1.get());
            System.out.println("Task2 result: " + future2.get());
            System.out.println("Task3 result: " + future3.exceptionally(e -> {
               // 处理异常，但是返回 null，导致异常被吞噬
                System.err.println("Task3 发生异常: " + e.getMessage());
                return null; // 错误的做法
            }).get());
        } catch (Exception e) {
            System.err.println("捕获到异常: " + e.getMessage());
        }

        System.out.println("主线程继续执行...");
        Thread.sleep(5000); // 确保异步任务有足够的时间执行完成
    }
}

在上面的代码中，future3.exceptionally 方法处理了异常，但是返回了 null，导致 get() 方法抛出了 NullPointerException，而不是原始的 RuntimeException。

解决方法： 在使用 CompletableFuture 处理异常时，需要确保返回一个有意义的值，或者使用 handle 或 whenComplete 方法来处理异常，而不是吞噬它。

3.4 自定义线程池配置不当

Spring Boot 允许你自定义线程池来执行异步任务。如果线程池的配置不当，例如 RejectedExecutionHandler 使用了 DiscardPolicy 或 DiscardOldestPolicy，那么当任务被拒绝执行时，可能会导致异常被吞噬。

根因： DiscardPolicy 和 DiscardOldestPolicy 会直接丢弃被拒绝的任务，而不会抛出任何异常。

解决方法： 在自定义线程池时，应该选择合适的 RejectedExecutionHandler。常用的选项包括：
- AbortPolicy (默认)：抛出 RejectedExecutionException。
- CallerRunsPolicy：在调用者的线程中执行被拒绝的任务。
- DiscardPolicy：直接丢弃被拒绝的任务，不抛出异常。
- DiscardOldestPolicy：丢弃队列中最老的任务，然后尝试重新提交被拒绝的任务。
应该避免使用 DiscardPolicy 和 DiscardOldestPolicy，除非你明确知道这样做不会导致问题。

4. 如何避免 @Async 异步任务异常被吞噬？

4.1 实现 AsyncConfigurer 接口，自定义异常处理机制

这是最常用的方法，也是推荐的方法。通过实现 AsyncConfigurer 接口，你可以自定义 TaskExecutor 和 AsyncUncaughtExceptionHandler。

TaskExecutor：用于执行异步任务的线程池。
AsyncUncaughtExceptionHandler：用于处理异步任务中未捕获的异常。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("MyAsync-");
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new MyAsyncExceptionHandler();
    }
}

public class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        System.err.println("异步任务发生异常: " + ex.getMessage());
        System.err.println("方法名: " + method.getName());
        Arrays.stream(params).forEach(param -> System.err.println("参数: " + param));
        // 在这里可以进行更复杂的异常处理，例如发送邮件、记录日志等
    }
}

在上面的代码中，我们自定义了一个 AsyncUncaughtExceptionHandler，用于处理异步任务中未捕获的异常。当异步任务抛出异常时，handleUncaughtException 方法会被调用，我们可以在这个方法中进行自定义的异常处理。

4.2 使用 Future 或 CompletableFuture，并正确处理异常

如果使用了 Future 或 CompletableFuture，需要确保捕获 ExecutionException，并使用 ExecutionException.getCause() 方法来获取原始异常，或者使用 CompletableFuture 提供的 exceptionally、handle、whenComplete 等方法来处理异常。
4.3 配置合适的 RejectedExecutionHandler

在自定义线程池时，应该选择合适的 RejectedExecutionHandler，避免使用 DiscardPolicy 和 DiscardOldestPolicy。

4.4 统一的异常处理
利用AOP统一处理异常

@Aspect
@Component
public class AsyncExceptionHandlerAspect {

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

    @AfterThrowing(pointcut = "@annotation(org.springframework.scheduling.annotation.Async)", throwing = "ex")
    public void handleAsyncException(JoinPoint joinPoint, Throwable ex) {
        // 获取方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        // 获取方法参数
        Object[] args = joinPoint.getArgs();

        // 记录异常信息
        logger.error("Async method {} threw exception: {}", method.getName(), ex.getMessage(), ex);

        // 可以根据实际需求进行其他处理，例如发送邮件、短信等
        // sendNotification(method, args, ex);
    }

    // 可以添加发送通知的方法
    private void sendNotification(Method method, Object[] args, Throwable ex) {
        // 实现发送通知的逻辑
        // 例如：发送邮件、短信等
        logger.info("Sending notification for exception in async method {}.", method.getName());
    }
}

4.5 记录详细的日志

无论使用哪种方法，都应该记录详细的日志，包括异常信息、方法名、参数等，以便于排查问题。

5. 最佳实践

5.1 优先使用 AsyncConfigurer 来自定义异常处理机制

这种方法可以集中处理所有的异步任务异常，方便管理和维护。
5.2 尽量避免使用 DiscardPolicy 和 DiscardOldestPolicy

除非你明确知道这样做不会导致问题。
5.3 记录详细的日志

这是调试异步任务问题的关键。
5.4 考虑使用监控系统

可以使用监控系统来监控异步任务的执行情况，及时发现和处理异常。

6. 总结

Spring Boot 的 @Async 注解为异步编程提供了极大的便利，但也容易出现异常被吞噬的问题。通过理解异常吞噬的根因，并采取相应的措施，我们可以有效地避免这个问题，保证程序的稳定性和可靠性。记住，关键在于正确地捕获和处理异步任务中抛出的异常，并记录详细的日志。

7. 异常处理的要点
正确处理异步任务异常，保障程序稳定运行。
自定义异常处理器，统一管理异步异常。
详细记录异常日志，便于问题排查和定位。

Spring Boot @Async 异步任务异常吞噬问题深度剖析

发表回复 取消回复

发表回复取消回复