Rxjava源码（三）-----线程控制Scheduler

又是一个令人激动的东西，真不想说废话了，开始神奇之旅吧（原谅我这么土鳖，就是觉得很神奇，不看不知道，一看吓一跳啊）

灵活的变换已经让我们眼花缭乱了，线程的自由控制更是让RxJava的牛叉之气更上一层楼。

前边我们已经知道了可以利用subscribeOn()结合observeOn()来实现线程控制，让事件的产生和消费发生在不同的线程，map() flatMap（）等方法都可以多次变换，那线程切换能不能多次呢？

答案当然是能啦，因为observeOn指定的是Subscriber的线程，而这个Subscriber并不一定是（此处可较真，理解为 不是）subscribe（）参数中的Subscriber，而是observeOn()执行时的当前observable所对应的Subscriber,即它的直接下级Subscriber，换句话说，observeOn()指定的是它之后的操作所在的线程，因此，如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次observeOn()即可。

Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定    .subscribeOn(Schedulers.io())    .observeOn(Schedulers.newThread())    .map(mapOperator) // 新线程，由 observeOn() 指定    .observeOn(Schedulers.io())    .map(mapOperator2) // IO 线程，由 observeOn() 指定    .observeOn(AndroidSchedulers.mainThread)     .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

不同于observeOn()，subscribeOn()的位置放哪里都可以，但是它只能调用一次，那如果非要调用多次呢，这个问题我们从线程控制的原理开始说起吧

Scheduler原理：

subscribeOn()和observeOn()的内部实现，也是用了lift()方法，

先看observeOn()吧：

public final Observable<T> observeOn(Scheduler scheduler) {        if (this instanceof ScalarSynchronousObservable) {            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);        }        return lift(new OperatorObserveOn<T>(scheduler));    }

这里分为了两种情况，第一种情况Observable是由just方法创建的，我们看看他的走向：

public Observable<T> scalarScheduleOn(Scheduler scheduler) {        if (scheduler instanceof EventLoopsScheduler) {            EventLoopsScheduler es = (EventLoopsScheduler) scheduler;            return create(new DirectScheduledEmission<T>(es, t));        }        return create(new NormalScheduledEmission<T>(scheduler, t));    }

这里可以看到根据Scheduler的类型又分为两种情况，不过都是创建一个新的Observable<T>对象。那么不同的就是两个OnSubscribe<T>对象了，一个是DirectScheduledEmission，另一个是NormalScheduleEmission。

    /** Optimized observeOn for scalar value observed on the EventLoopsScheduler. */    static final class DirectScheduledEmission<T> implements OnSubscribe<T> {        private final EventLoopsScheduler es;        private final T value;        DirectScheduledEmission(EventLoopsScheduler es, T value) {            this.es = es;            this.value = value;        }        @Override        public void call(final Subscriber<? super T> child) {            child.add(es.scheduleDirect(new ScalarSynchronousAction<T>(child, value)));        }    }

   /** Emits a scalar value on a general scheduler. */    static final class NormalScheduledEmission<T> implements OnSubscribe<T> {        private final Scheduler scheduler;        private final T value;        NormalScheduledEmission(Scheduler scheduler, T value) {            this.scheduler = scheduler;            this.value = value;        }                @Override        public void call(final Subscriber<? super T> subscriber) {            Worker worker = scheduler.createWorker();            subscriber.add(worker);            worker.schedule(new ScalarSynchronousAction<T>(subscriber, value));        }    }

/** Action that emits a single value when called. */    static final class ScalarSynchronousAction<T> implements Action0 {        private final Subscriber<? super T> subscriber;        private final T value;        private ScalarSynchronousAction(Subscriber<? super T> subscriber,                T value) {            this.subscriber = subscriber;            this.value = value;        }        @Override        public void call() {            try {                subscriber.onNext(value);            } catch (Throwable t) {                subscriber.onError(t);                return;            }            subscriber.onCompleted();        }    }

。。。。。。。再来看一下subscribeOn()

public final Observable<T> subscribeOn(Scheduler scheduler) {        if (this instanceof ScalarSynchronousObservable) {            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);        }        return nest().lift(new OperatorSubscribeOn<T>(scheduler));    }

这里我不想先分析第一种情况了，先来看第二种情况吧：

nest()函数干了啥：

public final Observable<Observable<T>> nest() {        return just(this);    }

so easy，调用了just方法，但是请注意，这里的this，把最原始的这个Observable当做参数传入了，

public final static <T> Observable<T> just(final T value) {        return ScalarSynchronousObservable.create(value);    }

还是来复习看一下这个ScalarSynchronousObservable吧

public final class ScalarSynchronousObservable<T> extends Observable<T> {    public static final <T> ScalarSynchronousObservable<T> create(T t) {        return new ScalarSynchronousObservable<T>(t);    }    private final T t;    protected ScalarSynchronousObservable(final T t) {        super(new OnSubscribe<T>() {            @Override            public void call(Subscriber<? super T> s) {                /*                 *  We don't check isUnsubscribed as it is a significant performance impact in the fast-path use cases.                 *  See PerfBaseline tests and https://github.com/ReactiveX/RxJava/issues/1383 for more information.                 *  The assumption here is that when asking for a single item we should emit it and not concern ourselves with                  *  being unsubscribed already. If the Subscriber unsubscribes at 0, they shouldn't have subscribed, or it will                  *  filter it out (such as take(0)). This prevents us from paying the price on every subscription.                  */                s.onNext(t);                s.onCompleted();            }        });        this.t = t;    }          // 暂且省略无关代码

看到这个ScalarSynchronousObservable对象，我们此时需要记住的是：原始Observable被当做一个属性保存在ScalarSynchronousObservable对象中，看图：

以上是nest()函数调用以后发生的事情，接着开始看lift()函数：先复习一下原来我们分析的lift原理图：

lift方法会创建一个Observable<T>对象，该对象的内部有一个OnSubscribe<T>对象，它的call方法会调用OperatorSubscribeOn.call方法得到一个Subscriber<Observable<T>>对象，并在调用上面的Observable<Observable<T>>.OnSubscribe<Observable<T>>.call方法时传递进去。那么来看下OperatorSubscribeOn.call是如何将一个Subscribe<T>转换成Subscriber<Observable<T>>对象的。

public class OperatorSubscribeOn<T> implements Operator<T, Observable<T>> {    private final Scheduler scheduler;    public OperatorSubscribeOn(Scheduler scheduler) {        this.scheduler = scheduler;    }    @Override    public Subscriber<? super Observable<T>> call(final Subscriber<? super T> subscriber) {        final Worker inner = scheduler.createWorker();        subscriber.add(inner);        return new Subscriber<Observable<T>>(subscriber) {            @Override            public void onCompleted() {                // ignore because this is a nested Observable and we expect only 1 Observable<T> emitted to onNext            }            @Override            public void onError(Throwable e) {                subscriber.onError(e);            }            @Override            public void onNext(final Observable<T> o) {                inner.schedule(new Action0() {                    @Override                    public void call() {                        final Thread t = Thread.currentThread();                        o.unsafeSubscribe(new Subscriber<T>(subscriber) {                            @Override                            public void onCompleted() {                                subscriber.onCompleted();                            }                            @Override                            public void onError(Throwable e) {                                subscriber.onError(e);                            }                            @Override                            public void onNext(T t) {                                subscriber.onNext(t);                            }                            @Override                            public void setProducer(final Producer producer) {                                subscriber.setProducer(new Producer() {                                    @Override                                    public void request(final long n) {                                        if (Thread.currentThread() == t) {                                            // don't schedule if we're already on the thread (primarily for first setProducer call)                                            // see unit test 'testSetProducerSynchronousRequest' for more context on this                                            producer.request(n);                                        } else {                                            inner.schedule(new Action0() {                                                @Override                                                public void call() {                                                    producer.request(n);                                                }                                            });                                        }                                    }                                });                            }                        });                    }                });            }        };    }}

可以看到OperatorSubscribeOn对象的call方法里面实例化了一个Subscriber<T>对象并返回。该Subscriber<T>的onNext方法中会调用Scheduler.schedule将一个Action0加入线程池里执行，该Action0的call方法会触发原始Observable<T>的unsafeSubscribe方法，然后会触发原始OnSubscribe<T>.call方法，也就是说原始OnSubscribe<T>.call方法是在切换后的线程中执行。如图