如何在Spring三层应用中实现异步处理长耗时任务（兼容Java8/17）

一、核心思路 #

针对耗时超30秒的长任务，通过Spring异步机制+延迟检查实现：

1. 控制器接收请求后，立即启动后台异步任务
2. 延迟30秒后，若任务未完成则返回指定提示消息，后台任务继续执行
3. 任务完成后仅记录日志，无需再通知客户端（若任务在30秒内完成，则直接返回完成消息）

二、步骤实现 #

1. 启用Spring异步支持并配置自定义线程池 #

创建配置类，启用异步并定义线程池（避免默认线程池的局限性）：

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;

@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("AsyncTask-");
        executor.initialize();
        return executor;
    }

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

2. 编写异步任务服务类 #

将长任务逻辑封装到异步方法中，使用@Async注解标记：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncTaskService {

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

    @Async
    public void executeLongTask() {
        // 替换为实际的长任务逻辑
        try {
            // 模拟耗时40秒的任务
            Thread.sleep(40000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            logger.error("长任务被中断", e);
            return;
        }
        logger.info("长任务执行完成");
    }
}

3. 编写控制器处理请求 #

使用DeferredResult实现异步响应，结合ScheduledExecutorService实现30秒延迟检查（兼容Java8/17）：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;
import javax.annotation.PreDestroy;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/tasks")
public class TaskController {

    private static final Logger logger = LoggerFactory.getLogger(TaskController.class);
    private static final ScheduledExecutorService SCHEDULER = Executors.newSingleThreadScheduledExecutor();

    @Autowired
    private AsyncTaskService asyncTaskService;

    @PostMapping("/long-task")
    public DeferredResult<ResponseEntity<String>> handleLongTask() {
        DeferredResult<ResponseEntity<String>> deferredResult = new DeferredResult<>();

        // 启动后台异步任务
        CompletableFuture<Void> taskFuture = CompletableFuture.runAsync(() -> asyncTaskService.executeLongTask());

        // 30秒后检查任务状态，未完成则返回提示消息
        SCHEDULER.schedule(() -> {
            if (!taskFuture.isDone()) {
                logger.info("任务执行已超30秒，向客户端返回处理中通知");
                deferredResult.setResult(ResponseEntity.ok("Processing in progress. We will notify you when it's completed"));
            }
        }, 30, TimeUnit.SECONDS);

        // 任务完成/异常时的处理（若30秒内完成则直接返回结果）
        taskFuture.whenComplete((result, ex) -> {
            if (!deferredResult.isSetOrExpired()) {
                if (ex != null) {
                    logger.error("长任务执行异常", ex);
                    deferredResult.setResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("任务执行失败"));
                } else {
                    deferredResult.setResult(ResponseEntity.ok("任务已完成"));
                }
            }
        });

        // 设置DeferredResult超时时间（略长于30秒，避免意外超时）
        deferredResult.setTimeout(31000L);
        deferredResult.onTimeout(() -> {
            logger.warn("DeferredResult超时触发");
            deferredResult.setResult(ResponseEntity.ok("Processing in progress. We will notify you when it's completed"));
        });

        return deferredResult;
    }

    // 应用关闭时关闭调度器，避免资源泄漏
    @PreDestroy
    public void shutdownScheduler() {
        SCHEDULER.shutdown();
    }
}

三、解决你之前的问题 #

1. CompletableFuture.delayedExecutor：该方法是Java9新增的，Java8环境下不存在，因此会报错，这是跨版本不兼容的核心原因。
2. Timer定时器：Timer的run方法运行在独立线程中，没有HTTP请求上下文，无法直接返回ResponseEntity，因此无法实现需求。

四、注意事项 #

• 异步线程池参数可根据实际业务调整（核心线程数、最大线程数等）
• 长任务中需处理中断异常，避免线程泄漏
• 若需要全局异常处理，可自定义AsyncUncaughtExceptionHandler

内容的提问来源于stack exchange，提问作者Sam Sam