Java中如何在CompletableFuture的不同阶段间共享数据？

当然可以在CompletableFuture的计算阶段间共享数据，但不建议用AtomicReference——这种方式会引入不必要的共享可变状态，在异步场景下不仅容易引发线程安全问题，还会让代码可读性和维护性变差。

给你两种更合理的方案：

方案1：返回包含多份数据的容器对象 #

既然你需要同时传递id和retrieveDifferentObject的结果，最直接的方式就是把两者打包成一个对象传递到下一个阶段。你可以用Java自带的容器类，比如AbstractMap.SimpleEntry，或者自定义一个语义化的DTO类。

示例代码（用SimpleEntry）： #

CompletableFuture<Response> serverResponseCf = service.get("someKey");
serverResponseCf.thenApplyAsync(response -> {
        String id = response.getId();
        DiffObject diffObj = retrieveDifferentObject(id);
        // 把id和diff对象打包成Entry返回
        return new AbstractMap.SimpleEntry<>(id, diffObj);
    })
    .thenAcceptAsync(entry -> {
        String id = entry.getKey();
        DiffObject thatDiffObject = entry.getValue();
        // 这里可以同时使用id和diff对象了
    })
    // 后续链继续...

示例代码（自定义DTO）： #

如果觉得SimpleEntry不够清晰，自己写个DTO更易读：

// 自定义一个用于传递数据的类
private static class IdAndDiffObject {
    private final String id;
    private final DiffObject diffObject;

    public IdAndDiffObject(String id, DiffObject diffObject) {
        this.id = id;
        this.diffObject = diffObject;
    }

    // getter方法
    public String getId() { return id; }
    public DiffObject getDiffObject() { return diffObject; }
}

// 然后在链中使用
CompletableFuture<Response> serverResponseCf = service.get("someKey");
serverResponseCf.thenApplyAsync(response -> {
        String id = response.getId();
        DiffObject diffObj = retrieveDifferentObject(id);
        return new IdAndDiffObject(id, diffObj);
    })
    .thenAcceptAsync(data -> {
        String id = data.getId();
        DiffObject thatDiffObject = data.getDiffObject();
        // 业务逻辑处理
    })

方案2：嵌套CompletableFuture（适合后续操作依赖两者的场景） #

如果后续的异步操作需要同时用到id和diffObject，可以在第一个thenApplyAsync内部嵌套逻辑，避免传递容器对象：

CompletableFuture<Response> serverResponseCf = service.get("someKey");
serverResponseCf.thenComposeAsync(response -> {
        String id = response.getId();
        DiffObject diffObj = retrieveDifferentObject(id);
        // 这里直接发起依赖id和diffObj的异步操作
        return CompletableFuture.runAsync(() -> {
            // 在这里直接使用id和diffObj处理业务
        });
    })

为什么不推荐AtomicReference？ #

用AtomicReference的写法大概是这样：

AtomicReference<String> idRef = new AtomicReference<>();
CompletableFuture<Response> serverResponseCf = service.get("someKey");
serverResponseCf.thenApplyAsync(response -> {
        String id = response.getId();
        idRef.set(id); // 存到AtomicReference
        return retrieveDifferentObject(id);
    })
    .thenAcceptAsync(thatDiffObject -> {
        String id = idRef.get(); // 取出id
        // 业务处理
    })

这种写法的问题：

• 线程安全隐患：如果CompletableFuture链有分支，或者多个线程同时操作这个AtomicReference，可能拿到错误的值；
• 代码可读性差：其他维护者看到这个AtomicReference，很难立刻明白它的作用和生命周期；
• 违背异步编程的"纯函数"原则：每个阶段应该尽量依赖输入参数，而不是外部可变状态。

内容的提问来源于stack exchange，提问作者Abhi.P