Kotlin Spring Boot中彻底终止超时线程并返回503错误

你当前使用的StuckThreadDetectionValve仅能断开客户端连接、标记线程为"卡住"，但无法强制终止业务线程——核心原因是业务代码未响应线程中断信号，且该Valve不会主动返回503响应。以下是可行的解决方案：

一、让业务代码响应线程中断（基础前提） #

无论采用哪种超时方案，业务逻辑必须能感知线程中断并终止执行：

• 在循环/耗时操作中定期检查Thread.currentThread().isInterrupted()，为true则立即退出
• 捕获InterruptedException时，不要吞掉异常，需重新设置中断状态或直接终止方法

示例业务代码：

@RestController
class LongRunningController {
    @GetMapping("/long-task")
    fun longTask(): ResponseEntity<String> {
        return try {
            repeat(100) {
                if (Thread.currentThread().isInterrupted) throw InterruptedException("任务被中断")
                Thread.sleep(100) // 模拟耗时操作
            }
            ResponseEntity.ok("任务完成")
        } catch (e: InterruptedException) {
            Thread.currentThread().interrupt() // 重置中断状态
            ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body("请求超时，任务已终止")
        }
    }
}

二、结合Tomcat AsyncTimeoutValve + 异步请求（推荐方案） #

利用Tomcat自带的AsyncTimeoutValve处理异步请求超时，自动返回503并中断线程：

1. 配置AsyncTimeoutValve #

@Configuration
class RequestTimeoutConfig(
    @Value("\${server.tomcat.connection-timeout}")
    private val timeoutSeconds: Int
) {
    @Bean
    fun asyncTimeoutValve() = AsyncTimeoutValve().apply {
        timeout = timeoutSeconds * 1000 // 转换为毫秒
    }

    @Bean
    fun webServerFactoryCustomizer(valve: AsyncTimeoutValve) =
        WebServerFactoryCustomizer { factory: TomcatServletWebServerFactory ->
            factory.addContextValves(valve)
        }
}

2. 编写异步控制器 #

@RestController
class TimeoutController {
    @GetMapping("/timeout-task")
    fun handleTimeout(): Callable<ResponseEntity<String>> {
        return Callable {
            try {
                repeat(100) {
                    if (Thread.currentThread().isInterrupted) throw InterruptedException("请求超时")
                    Thread.sleep(100)
                }
                ResponseEntity.ok("任务完成")
            } catch (e: InterruptedException) {
                Thread.currentThread().interrupt()
                ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body("请求超时，任务已终止")
            }
        }
    }
}

三、Spring异步任务+超时回调方案 #

通过Spring @Async实现异步任务，手动设置超时并终止任务：

1. 配置异步线程池 #

@Configuration
@EnableAsync
class AsyncConfig : AsyncConfigurer {
    override fun getAsyncExecutor(): Executor {
        val executor = ThreadPoolTaskExecutor()
        executor.corePoolSize = 10
        executor.maxPoolSize = 20
        executor.setThreadNamePrefix("async-task-")
        executor.initialize()
        return executor
    }
}

2. 异步服务与控制器 #

@Service
class AsyncTaskService {
    private var currentTask: CompletableFuture<Void>? = null

    @Async
    fun executeLongTask(): CompletableFuture<ResponseEntity<String>> {
        val resultFuture = CompletableFuture<ResponseEntity<String>>()
        currentTask = CompletableFuture.runAsync {
            try {
                repeat(100) {
                    if (Thread.currentThread().isInterrupted) throw InterruptedException("任务被取消")
                    Thread.sleep(100)
                }
                resultFuture.complete(ResponseEntity.ok("任务完成"))
            } catch (e: InterruptedException) {
                Thread.currentThread().interrupt()
                resultFuture.completeExceptionally(e)
            }
        }
        return resultFuture
    }

    fun cancelCurrentTask() {
        currentTask?.cancel(true) // 中断执行中的线程
    }
}

@RestController
class AsyncLongRunningController {
    @Autowired
    private lateinit var asyncTaskService: AsyncTaskService

    @GetMapping("/async-long-task")
    fun asyncLongTask(): CompletableFuture<ResponseEntity<String>> {
        val taskFuture = asyncTaskService.executeLongTask()
        return taskFuture
            .completeOnTimeout(
                ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body("请求超时，任务已终止"),
                10, TimeUnit.SECONDS
            )
            .whenComplete { _, throwable ->
                if (throwable is TimeoutException) {
                    asyncTaskService.cancelCurrentTask()
                }
            }
    }
}

关键注意事项 #

• 所有方案的核心前提是业务代码必须响应线程中断，否则即使线程被标记为中断，任务仍会继续执行
• 同步请求场景下，单纯依赖Tomcat Valve无法强制终止线程，必须结合业务代码的中断检查

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