RxJava2 (四)切换UI主线程源码阅读

RxJava2 (一)订阅流程源码阅读
RxJava2 (二)取消订阅流程 dispose( ) 源码阅读
RxJava2 (三)线程切换源码阅读
RxJava2 (四)切换UI主线程源码阅读
RxJava2 (五)just操作符源码阅读
RxJava2 (六)map操作符源码阅读

依赖

implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation 'io.reactivex.rxjava2:rxjava:2.x.x'

代码示例

Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        System.out.println("被观察者发射数据线程: " + Thread.currentThread().getId());
        emitter.onNext(100);
    }
});
// 被观察者发射消息从io线程
Observable<Integer> observable2 = observable1.subscribeOn(Schedulers.io());
// 观察者接收消息后在UI住线程中处理数据
Observable<Integer> observable3 = observable2.observeOn(AndroidSchedulers.mainThread());
observable3.subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
        System.out.println("onSubscribe");
    }
    @Override
    public void onNext(Integer integer) {
        System.out.println("onNext: " + integer);
        System.out.println("观察者接收数据线程: " + Thread.currentThread().getId());
    }
    @Override
    public void onError(Throwable e) {
        System.out.println("onError");
    }
    @Override
    public void onComplete() {
        System.out.println("onComplete");
    }
}

概述

1. observable1对象的真实类型为ObservableCreate,它持有一个ObservableOnSubscribe对象引用.
2. observable2对象的真实类型为ObservableSubscribeOn,它持有一个ObservableCreate对象引用.
3. observable3对象的真实类型为ObservableObserveOn,它持有一个ObservableSubscribeOn对象引用.
4. .subscribe(Observer)方法后的API调用流程,流程脉络清楚再来看线程的切换就相当的简单了.
   • ObservableObserveOn.subscribe(Observer)⬇
   • ObservableObserveOn.subscribeActual(Observer)⬇
   • ObservableSubscribeOn.subscribe(ObserveOnObserver)⬇
   • ObservableSubscribeOn.subscribeActual(ObserveOnObserver)⬇ 这里会切换被观察者发射数据的线程
   • ObservableCreate.subscribe(SubscribeOnObserver)⬇
   • ObservableCreate.subscribeActual(SubscribeOnObserver)⬇
   • ObservableOnSubscribe.subscribe(ObservableEmitter)⬇
   • ObservableEmitter.onNext(100)⬇
   • SubscribeOnObserver.onNext(t)⬇
   • ObserveOnObserver.onNext(t)⬇ 这里会切换观察者接收数据的线程
   • Observer.onNext(t)⬇
     如何将观察者接收数据的线程切换到Android的UI线程总体逻辑和之前的文章差不多,切换UI线程使用的是Android中的Handler来操作的.

ObserveOnObserver.onNext(t)

概述中说过在ObserveOnObserver.onNext(t)调用的时候,将观察者接收数据的流程切换到UI线程执行.

1. AndroidSchedulers.mainThread()返回的对象类型为HandlerScheduler.

public final class AndroidSchedulers {
    public static Scheduler mainThread() {
        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
    }
    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
            new Callable<Scheduler>() {
                @Override public Scheduler call() throws Exception {
                    return MainHolder.DEFAULT;
                }
            });
    private static final class MainHolder {
        // 最终返回的对象类型为HandlerScheduler.
        static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
    }
}

2. observable2.observeOn(AndroidSchedulers.mainThread())看下HandlerScheduler如何存储

public abstract class Observable<T> implements ObservableSource<T> {
    public final Observable<T> observeOn(Scheduler scheduler) {
        return observeOn(scheduler, false, bufferSize());
    }
    public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        ...
        // 最终将HandlerScheduler对象存储在ObservableObserveOn对象中了.
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }
}

3. ObserveOnObserver何时被创建.

public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
        super(source);
        this.scheduler = scheduler; // 为HandlerScheduler对象
        this.delayError = delayError;
        this.bufferSize = bufferSize;
    }
    protected void subscribeActual(Observer<? super T> observer) {
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            // 这里将创建HandlerWorker对象
            Scheduler.Worker w = scheduler.createWorker();
            // 这里创建ObserveOnObserver对象.
            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
        }
    }
}

4. 当使用ObservableEmitter.onNext(100)发射数据最终会委托给ObserveOnObserver.onNext(t)

public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>implements Observer<T>, Runnable {
        ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.downstream = actual;// 用户创建的观察者
            this.worker = worker;// HandlerWorker对象
            this.delayError = delayError;
            this.bufferSize = bufferSize;
        }
        // 用户发射的数据最终会委托给该方法
        @Override
        public void onNext(T t) {
            ...
            // 这里先将消息t存入队列中,等会发送的时候会将消息取出来的.
            queue.offer(t);
            schedule();
        }
        // this: ObserveOnObserver本身也是一个Runnable对象
        void schedule() {
            if (getAndIncrement() == 0) {
                // worke是HandlerWorker对象,接着下面看
                worker.schedule(this);
            }
        }
    }
}

5. 看HandlerWorker.schedule(this), 这里再强调一次this:是一个ObserveOnObserver对象,ObserveOnObserver父类是Runnable,它实现了run()方法.
   • 先来看下如何创建HandlerScheduler如何创建HandlerWorker对象

      final class HandlerScheduler extends Scheduler {
          // 创建HandlerWorker
          public Worker createWorker() {
                  return new HandlerWorker(handler, async);
              }
      }
   

   • 调用HandlerWorker对象的schedule()方法

      final class HandlerScheduler extends Scheduler {
          private static final class HandlerWorker extends Worker {
              // run参数实际是ObserveOnObserver对象
              public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
                  ...
                  // ScheduledRunnable也是一个Runnable类型的对象,调用该对象的run()最终会执行ObserveOnObserver.run().
                  ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
                  // 将ScheduledRunnable对象放入Message中
                  Message message = Message.obtain(handler, scheduled);
                  ...
                  // 使用UI Handler将消息发送到主线程中处理.
                  handler.sendMessageDelayed(message, unit.toMillis(delay));
                  ...
                  return scheduled;
              }
          }
      }
   

6. 上面将Runnable发送到UI Handler中执行,最后肯定是在UI主线程去处理这个消息了,主线程处理Runnable最终会调用到ObserveOnObserver对象的run()方法

public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>implements Observer<T>, Runnable {
        // 此时的run()方法将在Android UI的主线程中执行.
        @Override
        public void run() {
            if (outputFused) {
                drainFused();
            } else {
                drainNormal();
            }
        }
        void drainNormal() {
            ...
            final Observer<? super T> a = downstream;
            // 将消息存储在队列中
            final SimpleQueue<T> q = queue;
            // downstream就是用户创建的观察者对象.
            final Observer<? super T> a = downstream;
            // 取出消息
            v = q.poll();
            // 调用用户创建的Observer观察者对象的onNext(v)方法将消息传出.
            a.onNext(v);
            ..
        }
        void drainFused() {
            ...
            // 观察者中的onNext()被调用.
            downstream.onNext(null);
        }
    }
}