RxJava订阅&；观察家；带平面图的块。谁做什么？

这是我第一次用RxJava做实验

我试着用它来完成一个简单的任务：数据需要通过Java应用程序从数据库中导出。导出分为三个步骤：

发出查询以查找需要导出的对象的主键

批处理这些ID，并并行地获取/封送完整的对象

将封送的对象写入输出流

我认为一个好的方法是让一个线程执行步骤1（在ResultSet的页面上迭代），一个线程池执行步骤2（每个ResultSet页面一个任务），主线程执行步骤3（这需要在单个线程上发生）

我知道阻塞主线程在Rx世界中并不被视为一件好事，但对于这个问题，我们忽略它。这是我第一次在遗留应用程序上引入反应式编程

上述场景的测试如下所示：

   @Test
   public void testSimplePipelineRx()
   {
      Scheduler idsScheduler = makeScheduler("idsExecutor");
      Scheduler dataScheduler = makeScheduler("dataExecutor");

      final List<MutablePair<Integer, List<Integer>>> stateHolder = new CopyOnWriteArrayList<>();

      Observable<Integer> idsObservable = Observable.create(SyncOnSubscribe.createSingleState(
            () ->
            {
               print("ids observable initialized");
               stateHolder.add(emitIds());
               return stateHolder.get(0);
            },
            (state, observer) ->
            {
               if (state.getLeft() >= state.getRight().size())
               {
                  print("ids observable next - emitting onComplete");
                  observer.onCompleted();
               }
               else
               {
                  Integer val = state.getRight().get(state.getLeft());
                  state.setLeft(state.getLeft() + 1);

                  print("ids observable next - emitting " + val);
                  observer.onNext(val);
               }
            },
            (state) ->
            {
               print("ids observable finish");
               state.setLeft(-1);
               state.getRight().clear();
            }
      ));

      final ConcurrentHashMap<String, Boolean> results = new ConcurrentHashMap<>();

      print("Starting");

      idsObservable
            .buffer(2)
            .flatMap(i -> Observable.just(i)
                           .observeOn(dataScheduler)
                           .map(k ->
                                {
                                   print("Transforming values: " + k.get(0) + "-" + k.get(k.size() - 1));
                                   return "Values: " + k.get(0) + "-" + k.get(k.size() - 1);
                                })
                  , 5 //max count flatMap will have queued up
            )
            .subscribeOn(idsScheduler)
            .toBlocking()
            .subscribe(new Subscriber<String>()
            {
               @Override
               public void onStart()
               {
                  request(5);
               }

               @Override
               public void onCompleted()
               {
                  print("Observed done");
               }

               @Override
               public void onError(Throwable err)
               {
                  print(ExceptionUtils.getStackTrace(err));
                  print("Observed error");
               }

               @Override
               public void onNext(String str)
               {
                  print("Observed value " + str);
                  results.put(str, true);
                  request(1);
               }
            });

      print("Asserting");
      Assert.assertEquals(Integer.valueOf(-1), stateHolder.get(0).getLeft());
      Assert.assertEquals(0, stateHolder.get(0).getRight().size());
      Assert.assertEquals(7, results.keySet().size());
      print("Finishing");
   }

   private MutablePair<Integer, List<Integer>> emitIds()
   {
      return new MutablePair<>(0, IntStream.range(0, 13).mapToObj(i -> i).collect(Collectors.toList()));
   }

   private Scheduler makeScheduler(String name)
   {
      ExecutorService executor = Executors.newFixedThreadPool(10, new ThreadFactory()
      {
         private AtomicInteger id = new AtomicInteger(0);

         @Override
         public Thread newThread(Runnable r)
         {
            return new Thread(r, name + "-" + id.getAndIncrement());
         }
      });

      return Schedulers.from(executor);
   }

   private void print(String msg)
   {
      System.out.println(new SimpleDateFormat("HH:mm:ss.SSS").format(new Date()) + " - " + Thread.currentThread().getName() + " - " + msg);
   }

---

为什么“dataExecutor”线程在接近结束时接管了值的“发射”？我希望“idsExecutor-0”线程是唯一一个“发出”值的线程

这是RxJava中基于共同例程的背压设计和

observeOn

操作符的效果：来自

observeOn

的发出线程的请求调用可能在

SyncOnSubscribe

内部执行生成器（这称为弱管道）。要确保

SyncOnSubscribe

从已知线程生成项目，请直接在其后面使用

subscribeOn

（这称为强管道）：

---

这是RxJava中基于共同例程的背压设计和

observeOn

操作符的效果：来自

observeOn

的发出线程的请求调用可能在

SyncOnSubscribe

内部执行生成器（这称为弱管道）。要确保

SyncOnSubscribe

从已知线程生成项目，请直接在其后面使用

subscribeOn

（这称为强管道）：

---

非常感谢你。这有文件记录吗？我读到的每一篇文章都说“subscribeOn”的位置无关紧要。显然是这样！不管你把subscribee放在管道的什么地方，但重要的是你把它放在哪个可观察的对象上。你有两个观察到的。平面图中的外部和内部。subscribeOn将在idsObservable上创建observable。observeOn将在同一线程上创建Observable.just并切换到dataScheduler。该值将通过切换线程沿管道向下推送（ToBlock/subscribe）。因此，您的所有排放都是在flatMap之后的observeOn线程上发生的。谢谢您的评论。但并非所有的排放都来自数据调度程序。有些是从IDScheduler发生的（前5个，然后是更多），而另一些则是从dataScheduler开始发生的。这就是让我感到困惑的原因。正如我在前面的评论中解释的那样，到平面图为止的所有事情都会发生在subscribeOn上。flatMap将使用observeOn将排放切换到另一个线程。一切都将在flatMap调度线程上发生。这正是日志所显示的。请记住，flatMap是一种fork-join机制。因此，可观测源将发射，而平面贴图也可以发射。因此，source和flatMap的排放可以混合在日志中。非常感谢。这有文件记录吗？我读到的每一篇文章都说“subscribeOn”的位置无关紧要。显然是这样！不管你把subscribee放在管道的什么地方，但重要的是你把它放在哪个可观察的对象上。你有两个观察到的。平面图中的外部和内部。subscribeOn将在idsObservable上创建observable。observeOn将在同一线程上创建Observable.just并切换到dataScheduler。该值将通过切换线程沿管道向下推送（ToBlock/subscribe）。因此，您的所有排放都是在flatMap之后的observeOn线程上发生的。谢谢您的评论。但并非所有的排放都来自数据调度程序。有些是从IDScheduler发生的（前5个，然后是更多），而另一些则是从dataScheduler开始发生的。这就是让我感到困惑的原因。正如我在前面的评论中解释的那样，到平面图为止的所有事情都会发生在subscribeOn上。flatMap将使用observeOn将排放切换到另一个线程。一切都将在flatMap调度线程上发生。这正是日志所显示的。请记住，flatMap是一种fork-join机制。因此，可观测源将发射，而平面贴图也可以发射。因此，源排放和flatMap排放可在日志中混合。

16:25:36.168 - main - Starting
16:25:36.185 - idsExecutor-0 - ids observable initialized
16:25:36.194 - idsExecutor-0 - ids observable next - emitting 0
16:25:36.194 - idsExecutor-0 - ids observable next - emitting 1
16:25:36.201 - idsExecutor-0 - ids observable next - emitting 2
16:25:36.202 - dataExecutor-0 - Transforming values: 0-1
16:25:36.202 - idsExecutor-0 - ids observable next - emitting 3
16:25:36.202 - idsExecutor-0 - ids observable next - emitting 4
16:25:36.202 - dataExecutor-1 - Transforming values: 2-3
16:25:36.202 - idsExecutor-0 - ids observable next - emitting 5
16:25:36.202 - idsExecutor-0 - ids observable next - emitting 6
16:25:36.202 - idsExecutor-0 - ids observable next - emitting 7
16:25:36.203 - idsExecutor-0 - ids observable next - emitting 8
16:25:36.203 - idsExecutor-0 - ids observable next - emitting 9
16:25:36.203 - dataExecutor-3 - Transforming values: 6-7
16:25:36.203 - dataExecutor-2 - Transforming values: 4-5
16:25:36.204 - dataExecutor-4 - Transforming values: 8-9
16:25:36.206 - main - Observed value Values: 0-1
****16:25:36.206 - dataExecutor-3 - ids observable next - emitting 10
****16:25:36.206 - dataExecutor-3 - ids observable next - emitting 11
16:25:36.206 - main - Observed value Values: 2-3
****16:25:36.206 - dataExecutor-3 - ids observable next - emitting 12
16:25:36.206 - dataExecutor-5 - Transforming values: 10-11
16:25:36.206 - main - Observed value Values: 4-5
****16:25:36.206 - dataExecutor-3 - ids observable next - emitting onComplete
16:25:36.207 - main - Observed value Values: 6-7
****16:25:36.207 - dataExecutor-3 - ids observable finish
16:25:36.207 - main - Observed value Values: 8-9
16:25:36.207 - dataExecutor-6 - Transforming values: 12-12
16:25:36.207 - main - Observed value Values: 10-11
16:25:36.208 - main - Observed value Values: 12-12
16:25:36.208 - main - Observed done
16:25:36.208 - main - Asserting
16:25:36.208 - main - Finishing

Observable.range(1, 5)
.subscribeOn(Schedulers.io())
.map(v -> Thread.currentThread() + "|" + v)
.observeOn(Schedulers.single())
.subscribe(w -> Thread.currentThread() + "||" + w);

Thread.sleep(1000);