Question

我的问题陈述如下：

从源中阅读
将数据分为a类，b类
种类a和种类b将它们分开并独立运行
折叠a和b结果

为此，我正在使用源的可观察对象

AtomicLong appendX = new AtomicLong();
AtomicLong totalNumbers = new AtomicLong();
Observable<Integer> emission = Observable.fromIterable(() -> IntStream.range(1,11).iterator()).map(i -> {

  totalNumbers.incrementAndGet();
  long sleep = random.nextInt(100);
  log.info("Sleeping 1 {} for {}", i, sleep);
  Thread.sleep(sleep);
  return i;
});

我归类

enum Kind {
  DIVISIBLE_BY_THREE,
  EVEN
}

Observable<Tuple2<Integer, List<Kind>>> firstPass = emission.map(i -> {
  Tuple2<Integer, List<Kind>> finding = Tuple.of(i, new ArrayList<>());
  if (i % 3 == 0) {
    finding._2().add(Kind.DIVISIBLE_BY_THREE);
  }
  if (i % 2 == 0) {
    finding._2().add(Kind.EVEN);
  }
  return finding;
}).publish();

我使用publish，因此它是共享的，可以使用创建独立观察者的过滤器对其进行拆分

Observable<Tuple2<Integer, List<Kind>>> divByThreeFiltered = firstPass.filter(t -> {
  log.info("divByThreeFiltered {}", t._1);
  return t._2().contains(Kind.DIVISIBLE_BY_THREE);
});

Observable<Tuple2<Integer, List<Kind>>> evenFiltered = firstPass.filter(t -> {
  log.info("evenFiltered       {}", t._1);
  return t._2().contains(Kind.EVEN);
});

并同时处理它们

Observable<String> even = evenFiltered
    .map(i -> {
      return i._1() + "-" + i._2().stream()
          .map(e -> e.name()).collect(Collectors.joining(","));
    });
Observable<String> divByThree = divByThreeFiltered.map(i -> {
  long sleep = random.nextInt(100);
  log.info("Sleeping 2 {} for {}", i._1, sleep);
  Thread.sleep(sleep);
  return i._1() + "-" + i._2().stream()
      .map(e -> e.name()).collect(Collectors.joining(","));
});

最终合并它们

List<String> l = new ArrayList<>();
Single<List<String>> vals =
    divByThree.mergeWith(even)
        .map(
            i -> {
              appendX.incrementAndGet();
              log.info("append xxxx {}", i);
              return i + "-XXXX";
            })
        .reduce(
            l,
            (List<String> li, String s) -> {
              li.add(s);
              return li;
            });

firstPass.connect();
List<String> to = vals.blockingGet();

此过程仅发出一次可观察到的信号，但由于减少而挂起

List<String> to = vals.blockingGet();

为什么不减少费用或对此事进行过滤？

以及如何解决问题陈述？

我使用可观察的语言
使用昂贵的计算对数据进行分类
分类后，可观察到的流需要不同的处理，并出于性能原因并发运行
要求减少两个流

可拆分多播可观察到最终合并为一个可观察

0 个答案: