Java 创建三个Mono后，立即并行执行三个Mono，等待所有Mono完成并按照特定顺序/逻辑收集结果

我是春季网络流量新手，所以请温柔一点。。。如果我遗漏了一些明显的东西，我很抱歉，但我尝试寻找在线示例，每次我都会连续调用

我有这样的情况：

Mono<Response> mono1 = webclient1.post()...usual_stuffs....bodyToMono(Response.class);
Mono<Response> mono2 = webclient2.post()...usual_stuffs....bodyToMono(Response.class);
Mono<Response> mono3 = webclient3.post()...usual_stuffs....bodyToMono(Response.class);

Mono mono1=webclient1.post（）…常用的东西…bodyToMono（Response.class）；
Mono mono2=webclient2.post（）…常用的东西…bodyToMono（Response.class）；
Mono mono3=webclient3.post（）…常用的东西…bodyToMono（Response.class）；

响应是我的项目中的一个类，但是对于这个例子，我们可以把它们看作是单个列表的简单容器。 我想：

• 并行执行它们（只要我通过调用.subscribeOn（Schedulers.parallel（））将它们分配给mono1/mono2/mono3，可能是吗？）
• 完成所有操作后，将响应保存到resp1、resp2、resp3
• 如果resp1有结果（列表不是空的），则返回resp1 else
• 。。。如果resp2有结果（列表不是空的），则返回resp2 else
• 。。。返回resp3（即使其为空）

我如何做到这一点？（因为我失败了多次）

我的第一次尝试是：

Mono<Response> mono1 = webclient1.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());
Mono<Response> mono2 = webclient2.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());
Mono<Response> mono3 = webclient3.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());
ParallelFlux.from(mono1, mono2, mono3).then().block(); // im not sure if this really execute them in parallel
Response resp1 = mono1.block();
Response resp2 = mono2.block();
Response resp3 = mono3.block();
if (resp1.isNotEmpty()) {
    return resp1;
}
if (resp2.isNotEmpty()) {
    return resp2;
}
return resp3;

Mono mono1=webclient1.post（）…常用的东西…bodyToMono（Response.class）.subscribeOn（Schedulers.parallel（））；
Mono mono2=webclient2.post（）…常用的东西…bodytomino（Response.class）.subscribeOn（Schedulers.parallel（））；
Mono mono3=webclient3.post（）…常用的东西…bodytomino（Response.class）.subscribeOn（Schedulers.parallel（））；
ParallelFlux.from（mono1，mono2，mono3）.then（）.block（）；//我不确定这是否真的并行执行它们
响应resp1=mono1.block（）；
响应resp2=mono2.block（）；
响应resp3=mono3.block（）；
if（resp1.isNotEmpty（））{
返回响应1；
}
if（resp2.isNotEmpty（））{
返回响应2；
}
返回响应3；

这似乎不起作用，ParallelFlux.from（mono1，mono2，mono3）。那么（）.block（）真的并行运行这些Mono吗？为什么我需要并行通量？当我创建每个单声道时，我就不能说“在单独的线程上运行这个单声道”吗？实际上，每个.block（）都会重做调用。。。。就像重新执行mono。。。为什么?

更新：

通过阅读注释，我将代码更改为：

Mono<Response> mono1 = webclient1.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());
Mono<Response> mono2 = webclient2.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());
Mono<Response> mono3 = webclient3.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());

Tuple3<Response, Response, Response> all = Mono.zip(mono1, mono2, mono3).block();

Response resp1 = all.getT1();
Response resp2 = all.getT2();
Response resp3 = all.getT3();

if (resp1.hasMessages()) {
    return resp1;
}
if (resp2.hasMessages()) {
    return resp2;
}
return resp3;

Mono mono1=webclient1.post（）…常用的东西…bodyToMono（Response.class）.subscribeOn（Schedulers.parallel（））；
Mono mono2=webclient2.post（）…常用的东西…bodytomino（Response.class）.subscribeOn（Schedulers.parallel（））；
Mono mono3=webclient3.post（）…常用的东西…bodytomino（Response.class）.subscribeOn（Schedulers.parallel（））；
tuple3all=Mono.zip（mono1，mono2，mono3.block（）；
Response resp1=all.getT1（）；
Response resp2=all.getT2（）；
Response resp3=all.getT3（）；
if（resp1.hasMessages（））{
返回响应1；
}
if（resp2.hasMessages（））{
返回响应2；
}
返回响应3；

现在它似乎起作用了。我是否需要做其他事情，或者我对这个解决方案没有意见？我是否也应该在

Mono.zip（mono1，mono2，mono3）.subscribeOn（Schedulers.parallel（））.block（）中更改
Mono.zip（mono1，mono2，mono3）.block（）
？
p、 我现在正在重新阅读文档，我想我应该使用Schedulers.elastic（）而不是Schedulers.parallel（）。
创建mono不会自动执行它。您需要像
subscribe
或
block
这样的终端操作符来触发执行（
subscribebeon
不是终端操作符。您不需要它，除非您想将执行延迟到其他线程池。默认情况下，它使用默认线程池）。如果希望多个mono并行运行，可以使用
zip
运算符

Mono<Response> mono1 = webclient1.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());
Mono<Response> mono2 = webclient2.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());
Mono<Response> mono3 = webclient3.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());

return Mono.zip(mono1, mono2, mono3)
        .map(t -> {
            if (t.getT1().isEmpty()) {
                if (t.getT2().isEmpty()) {
                    return t.getT3();
                } else {
                    return t.getT2();
                }
            } else {
                return t.getT1();
            }
        });

Mono mono1=webclient1.post（）…常用的东西…bodyToMono（Response.class）.subscribeOn（Schedulers.parallel（））；
Mono mono2=webclient2.post（）…常用的东西…bodytomino（Response.class）.subscribeOn（Schedulers.parallel（））；
Mono mono3=webclient3.post（）…常用的东西…bodytomino（Response.class）.subscribeOn（Schedulers.parallel（））；
return Mono.zip（mono1、mono2、mono3）
.map（t->{
if（t.getT1（）.isEmpty（））{
if（t.getT2（）.isEmpty（））{
返回t.getT3（）；
}否则{
返回t.getT2（）；
}
}否则{
返回t.getT1（）；
}
});

注意：调用此函数不会执行并给出结果。它会返回一个mono，您可以在其上调用
subscribe（）
以获得结果。
创建mono不会自动执行它。您需要像
subscribe
或
block
这样的终端操作符来触发执行（
subscribebeon
不是终端操作符。您不需要它，除非您想将执行延迟到其他线程池。默认情况下，它使用默认线程池）。如果希望多个mono并行运行，可以使用
zip
运算符

Mono<Response> mono1 = webclient1.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());
Mono<Response> mono2 = webclient2.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());
Mono<Response> mono3 = webclient3.post()...usual_stuffs....bodyToMono(Response.class).subscribeOn(Schedulers.parallel());

return Mono.zip(mono1, mono2, mono3)
        .map(t -> {
            if (t.getT1().isEmpty()) {
                if (t.getT2().isEmpty()) {
                    return t.getT3();
                } else {
                    return t.getT2();
                }
            } else {
                return t.getT1();
            }
        });

Mono mono1=webclient1.post（）…常用的东西…bodyToMono（Response.class）.subscribeOn（Schedulers.parallel（））；
Mono mono2=webclient2.post（）…常用的东西…bodytomino（Response.class）.subscribeOn（Schedulers.parallel（））；
Mono mono3=webclient3.post（）…常用的东西…bodytomino（Response.class）.subscribeOn（Schedulers.parallel（））；
return Mono.zip（mono1、mono2、mono3）
.map（t->{
if（t.getT1（）.isEmpty（））{
if（t.getT2（）.isEmpty（））{
返回t.getT3（）；
}否则{
返回t.getT2（）；
}
}否则{
返回t.getT1（）；
}
});

注意：调用此函数不会执行并给出结果。它会返回一个mono，您可以在其上调用一个
subscribe（）
来获得结果。
Ty的回答：）最后我做了这个：
Tuple3 all=mono.zip（mono1，mono2，mono3.block（）
responsevalidaticontra