RxJava调度程序不'；不要睡觉换线

我面临着非常奇怪的RxJava行为，我无法理解

假设我想并行处理元素。我使用flatMap来实现：

public static void log(String msg) {
    String threadName = Thread.currentThread().getName();
    System.out.println(String.format("%s - %s", threadName, msg));
}

public static void sleep(int ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) throws InterruptedException {

    Scheduler sA = Schedulers.from(Executors.newFixedThreadPool(1));
    Scheduler sB = Schedulers.from(Executors.newFixedThreadPool(5));

    Observable.create(s -> {
        while (true) {
            log("start");
            s.onNext(Math.random());
            sleep(10);
        }
    }).subscribeOn(sA)
            .flatMap(r -> Observable.just(r).subscribeOn(sB))
            .doOnNext(r -> log("process"))
            .subscribe((r) -> log("finish"));
}

结果是可以预测的：

pool-1-thread-1 - start
pool-2-thread-1 - process
pool-2-thread-1 - finish
pool-1-thread-1 - start
pool-2-thread-2 - process
pool-2-thread-2 - finish
pool-1-thread-1 - start
pool-2-thread-3 - process
pool-2-thread-3 - finish

好吧，但如果我在flatMap并行化调度程序停止更改线程后，在映射中添加n>10的睡眠

public static void main(String[] args) throws InterruptedException {

    Scheduler sA = Schedulers.from(Executors.newFixedThreadPool(1));
    Scheduler sB = Schedulers.from(Executors.newFixedThreadPool(5));

    Observable.create(s -> {
        while (true) {
            log("start");
            s.onNext(Math.random());
            sleep(10);
        }
    }).subscribeOn(sA)
            .flatMap(r -> Observable.just(r).subscribeOn(sB))
            .doOnNext(r -> sleep(15))
            .doOnNext(r -> log("process"))
            .subscribe((r) -> log("finish"));
}

以下是什么原因：

pool-1-thread-1 - start
pool-1-thread-1 - start
pool-2-thread-1 - process
pool-2-thread-1 - finish
pool-1-thread-1 - start
pool-1-thread-1 - start
pool-2-thread-1 - process
pool-2-thread-1 - finish
pool-1-thread-1 - start
pool-2-thread-1 - process

---

为什么？？？为什么在flatMap之后，所有元素都在同一个线程（池-2-thread-1）中处理？

flatMap将所有并行任务序列化回单个线程，您可以查看此线程。试试这个

public static void main(String[] args) throws InterruptedException {

Scheduler sA = Schedulers.from(Executors.newFixedThreadPool(1));
Scheduler sB = Schedulers.from(Executors.newFixedThreadPool(5));

Observable.create(s -> {
    while (!s.isUnsubscribed()) {
        log("start");
        s.onNext(Math.random());
        sleep(10);
    }
}).subscribeOn(sA)
        .flatMap(r -> 
            Observable.just(r)
            .subscribeOn(sB)
            .doOnNext(r -> sleep(15))
            .doOnNext(r -> log("process"))
        )
        .subscribe((r) -> log("finish"));
}

---

非常感谢。为什么我不在睡觉的情况下偷看这个线程呢？源之间存在一个不确定的发射竞争，一些线程也可能发射其他线程的元素。