Rxjava-订阅和线程切换简单分析

喜欢的话,评论区留言点赞哦。

Wechat: CoolOriLans 酷奇源语

本篇文章简单分析下 Rxjava 订阅和线程切换简单:

我们先来看一个订阅的流程,这个流程是在之前的基础上,加了些调味剂:

val observable = Observable.create(object : ObservableOnSubscribe { // 返回的是 ObservableCreate 实例;
    override fun subscribe(emitter: ObservableEmitter) {
        emitter.onNext(1)
        emitter.onComplete()
    }
})
val observer = object : Observer {
    override fun onSubscribe(d: Disposable) {
        val d1 = d // 关键点 4: 这个 d 是 ObservableSubscribeOn.SubscribeOnObserver 对象。
        Log.d("rxjava", "Disposable: " +  d1.javaClass.canonicalName);
        // rxjava  : Disposable: io.reactivex.internal.operators.observable.ObservableSubscribeOn.SubscribeOnObserver
    }
    override fun onNext(t: Int) {}
    override fun onError(e: Throwable) {}
    override fun onComplete() {}
}
observable // 关键点 1: 是 ObservableCreate 实例;
.observeOn(Schedulers.io()) // 关键点 2: 切换线程1,返回的是 ObservableObserveOn 实例;
.subscribeOn(Schedulers.single()) // 关键点 3: 切换线程2,返回的是 ObservableSubscribeOn 实例;
.subscribe(observer)

本片文章也就是要弄懂上面的这个 4 个关键点:

注意:

1、我们是先调用 observeOn 再调用 subscribeOn,下面的分析也是按照这个顺序,实际上二者的顺序可以不一样。

这里先简单的总结下(其实网上的很多博客都有讲到,在这里我也总结了下)

subscribeOn 和observeOn 都是用来切换线程用的,但是区别如下:

  • subscribeOn:决定 Observable 对象在哪个线程上执行,其能改变调用它之前代码的线程;
  • observeOn:决定 Subscriber(Observer) 对象在哪个线程上执行,其能改变调用它之后代码的线程;

那么具体是怎么实现的,我们往下慢慢的跟踪代码了;

1 Schedulers - 简单分析

Schedulers 是 Rxjava 的调度器,用于为流提供线程环境,这里先简单的看下,后面会分析:

public final class Schedulers {
    @NonNull
    static final Scheduler SINGLE; // 单线程模式

    @NonNull
    static final Scheduler COMPUTATION;

    @NonNull
    static final Scheduler IO;

    @NonNull
    static final Scheduler TRAMPOLINE;

    @NonNull
    static final Scheduler NEW_THREAD;

    ... ... ... ...
}

Schedulers 默认提供了如上的线程实现。

1.1 Schedulers.io

这里先简单的看下 IO 的实现吧,这样方便我们对线程的切换进行分析:

    public static Scheduler io() {
        // RxJavaPlugins.onIoScheduler 是 hook 用的,这里不关注
        return RxJavaPlugins.onIoScheduler(IO);
    }

实际上默认返回的就是上面的 Schedulers.IO:

public final class Schedulers {

    static {
        SINGLE = RxJavaPlugins.initSingleScheduler(new SingleTask());

        COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());

        // 这里会创建 IO,RxJavaPlugins.initIoScheduler 依然是 Hook 专用的
        // 默认返回 IOTask
        IO = RxJavaPlugins.initIoScheduler(new IOTask());

        TRAMPOLINE = TrampolineScheduler.instance();

        NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
    }
}

我们去看看 IOTask:

1.2 IOTask

    static final class IOTask implements Callable {
        @Override
        public Scheduler call() throws Exception {
            return IoHolder.DEFAULT;
        }
    }

1.3 IoHolder

    static final class IoHolder {
        // 最终实现为 IoScheduler;;
        static final Scheduler DEFAULT = new IoScheduler();
    }

实际上:Schedulers 只是一个包装而已,真正的线程切换是基于平台提供的线程工具的:线程池;

这个我们后面再分析哦。

2 Observable

2.1 observeOn

observeOn 用于指定被观察者逻辑所在的 Scheduler:

Observable.create 返回的是一个 ObservableCreate 实例:

    public final Observable observeOn(Scheduler scheduler) {
        return observeOn(scheduler, false, bufferSize());
    }

    public final Observable observeOn(Scheduler scheduler, boolean delayError) {
        return observeOn(scheduler, delayError, bufferSize());
    }

    // 核心方法 3
    public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        // RxJavaPlugins.onAssembly 用于 Hook 操作,这里不关注
        //【-->3】默认返回 ObservableObserveOn 实例:
        return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize));
    }

observeOn 有三个重载函数。

最终调用的都是核心方法 3

可以看到,默认其返回了一个 ObservableObserveOn 对象。将 ObservableCreate 包装到了内部,如下;

ObservableObserveOn [ // --> 3
    ObservableCreate [ 
        ObservableOnSubscribe [  
            emitter: ObservableEmitter
        ]  
    ]  
]

其实脉络已经很清楚了;

2.2 subscribeOn

observeOn 用于指定观察者逻辑所在的 Scheduler:

    public final Observable subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        //【-->4.x】进入;
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
    }

可以看到,默认其返回了一个 ObservableSubscribeOn 对象。将 ObservableCreate 包装到了内部!

如下:

ObservableSubscribeOn [ // --> 4
    ObservableObserveOn [ // --> 3
        ObservableCreate [ 
            ObservableOnSubscribe [  
                emitter: ObservableEmitter
            ]  
        ]  
    ]
]

其实脉络已经很清楚了;

3 ObservableObserveOn

3.1 constructor

ObservableObserveOn 的父类 AbstractObservableWithUpstream 继承了 Observable,所以 ObservableObserveOn 具有 Observable 的能力:

public final class ObservableObserveOn extends AbstractObservableWithUpstream { // 如下:
    final Scheduler scheduler;
    final boolean delayError;
    final int bufferSize;
    
    // 参数 Scheduler 是调度器;
    public ObservableObserveOn(ObservableSource source, Scheduler scheduler, boolean delayError, int bufferSize) {
        super(source); // 是 ObservableCreate 实例;
        this.scheduler = scheduler;
        this.delayError = delayError;
        this.bufferSize = bufferSize;
    }
    

按照例子的顺序,这里的 ObservableSource source 是 ObservableCreate 实例!

abstract class AbstractObservableWithUpstream extends Observable implements HasUpstreamObservableSource {
    protected final ObservableSource source;
    ... ... ...
}

public interface HasUpstreamObservableSource {
    ObservableSource source();
}

3.2 subscribeActual

我们回忆下 subscribe 的流程,subscribe 实际上最后会调用 subscribeActual

但是此时执行完 observeOn 后,返回的是 ObservableObserveOn,其将 ObservableCreate 封装在了内部,所以会先执行 ObservableObserveOn.subscribeActual

    @Override
    protected void subscribeActual(Observer observer) { //【-->4.3】是 SubscribeOnObserver 实例
        // 核心 1: 如果 scheduler 是 TrampolineScheduler 类型的,那么会直接执行订阅
        // 对观察者 observer 不做任何的包装;
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            // 核心 2: 如果是其他类型的,那么这里会通过 scheduler 创建对应的 Worker
            Scheduler.Worker w = scheduler.createWorker();
            // 核心 3: 然后将观察者 observer 封装成一个 【-->3.3】ObserveOnObserver,然后在执行订阅;
            // source 是【-->6.1】 ObservableCreate 实例;
            source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
        }
    }

这样,相当于发射器通过 ObserveOnObserver 委托代理执行 Observer 的方法了;

source 是 ObservableCreate 实例,这里最终会调用 ObservableCreate.subcribeActual。

只不过参数由 Observer 变成了 ObserveOnObserver(Observer)。

    ObservableObserveOn [ // --> 3
        ObservableCreate [ 
            ObservableOnSubscribe [  
                emitter: ObservableEmitter
            ]  
        ]  
    ].subscribe -> subscribeActual {
        ObserveOnObserver [
            SubscribeOnObserver [ // 下面返回的;
                
            ]
        ]
    }

3.3 ObserveOnObserver - 切换核心

ObserveOnObserver 是 ObservableObserveOn 的内部类:

3.3.1 Constructor

   static final class ObserveOnObserver extends BasicIntQueueDisposable
   implements Observer, Runnable {

        private static final long serialVersionUID = 6576896619930983584L;
        final Observer downstream; //【1】下游的观察者;
        final Scheduler.Worker worker; //【2】线程调度;
        final boolean delayError;
        final int bufferSize;

        SimpleQueue queue;

        Disposable upstream; // 表示上游的数据源,

        Throwable error;
        volatile boolean done;

        volatile boolean disposed;

        int sourceMode;

        boolean outputFused;

        ObserveOnObserver(Observer actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.downstream = actual; //【3】表示下游的数据接收方 Observer 实例,本例中是 SubscribeOnObserver 实例;
            this.worker = worker; //【4】线程调度;
            this.delayError = delayError;
            this.bufferSize = bufferSize;
        }
       ... ... ...
   }

由于 ObserveOnObserver 本质也是一个 Observer,他代理了 Observer 一系列方法,我们去看看

3.3.2 onSubscribe

在订阅发生之前会先执行 onSubscribe 方法:

参数 Disposable d 就是 CreateEmitter 发射器!

        @Override
        public void onSubscribe(Disposable d) {
            if (DisposableHelper.validate(this.upstream, d)) {
                // 核心 1: CreateEmitter 作为发射器,用于发射数据;
                this.upstream = d;
                if (d instanceof QueueDisposable) {
                    @SuppressWarnings("unchecked")
                    QueueDisposable qd = (QueueDisposable) d;

                    int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);

                    if (m == QueueDisposable.SYNC) {
                        sourceMode = m;
                        queue = qd;
                        done = true;
                        downstream.onSubscribe(this);
                        schedule();
                        return;
                    }
                    if (m == QueueDisposable.ASYNC) {
                        sourceMode = m;
                        queue = qd;
                        downstream.onSubscribe(this);
                        return;
                    }
                }

                queue = new SpscLinkedArrayQueue(bufferSize);
                // 核心 2: 调用下游的 Observer 的 onSubscribe 方法,将自身传递下去!
                // downstream 是 SubscribeOnObserver
                downstream.onSubscribe(this);
            }
        }

3.3.3 onNext

        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            if (sourceMode != QueueDisposable.ASYNC) {
                // 把执行的结果保存到内部队列里;
                queue.offer(t);
            }
            schedule();
        }

3.3.4 onError

        @Override
        public void onError(Throwable t) {
            if (done) {
                RxJavaPlugins.onError(t);
                return;
            }
            // 保存错误到 error.
            error = t;
            done = true;
            schedule();
        }

3.3.5 onComplete

        @Override
        public void onComplete() {
            if (done) {
                return;
            }
            done = true;
            schedule();
        }

4 ObservableSubscribeOn

4.1 constructor

同样的,ObservableSubscribeOn 也继承了 AbstractObservableWithUpstream 类,也具有 Observable 的能力:

public final class ObservableSubscribeOn extends AbstractObservableWithUpstream { // 如下:
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
        super(source); // 父类的变量;
        this.scheduler = scheduler;
    }

注意:按照例子的顺序,这里的 ObservableSource source 是 ObservableObserveOn 实例!(这里不一定是这样,因为调用顺序可以切换)

abstract class AbstractObservableWithUpstream extends Observable implements HasUpstreamObservableSource {

    /** The source consumable Observable. */
    protected final ObservableSource source;
    
    ... ... ...
}

4.2 subscribeActual - 切换核心

    @Override
    public void subscribeActual(final Observer observer) {
        //【-->4.3】将 observer 包装成 SubscribeOnObserver 实例;;
        final SubscribeOnObserver parent = new SubscribeOnObserver(observer);
        // 核心:这里立刻回调,这个回调会触发器上面的关键点 4:
        observer.onSubscribe(parent);
        //【-->】创建了 SubscribeTask 实例,将 SubscribeOnObserver 保存到内部;;
        // SubscribeTask 是一个 Runnable 实例;;
        //【-->4.3.5】scheduler.scheduleDirect 会返回一个 Disposable 对象。
        // SubscribeOnObserver 会持有该对象的原子引用;;
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

4.2.1 SubscribeTask - 切换核心

可以看到 SubscribeTask 实际上就是一个 Runnable 实例;

这里其实已经能够看到线程的切换的实现:将 Observer 封装到 SubscribeTask ( Runnable ) 中,通过 handler / ThreadPool 执行:

    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent; //【-->4.3】SubscribeOnObserver 实例

        SubscribeTask(SubscribeOnObserver parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            // 这里的 source 来自 ObservableSubscribeOn
            // 就是 ObservableObserveOn 实例了;
            //【-->3.2】这样就进入了 ObservableObserveOn 的 subscribeActual 方法; 
            source.subscribe(parent);
        }
    }

4.3 SubscribeOnObserver

是对 Observer 的封装,继承了 AtomicReference 类,内部持有 Disposable 对象的原子引用:

    static final class SubscribeOnObserver extends AtomicReference implements Observer, Disposable {

        private static final long serialVersionUID = 8094547886072529208L;
        final Observer downstream; // 下游的观察者;

        final AtomicReference upstream;

        SubscribeOnObserver(Observer downstream) {
            this.downstream = downstream; // 这个就是我们的 obsever
            this.upstream = new AtomicReference();
        }
    }

可以的得到如下的关系图了:

ObservableSubscribeOn [ // --> 4
    ObservableObserveOn [ // --> 3
        ObservableCreate [ 
            ObservableOnSubscribe [  
                emitter: ObservableEmitter
            ]  
        ]  
    ]
].subscribe -> subscribeActual {
    SubscribeOnObserver [
        Observer [
            ...
        ]
    ]
}

4.3.1 onSubscribe

保存上游的 Disposable 实例:

        @Override
        public void onSubscribe(Disposable d) {
            // 核心 1,这里的 d 是 ObserveOnObserver 实例【-->4.3.1】;
            DisposableHelper.setOnce(this.upstream, d);
        }

4.3.2 onNext

发送数据:

        @Override
        public void onNext(T t) {
            downstream.onNext(t);
        }

4.3.3 onError

发送异常:

        @Override
        public void onError(Throwable t) {
            downstream.onError(t);
        }

4.3.4 onComplete

完成回调:

        @Override
        public void onComplete() {
            downstream.onComplete();
        }

4.3.5 setDisposable - 核心

设置 Disposable 对象的弱引用,这个 Disposable 对象是由 Scheduler 对 new SubscribeTask(SubscribeOnObserver)) 封装后返回的:

        void setDisposable(Disposable d) {
            DisposableHelper.setOnce(this, d);
        }

4.3.5.1 DisposableHelper.setOnce

DisposableHelper 枚举类封装了对 Disposable 的操作:

    public static boolean setOnce(AtomicReference field, Disposable d) {
        ObjectHelper.requireNonNull(d, "d is null");
        // 通过 CAS 设置内部的 field 变量为 d;
        if (!field.compareAndSet(null, d)) {
            // 如果失败的话,那么说明内部已经有 Disposable 对象了
            // 那这里会执行 d 的取下操作;
            d.dispose();
            if (field.get() != DISPOSED) {
                reportDisposableSet();
            }
            return false;
        }
        return true;
    }

不多说了。

4.3.6 dispose

取消订阅:

@Override
public void dispose() {
    // 清空对上游的弱引用;
    DisposableHelper.dispose(upstream);
    // 清空自身对下游的弱引用:SubscribeTask【-->4.2.1】
    DisposableHelper.dispose(this);
}

4.3.6 isDisposed

是否取消订阅:

@Override
public boolean isDisposed() {
    return DisposableHelper.isDisposed(get());
}

5 subscribe 再分析

接下来,我们来看看,在执行了 observeOn 和 subscribeOn 后的执行逻辑:

回顾一下:

observable // 关键点 1: 是 ObservableCreate 实例
.observeOn(Schedulers.io()) // 关键点 2: 被观察者所在的线程,返回的是 ObservableObserveOn 实例;
.subscribeOn(Schedulers.single()) // 关键点 3: 观察者所在的线程,返回的是 ObservableSubscribeOn 实例;
.subscribe(observer)

实际上经过了 observeOn/subscribeOn 方法的执行,整个逻辑变的很复杂了;

5.1 subscribe 回顾

subscribe 方法会调用 subscribeActual 方法:

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer observer) {
        try {
            // --> 按照现在的逻辑,进入 4.2 了;
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            ... ... ...
            throw npe;
        }
    }

按照上面的包装顺序,会先调用 ObservableSubscribeOn 的 subscribeActual 方法了;

6 ObservableCreate - 回顾

6.1 subscribeActual - 回顾

回顾下 subscribeActual 方法:

    @Override
    protected void subscribeActual(Observer observer) {
        // 核心 1: 创建的 CreateEmitter 实例,包装下 Observer; 
        // 此时的 observer
        CreateEmitter parent = new CreateEmitter(observer);
        // 核心 2: 这里的 observer 就是【-->3.3】ObserveOnObserver 实例;
        observer.onSubscribe(parent);

        try {
            // 核心 1: 这里的 source 是 ObservableOnSubscribe 实例;
            // 见【-->6.2】ObservableOnSubscribe
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

6.2 ObservableOnSubscribe

回顾下 ObservableOnSubscribe

public interface ObservableOnSubscribe {
    void subscribe(@NonNull ObservableEmitter emitter) throws Exception;
}

在这个方法中,我们使用:

emitter.onNext(1)
emitter.onComplete()

6.2.1 onNext

发射数据:

@Override
public void onNext(T t) {
    if (t == null) {
        onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
        return;
    }
    if (!isDisposed()) {
        // 这里的 observer 实际上是【-->3.3】ObserveOnObserver 实例;
        observer.onNext(t);
    }
}

7 总结

总结一下哈

7.1 完整订阅的流程

我们回顾下整个流程,下面的这个流程包含了线程切换的流程,以及调度的走势:

(好累,后序补上哦)

7.2 线程切换的关键

被观察者的线程切换的 Mr.Key : ObservableObserveOn 和 ObserveOnObserver

观察者的线程切换的 Mr.Key : ObservableSubscribeOn 和 SubscribeOnObserver

7.2.1 ObservableObserveOn 的关键点

  • ObservableObserveOn 内部会讲 Scheduler 保存下来
    // 参数 Scheduler 是调度器;
    public ObservableObserveOn(ObservableSource source, Scheduler scheduler, boolean delayError, int bufferSize) {
        super(source); // 是 ObservableCreate 实例;
        this.scheduler = scheduler;
  • subscribeActual 方法,这里会实现订阅,用 ObserveOnObserver 封装 observer,同时传入 Scheduler.Worker 作为调度器:
    @Override
    protected void subscribeActual(Observer observer) { //【-->4.3】是 SubscribeOnObserver 实例
        // 核心 1: 如果 scheduler 是 TrampolineScheduler 类型的,那么会直接执行订阅
        // 对观察者 observer 不做任何的包装;
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            // 核心 2: 如果是其他类型的,那么这里会通过 scheduler 创建对应的 Worker
            Scheduler.Worker w = scheduler.createWorker();
            // 核心 3: 然后将观察者 observer 封装成一个 【-->3.3】ObserveOnObserver,然后在执行订阅;
            // source 是【-->6.1】 ObservableCreate 实例;
            source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
        }
    }
  • ObserveOnObserver 中的 onNext 通过 schedule() 通过线程池实现在指定线程中执行数据分发:
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            if (sourceMode != QueueDisposable.ASYNC) {
                queue.offer(t);
            }
            // 执行线程池调度;
            schedule();
        }

        void schedule() {
            if (getAndIncrement() == 0) {
                worker.schedule(this); // 将自身加入到 worker 中;
            }
        }

刚刚我们说了 ObserveOn 能改变调用后的逻辑所在的线程,这里其实已经能看到原因了。

按照逻辑,发射器最终会调用 ObserveOnObserver 的 onNext/onComplete 方法,而这个方法会讲 ObserveOnObserver 自身(就是一个 Runnable)放入 worker 中执行调度,后续的操作就会在 worker 所在的线程了(这是一个上游 -> 下游的过程);

到这里,就能够推断,ObserveOn 是可以调多次的,每次都会将下游的回调逻辑通过装饰器的方式切换到对应的线程;

7.2.2 ObservableSubscribeOn 的关键点

  • ObservableSubscribeOn 内部会讲 Scheduler 保存下来
public final class ObservableSubscribeOn extends AbstractObservableWithUpstream { // 如下:
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
        super(source); // 父类的变量;
        this.scheduler = scheduler;
    }
  • subscribeActual 方法,这里会实现订阅,用 ObserveOnObserver 封装 observer,同时传入 Scheduler.Worker 作为调度器:
    @Override
    public void subscribeActual(final Observer observer) {
        //【-->4.3】将 observer 包装成 SubscribeOnObserver 实例;;
        final SubscribeOnObserver parent = new SubscribeOnObserver(observer);
        // 这里立刻回调;
        observer.onSubscribe(parent);
        //【-->】创建了 SubscribeTask 实例,将 SubscribeOnObserver 保存到内部;;
        // SubscribeTask 是一个 Runnable 实例;;
        //【-->4.3.5】scheduler.scheduleDirect 会返回一个 Disposable 对象。
        // SubscribeOnObserver 会持有该对象的原子引用;;
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }
  • SubscribeTask 本质上就是一个 runnable:
    final class SubscribeTask implements Runnable {
        //【-->4.3】SubscribeOnObserver 实例
        private final SubscribeOnObserver parent;

        SubscribeTask(SubscribeOnObserver parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            // 这里的 source 来自 ObservableSubscribeOn
            // 就是 ObservableObserveOn 实例了;
            //【-->3.2】这样就进入了 ObservableObserveOn 的 subscribeActual 方法; 
            source.subscribe(parent);
        }
    }

刚刚我们说了 subscribeOn 能改变调用前的逻辑所在的线程,这里其实已经能看到原因了。

按照逻辑,这里会将 source.subscribe(parent) 放到 scheduler 指定的线程中执行,而 subscribe 是一个从下游->上游的过程。

source.subscribe(parent) 会按照订阅流程,向上不断的执行 source[x].subscribe(parent) -> source[x].subscribeActual(parent)

一直到最终的 ObservableOnSubscribe ,而这个过程是在 scheduler 指定的线程中执行。

同时,当到 ObservableOnSubscribe 的时候,会通过发射器发送数据,这样又会变成上游 -> 下游,而发生器也是在 ObservableOnSubscribe.subscribe 方法中触发,所以此时依然是在 scheduler 指定的线程中执行。

最终,执行到最近的 ObserveOn 处,这里才会切换线程,这样下游的调度线程都会在 ObserveOn 方法进行切换了;

疑问

上面是先调用 observeOn 再调用 subscribeOn,实际上二者的顺序可以不一样。如果我们反过来呢?

如果反过来的话只是装饰的对象顺序发生了变化,对于 subscribeOn 和 observeOn 的效果依然是没有变化的。

这里不多说了,溜了溜了。

你可能感兴趣的:(Rxjava-订阅和线程切换简单分析)