RxJava: onBackpressureBlock () comportamiento extraño

Estoy jugando con RxJava (RxKotlin para ser preciso). Aquí tengo los siguientes Observable :

 fun metronome(ms: Int) = observable<Int> { var i = 0; while (true) { if (ms > 0) { Thread.sleep(ms.toLong()) } if (it.isUnsubscribed()) { break } it.onNext(++i) } } 

Y me gustaría que algunos de ellos se fusionen y se ejecuten al mismo time. Ignoran la contrapresión, por lo que los operadores de contrapresión deben aplicarse a ellos.

Luego creo

 val cores = Runtime.getRuntime().availableProcessors() val threads = Executors.newFixedThreadPool(cores) val scheduler = Schedulers.from(threads) 

Y luego fusiono el metronome s:

 val o = Observable.merge(listOf(metronome(0), metronome(1000).map { "---------" }) .map { it.onBackpressureBlock().subscribeOn(scheduler) }) .take(5000, TimeUnit.MILLISECONDS) 

Se supone que el primero debe emitir elementos incesantemente. Si lo hago en los últimos 3 segundos de la ejecución obtengo el siguiente resultado:

 ... [RxComputationThreadPool-5]: 369255 [RxComputationThreadPool-5]: 369256 [RxComputationThreadPool-5]: 369257 [RxComputationThreadPool-5]: --------- [RxComputationThreadPool-5]: --------- [RxComputationThreadPool-5]: --------- 

Parece que los Observable están suscritos en el mismo hilo, y el primer observable está bloqueado por más de 3 segundos.

Pero cuando cambio en las onBackpressureBlock() y subscribeOn(scheduler) el resultado se convierte en lo que esperaba, el resultado se fusiona durante toda la ejecución.

Es obvio para mí que el order llama la atención en RxJava, pero no entiendo muy bien qué sucede en esta situación particular.

Entonces, ¿qué sucede cuando se onBackpressureBlock operador onBackpressureBlock antes de subscribeOn onBackpressureBlock qué ocurre si después ?