Spring Boot中如何隔离就绪探针与存活探针的计算逻辑？

完全可以将就绪探针（readiness probe）和存活探针（liveness probe）的计算逻辑隔离开，解决就绪探针耗时过长导致存活探针被拖垮的问题。结合你当前使用Undertow、Actuator已在独立端口运行且有专属线程池的场景，这里提供两种落地性强的方案：

方案1：为两类探针端点配置独立线程池 #

既然Actuator已经用了独立端口，我们可以给这个端口下的/actuator/health/liveness和/actuator/health/readiness两个端点分别分配独立的线程池，彻底避免彼此的资源抢占。

具体实现（Undertow环境） #

通过自定义Undertow的ServletWebServerFactory，针对特定路径绑定不同的worker线程池：

@Configuration
public class UndertowThreadPoolConfig {

    @Bean
    public ServletWebServerFactory servletWebServerFactory() {
        UndertowServletWebServerFactory factory = new UndertowServletWebServerFactory();
        factory.addBuilderCustomizers(builder -> {
            // 为存活探针创建独立线程池
            WorkerThreadPool livenessWorker = Workers.createWorkerThreadPool(
                builder.getIoThreads(),
                8, // 线程池大小，根据实际调整
                new ExecutorOptionMap(),
                builder.getBufferPool(),
                builder.getWorkerOptions()
            );
            // 为就绪探针创建独立线程池
            WorkerThreadPool readinessWorker = Workers.createWorkerThreadPool(
                builder.getIoThreads(),
                16, // 就绪探针可能需要更多线程，按需调整
                new ExecutorOptionMap(),
                builder.getBufferPool(),
                builder.getWorkerOptions()
            );

            // 给对应路径绑定线程池
            builder.addHttpHandlerWrapper(exchangeHandler -> {
                String path = exchangeHandler.getExchange().getRequestPath();
                if ("/actuator/health/liveness".equals(path)) {
                    return new BlockingHandler(exchangeHandler, livenessWorker);
                } else if ("/actuator/health/readiness".equals(path)) {
                    return new BlockingHandler(exchangeHandler, readinessWorker);
                }
                return exchangeHandler;
            });
        });
        return factory;
    }
}

这样即使就绪探针因为数据库连接超时等问题占用大量线程，存活探针的线程池不受影响，依然能快速响应。

方案2：限制就绪健康检查的单次调用耗时 #

给就绪探针的健康检查逻辑加上超时限制，避免单个检查拖垮整个端点。

具体实现 #

方式1：使用@Timeout注解（Spring Boot 2.3+）

针对自定义的就绪探针相关HealthIndicator，直接添加@Timeout注解设置超时时间：

@Component
@Endpoint(id = "readiness-db")
public class DbReadinessHealthIndicator implements HealthIndicator {

    private final DataSource dataSource;

    public DbReadinessHealthIndicator(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    @Timeout(value = 3, unit = TimeUnit.SECONDS) // 设置3秒超时
    public Health health() {
        try (Connection conn = dataSource.getConnection()) {
            return Health.up().withDetail("db", "connected").build();
        } catch (Exception e) {
            return Health.down(e).build();
        }
    }
}

方式2：手动用异步+超时控制

如果是默认的健康检查组合，可以通过自定义包装逻辑，用CompletableFuture实现超时：

@Component
public class TimeoutReadinessHealthIndicator implements HealthIndicator {

    private final HealthIndicator delegate;

    public TimeoutReadinessHealthIndicator(HealthIndicator delegate) {
        this.delegate = delegate;
    }

    @Override
    public Health health() {
        try {
            return CompletableFuture.supplyAsync(delegate::health)
                    .get(3, TimeUnit.SECONDS);
        } catch (TimeoutException e) {
            return Health.down().withDetail("error", "readiness check timed out").build();
        } catch (Exception e) {
            return Health.down(e).build();
        }
    }
}

两种方案可以结合使用：先用方案2限制就绪检查的单次耗时，再用方案1彻底隔离线程池，最大化避免两类探针的互相影响。

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