Rx java 如何并行共享RxJava Observable？

在下面的示例代码中，我尝试从远程源1和远程源2获取数据，这两个数据都需要从远程源0输入。我只希望从source0获取一次，同时从source1和source2获取

public class TestReactiveX5 {
  public static void main(String[] args) throws Exception {
    Scheduler scheduler = Schedulers.io();
    RemoteSourceData<Integer, Integer> source0 = new RemoteSource0();
    RemoteSourceData<Integer, String> source1 = new RemoteSource1();
    RemoteSourceData<Integer, String> source2 = new RemoteSource2();

    Observable<Integer> i = Observable.just(1);
    Observable<Integer> i0 = i.map(input -> source0.getData(input)).share();
    Observable<String> fooSource = i0.map(input0 -> source1.getData(input0)).subscribeOn(scheduler);
    Observable<String> barSource = i0.map(input0 -> source2.getData(input0)).subscribeOn(scheduler);

    Observable<List<String>> merged = Observable.merge(fooSource, barSource).toList();
    merged.subscribe(val -> System.out.println(val));

    Thread.sleep(15000);
  }

  @FunctionalInterface
  private static interface RemoteSourceData<IN, OUT> {
    public OUT getData(IN input);
  }

  public static class RemoteSource0 implements RemoteSourceData<Integer, Integer> {
    @Override
    public Integer getData(Integer input) {
      try {
        System.out.println("fetch from remote Source0 " + new Timestamp(System.currentTimeMillis()));
        Thread.sleep(2000L);
      } catch (InterruptedException ex) {
        // ignore
      }
      return 0;
    }
  }

  private static class RemoteSource1 implements RemoteSourceData<Integer, String> {
    @Override
    public String getData(Integer i) {
      try {
        System.out.println("fetch from remote Source1 " + new Timestamp(System.currentTimeMillis()));
        Thread.sleep(4000L);
      } catch (InterruptedException ex) {
        // ignore
      }
      return "foo";
    }
  }

  private static class RemoteSource2 implements RemoteSourceData<Integer, String> {
    @Override
    public String getData(Integer i) {
      try {
        System.out.println("fetch from remote Source2 " + new Timestamp(System.currentTimeMillis()));
        Thread.sleep(4000L);
      } catch (InterruptedException ex) {
        // ignore
      }
      return "bar";
    }
  }
}

如果删除share（），则并行获取Source1和Source2，但需要对Source0进行两次调用：

fetch from remote Source0 2016-06-03 16:05:48.027
fetch from remote Source0 2016-06-03 16:05:48.027
fetch from remote Source1 2016-06-03 16:05:50.028
fetch from remote Source2 2016-06-03 16:05:50.028
[foo, bar]

---

如何获得对Source0的一次调用和对Source1&Source2的并行调用？

源没有被并行查询，因为它们使用同一个线程，您可以在来自不同源的操作之间休眠该线程

我添加了一些额外的日志记录，以便为您显示正在执行的线程基本示例：

从远程源获取0 2016-06-03 23:28:35.426 Thread=线程[RxIoScheduler-2,5，main] 从远程源获取1 2016-06-03 23:28:37.426线程=线程[RxIoScheduler-2,5，main] 从远程源获取2 2016-06-03 23:28:41.426线程=线程[RxIoScheduler-2,5，main] [foo，bar]

正如您所看到的，对于预期进入睡眠状态2秒和4秒的所有任务，都是相同的线程

我尝试了

subscribeOn

和

observeOn

的不同配置，但我不能说RxJava在某些情况下做它所做的事情对我来说是完全透明的，但以下是一些对我有用的东西：

publicstaticvoidmain（字符串[]args）引发异常{
调度器调度器=Schedulers.io（）；
RemoteSourceData source0=新的RemoteSource0（）；
RemoteSourceData source1=新的RemoteSource1（）；
RemoteSourceData source2=新的RemoteSource2（）；
可观测i=可观测的.just（1）.subscribeOn（调度器）；
Observable i0=i.map（source0:：getData）.share（）；
Observable fooSource=i0.observeOn（调度器）.map（source1:：getData）；
Observable barSource=i0.observeOn（调度器）.map（source2:：getData）；
Observable merged=obbservable.merge（fooSource，barSource.toList（）；
merged.subscribe（System.out:：println）；
睡眠（15000）；
}

输出：

从远程源获取0 2016-06-03 23:37:11.264 Thread=Thread[RxIoScheduler-3,5，main] 从远程源获取1 2016-06-03 23:37:13.265线程=线程[RxIoScheduler-2,5，main] 从远程源获取2 2016-06-03 23:37:13.265线程=线程[RxIoScheduler-4,5，main] [foo，bar]

---

现在

fooSource

和

barSource

各有专用线程并并行运行。

这些源没有被并行查询，因为它们使用相同的线程，您可以在来自不同源的操作之间休眠这些线程

我添加了一些额外的日志记录，以便为您显示正在执行的线程基本示例：

从远程源获取0 2016-06-03 23:28:35.426 Thread=线程[RxIoScheduler-2,5，main] 从远程源获取1 2016-06-03 23:28:37.426线程=线程[RxIoScheduler-2,5，main] 从远程源获取2 2016-06-03 23:28:41.426线程=线程[RxIoScheduler-2,5，main] [foo，bar]

正如您所看到的，对于预期进入睡眠状态2秒和4秒的所有任务，都是相同的线程

我尝试了

subscribeOn

和

observeOn

的不同配置，但我不能说RxJava在某些情况下做它所做的事情对我来说是完全透明的，但以下是一些对我有用的东西：

publicstaticvoidmain（字符串[]args）引发异常{
调度器调度器=Schedulers.io（）；
RemoteSourceData source0=新的RemoteSource0（）；
RemoteSourceData source1=新的RemoteSource1（）；
RemoteSourceData source2=新的RemoteSource2（）；
可观测i=可观测的.just（1）.subscribeOn（调度器）；
Observable i0=i.map（source0:：getData）.share（）；
Observable fooSource=i0.observeOn（调度器）.map（source1:：getData）；
Observable barSource=i0.observeOn（调度器）.map（source2:：getData）；
Observable merged=obbservable.merge（fooSource，barSource.toList（）；
merged.subscribe（System.out:：println）；
睡眠（15000）；
}

输出：

从远程源获取0 2016-06-03 23:37:11.264 Thread=Thread[RxIoScheduler-3,5，main] 从远程源获取1 2016-06-03 23:37:13.265线程=线程[RxIoScheduler-2,5，main] 从远程源获取2 2016-06-03 23:37:13.265线程=线程[RxIoScheduler-4,5，main] [foo，bar]

现在

fooSource

和

barSource

各有专用线程，并并行运行。

使用.cache（）代替.share（）。使用.cache（）代替.share（）。

fetch from remote Source0 2016-06-03 16:05:48.027
fetch from remote Source0 2016-06-03 16:05:48.027
fetch from remote Source1 2016-06-03 16:05:50.028
fetch from remote Source2 2016-06-03 16:05:50.028
[foo, bar]