Java 项目反应器：多个发布者进行HTTP调用，一个订阅者处理所有结果

以下代码的问题是订阅者只看到第一个通量的项目（即仅打印

1

）。有趣的是，如果我添加

delayElements

，它就可以正常工作

这是一个很有趣的例子，但我的意图是用

Flux

替换它，它使HTTP获取请求并发出它们的结果（也可能不止两个）

因此，重新阐述我的问题，我有一个需要实施的多对一关系。考虑到我的情况，如何实施它？你会用某种处理器吗

 public static void main(String[] args) throws Exception {
    Flux<Integer> flux1 = Flux.generate(emitter -> {
        emitter.next(1);
    });

    Flux<Integer> flux2 = Flux.generate(emitter -> {
        emitter.next(2);

    });

    Flux<Integer> merged = flux1.mergeWith(flux2);
    merged.subscribe(s -> System.out.println(s));

    Thread.currentThread().join();
}

publicstaticvoidmain（字符串[]args）引发异常{
通量flux1=通量生成（发射器->{
下一步（1）；
});
通量flux2=通量生成（发射器->{
下一步（2）；
});
合并通量=flux1.mergeWith（flux2）；
合并.subscribe->System.out.println；
Thread.currentThread（）.join（）；
}

试图用TopicProcessor实现同样的想法，但遇到了同样的问题：

public static void main(String[] args) throws Exception {
    Flux<Integer> flux1 = Flux.generate(emitter -> {
        emitter.next(1);
        try {
            Thread.sleep(100);
        } catch (Exception e) {}
    });

    Flux<Integer> flux2 = Flux.generate(emitter -> {
        emitter.next(2);
        try {
            Thread.sleep(100);
        } catch (Exception e) {}
    });

    TopicProcessor<Integer> processor = TopicProcessor.create();
    flux1.subscribe(processor);
    flux2.subscribe(processor);

    processor.subscribe(s -> System.out.println(s));


    Thread.currentThread().join();
}

publicstaticvoidmain（字符串[]args）引发异常{
通量flux1=通量生成（发射器->{
下一步（1）；
试一试{
睡眠（100）；
}捕获（例外e）{}
});
通量flux2=通量生成（发射器->{
下一步（2）；
试一试{
睡眠（100）；
}捕获（例外e）{}
});
TopicProcessor=TopicProcessor.create（）；
flux1.subscribe（处理器）；
flux2.订阅（处理器）；
处理器.subscribe->System.out.println；
Thread.currentThread（）.join（）；
}

请注意，merge是为使用异步源或有限源而定制的。当处理尚未在专用调度程序上发布的无限源时，必须在其自己的调度程序中隔离该源，因为merge会在订阅另一个源之前尝试将其耗尽

您在这里创建的是一个没有专用调度程序的无限源，因此它试图在合并之前将该源完全耗尽—这就是您遇到问题的原因

这在您的实际用例中可能不是问题，因为

GET

请求的结果可能不会是无限的。但是，如果要确保结果是交错的，则只需确保使用自己的调度程序设置每个通量（通过调用

subscribeOn（Schedulers.elastic（））；

对每个通量进行调度）

因此，您的示例变成：

Flux<Integer> flux1 = Flux.<Integer>generate(emitter -> emitter.next(1))
        .subscribeOn(Schedulers.elastic());

Flux<Integer> flux2 = Flux.<Integer>generate(emitter -> emitter.next(2))
        .subscribeOn(Schedulers.elastic());

Flux<Integer> merged = flux1.mergeWith(flux2);
merged.subscribe(s -> System.out.println(s));

Thread.currentThread().join();

flux1=Flux.generate（发射器->发射器.next（1））
.subscribeOn（Schedulers.elastic（））；
通量flux2=通量.generate（发射器->发射器.next（2））
.subscribeOn（Schedulers.elastic（））；
合并通量=flux1.mergeWith（flux2）；
合并.subscribe->System.out.println；
Thread.currentThread（）.join（）；

“Thread.currentThread（）.join（）；”假设其他线程将中断当前线程。另一根线是什么？