FlatMap and subscribeOn

Hello there. Consider this observable

Observable.just(1)
  .flatMap( i -> {
    Timber.d("FLATMAP PRE-1: %d - %s", Thread.currentThread().getId(), Thread.currentThread().getName());
    return Observable.create(s -> {
       Timber.d("FLATMAP PRE-1-CALL: %d - %s", Thread.currentThread().getId(), Thread.currentThread().getName());
       s.onNext(i);
       s.onCompleted();
    })
  .subscribeOn(Schedulers.io())
  .flatMap( i -> {
    Timber.d("FLATMAP POST-1: %d - %s", Thread.currentThread().getId(), Thread.currentThread().getName());
    return Observable.create(s -> {
       Timber.d("FLATMAP POST-1-CALL: %d - %s", Thread.currentThread().getId(), Thread.currentThread().getName());
       s.onNext(i);
       s.onCompleted();
    })
    .subscribe( i -> {
        Timber.d("Subscribe: Thread: %d - %s", Thread.currentThread().getId(), Thread.currentThread().getName());
    });

This will emit the following:

FLATMAP PRE-1: 1 - main
FLATMAP PRE-1-CALL: 1 - main
FLATMAP POST-1: 1 - main
FLATMAP POST-1-CALL: 1 - main
Subscribe: Thread: 1 - main

This means that it subscribeOn is “lost” when flatMap is called?

[dwursteisen]

subscribeOn will run the code which perform the subscription into the schedculer given in subscribeOn.

So Observable.just(...) will executed in the io thread pool. And all sub sequent call too, if you don’t give another Scheduler using observeOn.

ie:

Observable.just(1) // 1 will be emited in the IO thread pool
                  .subscribeOn(Schedulers.io())
                  .flatMap(...) // will be in the IO thread pool
                  .observeOn(Schedulers.computation())
                  .flatMap(...) // will be executed in the computation thread pool
                  .observeOn(AndroidSchedulers.mainThread())
                  .subscribe(); // will be executed in the Android main thread (if you're running your code on Android)

[soshial]

Important thing to note though, that if Observables inside flatMap would subscribe on some other thread, then these flatMaps would override initial thread. E.g.:

    public void main() {
        Observable.just(1)
                  .subscribeOn(Schedulers.io())
                  .observeOn(Schedulers.io()) // this is put just for demonstration
                  .doOnNext(this::printThread) // IO
                  .flatMap(i -> incrementOnIoThread1(i)) // or incrementOnIoThread2(i)
                  .subscribe(this::printThread // computation
                             , throwable -> {});
    }

    public Observable<Integer> incrementOnIoThread1(int i) {
        return Observable.just(i + 1)
                .observeOn(Schedulers.computation());
    }

    public Observable<Integer> incrementOnIoThread2(int i) {
        return Observable.just(i + 1)
                .subscribeOn(Schedulers.computation());
    }

The only thing we can to alleviate this, is to add observeOn after flatMap, as Karnok said here.