如何在Java中非阻塞等待REST API调用并保留函数状态？

你要构建的是结合WebSocket和REST的Java应用，核心交互包括：

• 用户通过WebSocket发起操作（查询天气、流式文本传输），需异步调用DB/REST API后同步结果到前端
• 外部系统事件（如邮件接收）要实时推送给在线用户

但Java传统同步线程模型会遇到两个核心问题：

1. 等待异步操作（DB/REST/WebSocket）时阻塞线程，无法处理其他用户请求
2. 单用户线程在等待慢API时，无法同时处理该用户的其他事件（如邮件推送）
   给每个用户分配独立线程的方案不仅无法解决第二个问题，还会带来过高的线程开销。

以下是Java中实现类似JS异步函数效果的几种方案：

1. 使用CompletableFuture实现链式异步调用 #

Java 8引入的CompletableFuture可实现类似JS的异步链式调用，无需阻塞线程，同时通过闭包或对象引用保留状态。

针对你的场景改造示例代码：

public void uponReceivingMessageFromWebsocket(String mess, User user, WebSocketSession session) {
    if ("get_weather".equals(mess)) {
        // 异步查询用户位置，链式调用后续操作
        CompletableFuture.supplyAsync(this::checkDatabaseForUserLocation)
                // 拿到位置后异步调用天气API
                .thenCompose(location -> fetchWeatherLocationFromApiAsync("api.weather.com/", location))
                // 更新用户状态并异步同步到WebSocket
                .thenAccept(weather -> {
                    user.setWeather(weather);
                    synchronizeWeatherAsync(session, weather);
                })
                // 异常处理
                .exceptionally(ex -> {
                    sendErrorAsync(session, "获取天气失败：" + ex.getMessage());
                    return null;
                });
    } else if ("stream_text".equals(mess)) {
        startTextStreaming(user, session);
    }
}

// 异步流式文本处理：用递归+CompletableFuture实现非阻塞循环
private void startTextStreaming(User user, WebSocketSession session) {
    fetchNextChunkFromApiAsync()
            .thenAccept(chunk -> {
                if (chunk != null && !user.isTaskCancelled()) {
                    user.appendStreamedText(chunk);
                    synchronizeTextAsync(session, user.getStreamedText());
                    // 递归调用继续获取下一块
                    startTextStreaming(user, session);
                }
            })
            .exceptionally(ex -> {
                sendErrorAsync(session, "流式文本传输失败：" + ex.getMessage());
                return null;
            });
}

// 异步处理邮件接收
public void uponReceivingMail(String mail, User user, WebSocketSession session) {
    user.addMail(mail);
    synchronizeMailAsync(session, user.getMails());
}

核心优势：

• 所有IO操作（DB/REST/WebSocket）提供异步版本（返回CompletableFuture），线程在等待期间会被释放处理其他任务
• 闭包自动保留user、session等状态，无需手动管理
• 链式调用替代同步等待，避免线程阻塞

2. Project Loom虚拟线程（Java 19+） #

若使用Java 19及以上版本，Project Loom的虚拟线程可完美解决线程开销问题，同时保留同步代码的可读性，底层自动实现非阻塞调度。

改造后可保持类似你示例的同步写法，运行在虚拟线程上：

// 为每个WebSocket连接分配虚拟线程
public void onWebSocketConnect(User user, WebSocketSession session) {
    Thread.startVirtualThread(() -> {
        try {
            String mess;
            while ((mess = session.receiveMessage()) != null) {
                handleMessage(mess, user, session);
            }
        } catch (IOException e) {
            // 处理连接关闭逻辑
        }
    });
}

private void handleMessage(String mess, User user, WebSocketSession session) {
    if ("get_weather".equals(mess)) {
        // 虚拟线程下的同步写法，底层不会阻塞平台线程
        String location = checkDatabaseForUserLocation();
        String weather = fetchWeatherLocationFromApi("api.weather.com/", location);
        user.setWeather(weather);
        websocket.synchronizeWeather(session, weather);
    } else if ("stream_text".equals(mess)) {
        String chunk;
        while ((chunk = fetchNextChunkFromAPI()) != null && !user.isTaskCancelled()) {
            user.appendStreamedText(chunk);
            websocket.synchronizeText(session, user.getStreamedText());
        }
    }
}

// 邮件接收可直接在虚拟线程/平台线程处理，无需等待其他操作
public void uponReceivingMail(String mail, User user, WebSocketSession session) {
    user.addMail(mail);
    websocket.synchronizeMail(session, user.getMails());
}

核心优势：

• 写法和同步代码一致，无需重构为链式调用
• 虚拟线程由JVM调度，平台线程在IO等待时会被释放，线程开销极低
• 单个用户的虚拟线程在等待IO时，JVM会切换执行逻辑，允许处理该用户的其他事件（如邮件推送）

3. 反应式编程（RxJava/Spring WebFlux） #

若基于Spring生态，Spring WebFlux结合Reactor可实现完全非阻塞的反应式编程，类似JS的异步流处理。

示例代码（Spring WebFlux）：

public Mono<Void> handleWebSocketMessage(String mess, User user, WebSocketSession session) {
    if ("get_weather".equals(mess)) {
        return checkDatabaseForUserLocationReactive()
                .flatMap(location -> fetchWeatherLocationFromApiReactive("api.weather.com/", location))
                .doOnNext(weather -> user.setWeather(weather))
                .flatMap(weather -> session.send(Mono.just(session.textMessage(weather))))
                .then();
    } else if ("stream_text".equals(mess)) {
        return fetchTextChunksReactive()
                .takeUntil(chunk -> chunk == null || user.isTaskCancelled())
                .doOnNext(chunk -> user.appendStreamedText(chunk))
                .flatMap(chunk -> session.send(Mono.just(session.textMessage(chunk))))
                .then();
    }
    return Mono.empty();
}

public Mono<Void> handleMail(String mail, User user, WebSocketSession session) {
    user.addMail(mail);
    return session.send(Mono.just(session.textMessage("新邮件：" + mail)));
}

核心优势：

• 基于流的异步处理，所有操作非阻塞，线程复用率极高
• 通过流上下文自动保留状态，支持复杂的异步流控制

状态保留核心思路 #

不管采用哪种方案，保留函数状态的方式主要有两种：

• 闭包引用：在异步回调/链式调用中直接引用外部的user、session等对象，Java会自动通过闭包保留引用（注意及时清理无用引用避免内存泄漏）
• 状态封装：将需要保留的状态（如流式传输进度、用户信息）封装到UserContext类中，传递给各个异步操作

总结 #

• 若追求代码简洁性和低改造量，优先选择Project Loom虚拟线程（Java 19+），用同步写法实现非阻塞效果
• 若需兼容低版本Java，CompletableFuture是最成熟的异步方案
• 若为Spring生态应用，Spring WebFlux反应式编程可实现端到端非阻塞架构

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