Java 我可以在一个完整的未来多次使用合并/合成吗？

假设我有完全期货A，B和C是可运行的。B依赖于A，C依赖于A和B，我可以先做A，然后组合B和B，然后组合A，这样即使B也依赖于A的值，C也能从A和B得到值吗

基本上，我想问的是——有没有一种方法可以获得这样一个完整的未来管道：

A -- B -- C
  -------^

CompletableFuture<String> A = CompletableFuture.supplyAsync(() -> return "Hello");
CompletableFuture<String> B = A.thenApplyAsync(stringA -> return stringA + "World");
B.thenCombine(A, (stringA, StringB) -> doStuffWithAAndB(stringA, stringB));

CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> return "Hello");
CompletableFuture<String> b = a.thenApplyAsync(stringA -> return stringA + "World");
b.thenApply(stringB -> doStuffWithAAndB(a.join(), stringB));

A--B--C
-------^
CompletableFuture A=CompletableFuture.supplyAsync（（）->返回“Hello”）；
CompletableFuture B=A。然后应用同步（stringA->返回stringA+“World”）；
然后结合（A，（stringA，StringB）->dostuff与A和B（stringA，StringB））；

希望这是有意义的。

如果您可以使用，您可以按如下方式操作：

import io.reactivex.Observable;

public class CompletableFutureDemo {

    public static void main(String[] args) {

        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> "Hello");
        Observable<String> obsA = Observable.fromFuture(a);

        Observable<String> obsB = obsA.map(stringA -> stringA + " world");

        Observable.zip(obsA, obsB, (stringA, stringB) -> {
            return stringA + " " + stringB;
        })
        .subscribe(zipped -> {
            System.out.println(zipped);
        });
    }

import io.reactivex.Observable；
公共类CompletableFutureDemo{
公共静态void main（字符串[]args）{
CompletableFuture a=CompletableFuture.supplyAsync（（）->“Hello”）；
可观测的obsA=可观测的未来（a）；
可观测obsB=obsA.map（stringA->stringA+“世界”）；
Observable.zip（obsA，obsB，（stringA，stringB）->{
返回stringA+“”+stringB；
})
.订阅（压缩->{
System.out.println（压缩）；
});
}
这样做很好。如何将
CompletableFuture
组合在一起没有任何限制

你有责任确保它们最终完成，但这不是一个问题

或者，您可以直接从回调访问，如下所示：

A -- B -- C
  -------^

CompletableFuture<String> A = CompletableFuture.supplyAsync(() -> return "Hello");
CompletableFuture<String> B = A.thenApplyAsync(stringA -> return stringA + "World");
B.thenCombine(A, (stringA, StringB) -> doStuffWithAAndB(stringA, stringB));

CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> return "Hello");
CompletableFuture<String> b = a.thenApplyAsync(stringA -> return stringA + "World");
b.thenApply(stringB -> doStuffWithAAndB(a.join(), stringB));

CompletableFuture a=CompletableFuture.supplyAsync（（）->返回“Hello”）；
CompletableFuture b=a。然后应用同步（stringA->返回stringA+“World”）；
b、 然后应用（stringB->doStuffWithAAndB（a.join（），stringB））；

但这确实是一个偏好问题。
我认为如果你展示一些实际的代码，而不是试图描述你的代码，会更清楚。添加了代码片段。从我所看到的，你有
a
将其输出发送到
B
，然后B将其作为输入并将输出发送到C。因此，如果你还需要
A
转到
C
，然后从
B
执行该操作，因为
B
已经有
A
output@smac89我曾想过这样做，但这可能会导致我试图避免的深层嵌套回调结构。两次依赖一个线程模型（即未定义的行为）是否有违CompletableFuture线程模型或者只是一些我们应该避免的设计方面的问题？我的建议是让
A
返回一个供应商，当调用该供应商时，该供应商将产生
A
的结果。这将允许您在某种意义上获得
A
的结果，次数可以根据您的意愿而定。这一切都归结为这样一个事实，即B和C需要A的结果，然后才能进行专业化ceed，所以我建议要么进行同步，然后将结果交给B和C，要么将B合并到C中，以便在C中处理A的异步结果，这将返回一个等待B的未来，然后执行C的工作。