Java 为什么最终订户从未执行？

当运行下面的代码时，将永远不会执行最终订阅服务器。为什么？ 我使用的是rxjava2.1.0；我怀疑线程技术有点胡闹，但很难弄明白这一点

我的实际目标是将id字段值相同的所有Struct实例组合（reduce）到Reduced的单个实例中，然后将其输送到管道中

   @Test
   public void experiment2() throws InterruptedException {

      PublishSubject<Struct> publishSubject = PublishSubject.create();

      publishSubject.buffer(3000, TimeUnit.MILLISECONDS, 10000)
              .flatMap(Observable::fromIterable)
              .groupBy(Struct::getId)
              .flatMap((GroupedObservable<String, Struct> t) -> {
                  return t.reduce(Optional.<Reduced>empty(), (Optional<Reduced> accumulator, Struct str) -> {
                     if (accumulator.isPresent()) {
                        accumulator.get().all.add(str.patternId);
                        return accumulator;
                     } else {
                        Reduced fresh = new Reduced();
                        fresh.all.add(str.patternId);
                        return Optional.of(fresh);
                     }
                  }).toObservable();
              })
              .filter(Optional::isPresent)
              .map(Optional::get)
              .subscribe((Reduced t) -> {
                 //WHY IS THIS NEVER REACHED???
                 System.out.println(t);
              });

      publishSubject.onNext(new Struct("sig1", "A"));
      publishSubject.onNext(new Struct("sig1", "B"));

      Thread.sleep(60000L);
   }

   public static class Reduced {
      private final Set<String> all = ConcurrentHashMap.newKeySet();

      @Override
      public String toString() {
         return all.toString();
      }
   }

   public static class Struct {
      private final String id;
      private final String patternId;

      public Struct(String id, String patternId) {
         this.id = id;
         this.patternId = patternId;
      }

      public String getId() {
         return id;
      }

      public String getPatternId() {
         return patternId;
      }
   }

@测试
public void experiment2（）引发InterruptedException{
PublishSubject PublishSubject=PublishSubject.create（）；
publishSubject.buffer（3000，TimeUnit.ms，10000）
.flatMap（可观察：：fromIterable）
.groupBy（结构：：getId）
.flatMap（（组可观测t）->{
返回t.reduce（可选的.empty（），（可选的累加器，Struct-str）->{
if（累加器.isPresent（））{
acculator.get（）.all.add（str.patternId）；
回流蓄能器；
}否则{
还原新鲜=新还原（）；
fresh.all.add（str.patternId）；
返回可选。of（新鲜）；
}
}).toObservable（）；
})
.filter（可选：：isPresent）
.map（可选：：get）
.订阅（（减少的t）->{
//为什么从来没有达到这个目标？？？
系统输出打印ln（t）；
});
publishSubject.onNext（新结构（“sig1”、“A”）；
publishSubject.onNext（新结构（“sig1”、“B”）；
线程睡眠（60000L）；
}
减少公共静态类{
private final Set all=ConcurrentHashMap.newKeySet（）；
@凌驾
公共字符串toString（）{
返回所有.toString（）；
}
}
公共静态类结构{
私有最终字符串id；
私有最终字符串模式ID；
公共结构（字符串id、字符串模式id）{
this.id=id；
this.patternId=patternId；
}
公共字符串getId（）{
返回id；
}
公共字符串getPatternId（）{
返回模式ID；
}
}

它可能会崩溃，但由于

subscribe（）

中缺少

onError

处理程序，因此您看不到它。如果没有，您可以开始将

System.out.println

放入回调和/或在不同点添加

doOnEach

，以查看数据丢失的位置。如果您在

isPresent（）

上进行筛选，则您的选项可能为空，您可能没有任何数据可以传递到

subscribe

。您是否尝试过在呼叫链中移动

订阅
，以确定哪一步失败？您还可以尝试使用
blockingSubscribe（）
调用来排除潜在的异步骗局。