如何避免用While循环等待Java Future完成？Redis健康检查优化

问题分析 #

你的代码通过while循环轮询Future状态实现同步返回，这种方式会阻塞线程，违背Vert.x的异步非阻塞设计原则。而直接在onSuccess/onFailure回调里无法返回HealthCheckResponse，是因为回调方法的返回值类型与call()方法不匹配，且同步方法无法直接处理异步结果。

推荐解决方案：使用异步健康检查接口 #

Vert.x的健康检查框架原生支持异步检查逻辑，你可以实现AsyncHealthCheckProcedure接口，通过回调方式返回检查结果，完全避免轮询和线程阻塞：

import io.vertx.ext.healthchecks.AsyncHealthCheckProcedure;
import io.vertx.ext.healthchecks.HealthCheckHandler;
import io.vertx.ext.healthchecks.HealthCheckResponse;
import io.vertx.redis.client.Redis;
import io.vertx.redis.client.RedisConnection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class RedisCustomHealthCheck implements AsyncHealthCheckProcedure {

    private final Configuration configuration;
    private final Logger log = LoggerFactory.getLogger(RedisCustomHealthCheck.class);

    public RedisCustomHealthCheck(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public void check(HealthCheckHandler.ResultHandler resultHandler) {
        String redisHost = configuration.getRedisHost();
        log.info("connect to redis host: {}", redisHost);

        Redis.createClient(Vertx.vertx(), redisHost)
             .connect()
             .onSuccess(connection -> {
                 log.info("redis connection future completed, succeeded: true");
                 connection.close(); // 及时关闭连接，避免资源泄漏
                 resultHandler.handle(HealthCheckResponse.up("RedisCustomHealthCheck"));
             })
             .onFailure(throwable -> {
                 log.info("redis connection future completed, succeeded: false");
                 log.error("Redis connection failed", throwable);
                 resultHandler.handle(HealthCheckResponse.down("RedisCustomHealthCheck", throwable));
             });
    }
}

关键说明：

• 实现AsyncHealthCheckProcedure接口后，check方法接收一个ResultHandler参数，用于异步传递检查结果
• 利用Future的onSuccess和onFailure回调处理连接结果，无需轮询
• 连接成功后必须调用connection.close()释放资源，防止连接泄漏

备选方案：同步阻塞获取结果（不推荐） #

如果因特殊需求必须在同步方法中返回结果，可以将Vert.x的Future转换为CompletableFuture并调用get()阻塞等待，但这种方式会破坏Vert.x的非阻塞特性，影响应用性能：

import io.vertx.ext.healthchecks.HealthCheckResponse;
import io.vertx.redis.client.Redis;
import io.vertx.redis.client.RedisConnection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.ExecutionException;

public HealthCheckResponse call() throws ExecutionException, InterruptedException {
    String redisHost = this.configuration.getRedisHost();
    log.info("connect to redis host: {}", redisHost);

    Future<RedisConnection> redisConnectionFuture = Redis.createClient(Vertx.vertx(), redisHost).connect();
    try {
        RedisConnection connection = redisConnectionFuture.toCompletionStage().toCompletableFuture().get();
        connection.close();
        log.info("redis connection future completed, succeeded: true");
        return HealthCheckResponse.up("RedisCustomHealthCheck");
    } catch (ExecutionException | InterruptedException e) {
        log.info("redis connection future completed, succeeded: false");
        log.error("Redis connection failed", e);
        return HealthCheckResponse.down("RedisCustomHealthCheck", e.getCause());
    }
}

注意：此方案会阻塞当前线程，仅适用于非Vert.x事件循环线程的场景，不建议在Vert.x核心业务逻辑中使用。

内容的提问来源于stack exchange，提问作者Jan Kück