从源码出发了解RxJava的使用（下）

---

序言

  终于到了RxJava中的最重要环节——线程控制，是不是有些小激动啊~，不要着急，让我们怀着好奇的心情一步步地揭开它的面纱，看它究竟是何方神圣。

Scheduler

  Schedulers.immediate()直接在当前的线程中运行，相当于不指定线程。这是默认的 Scheduler。
  Schedulers.newThread()总是启动新线程，并在新线程中执行操作。
  Schedulers.io()I/O操作（读写文件、读写数据库、访问网络），内部是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。但不要把计算工作放在 io() 中，这样可以避免创建不必要的线程。
  Schedulers.computation()内部使用固定数量的线程池，大小为 CPU 核数。适合计算工作，如图形的计算。但不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。
  AndroidSchedulers.mainThread()指定运行在Android的UI线程。
  我们可以通过subscribeOn方法和observeOn方法来实现线程的来回切换。但这两个方法是有区别的。
  observeOn方法指定的是它之后的操作所在的线程，因此如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次observeOn方法即可。
  subscribeOn方法的位置放在哪里都可以，也可以多次调用，但只有第一次是有效的（即能切换线程）。

线程控制-1

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        Log.i("My", "OnSubscribe.call " + Thread.currentThread().getName());
        subscriber.onNext(null);
    }
});
observable = observable.subscribeOn(Schedulers.io());
observable = observable.observeOn(AndroidSchedulers.mainThread());
observable.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        Log.i("My", "Action1.call " + Thread.currentThread().getName());
    }
});

  运行结果：
  

observable.subscribeOn(Schedulers.io());

public final Observable<T> subscribeOn(Scheduler scheduler) {
    return create(new OperatorSubscribeOn<T>(this, scheduler));
}

new OperatorSubscribeOn<T>(this, scheduler)

public final class OperatorSubscribeOn<T> implements OnSubscribe<T> {

    final Scheduler scheduler;
    final Observable<T> source;

    public OperatorSubscribeOn(Observable<T> source, Scheduler scheduler) {
        this.scheduler = scheduler;
        this.source = source;
    }

    @Override
    public void call(final Subscriber<? super T> subscriber) {
        final Worker inner = scheduler.createWorker();

        inner.schedule(new Action0() {
            @Override
            public void call() {
                final Thread t = Thread.currentThread();

                Subscriber<T> s = new Subscriber<T>(subscriber) {
                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);
                    }

                    @Override
                    public void onError(Throwable e) {
                        subscriber.onError(e);
                    }

                    @Override
                    public void onCompleted() {
                        subscriber.onCompleted();
                    }

                    @Override
                    public void setProducer(final Producer p) {
                        subscriber.setProducer(new Producer() {
                            @Override
                            public void request(final long n) {
                                if (t == Thread.currentThread()) {
                                    p.request(n);
                                } else {
                                    inner.schedule(new Action0() {
                                        @Override
                                        public void call() {
                                            p.request(n);
                                        }
                                    });
                                }
                            }
                        });
                    }
                };

                source.unsafeSubscribe(s);
            }
        });
    }
}

observable.observeOn(AndroidSchedulers.mainThread());

public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
    return lift(new OperatorObserveOn<T>(scheduler, delayError, bufferSize));
}

new OperatorObserveOn<T>(scheduler, delayError, bufferSize)

public final class OperatorObserveOn<T> implements Operator<T, T> {

    private final Scheduler scheduler;

    public OperatorObserveOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        this.scheduler = scheduler;
    }

    @Override
    public Subscriber<? super T> call(Subscriber<? super T> child) {
        if (scheduler instanceof ImmediateScheduler) {
            // avoid overhead, execute directly
            return child;
        } else if (scheduler instanceof TrampolineScheduler) {
            // avoid overhead, execute directly
            return child;
        } else {
            ObserveOnSubscriber<T> parent = new ObserveOnSubscriber<T>(scheduler, child, delayError, bufferSize);
            parent.init();
            return parent;
        }
    }

    private static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Action0 {

        final Subscriber<? super T> child;
        final Scheduler.Worker recursiveScheduler;
        final AtomicLong counter = new AtomicLong();

        public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> child, boolean delayError, int bufferSize) {
            this.child = child;
            this.recursiveScheduler = scheduler.createWorker();
        }

        void init() {
            Subscriber<? super T> localChild = child;
            localChild.setProducer(new Producer() {
                @Override
                public void request(long n) {
                    schedule();
                }
            });
        }

        @Override
        public void onNext(final T t) {
            schedule();
        }

        @Override
        public void onCompleted() {
            schedule();
        }

        @Override
        public void onError(final Throwable e) {
            schedule();
        }

        protected void schedule() {
            if (counter.getAndIncrement() == 0) {
                recursiveScheduler.schedule(this);
            }
        }

        // only execute this from schedule()
        @Override
        public void call() {
            final Subscriber<? super T> localChild = this.child;
            localChild.onNext(localOn.getValue(v));
        }
    }
}

  总结：

Observable.create.subscribeOn.observeOn
OnSubscribe（my） --> OperatorSubscribeOn --> OnSubscribeLift#OperatorObserveOn

1>> subscribe(mySubscriber)
    static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
        subscriber.onStart();  // subscriber为mySubscriber
        onSubscribe.call(subscriber);  // OnSubscribeLift#OperatorObserveOn
        return subscription;
    }
2>> onSubscribe.call(subscriber) --> OnSubscribeLift#OperatorObserveOn.call(mySubscriber)
    public void call(Subscriber<? super R> o) {  // o为mySubscriber
        Subscriber<? super T> st = operator.call(o);  // operator为OperatorObserveOn
        st.onStart();
        onSubscribe.call(st);  // onSubscribe为OperatorSubscribeOn
    }
3>> operator.call(o) --> OperatorObserveOn.call(mySubscriber)
    public Subscriber<? super T> call(Subscriber<? super T> child) {  // child为mySubscriber
        ObserveOnSubscriber<T> parent = new ObserveOnSubscriber<T>(scheduler, child, delayError, bufferSize);
        return parent;
    }
4>> onSubscribe.call(st) --> OperatorSubscribeOn.call(ObserveOnSubscriber st)
    public void call(final Subscriber<? super T> subscriber) {  // subscriber为ObserveOnSubscriber
        final Worker inner = scheduler.createWorker();
        inner.schedule(new Action0() {
            @Override
            public void call() {
                Subscriber<T> s = new Subscriber<T>(subscriber) {
                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);
                    }
                };
                source.unsafeSubscribe(s);  // source为Observable#OnSubscribe（my）
            }
        });
    }
5>> source.unsafeSubscribe(s) --> Observable#OperatorSubscribeOn.unsafeSubscribe(Subscriber#ObserveOnSubscriber)
    public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {  // subscriber为Subscriber#ObserveOnSubscriber
        subscriber.onStart();
        onSubscribe.call(subscriber);  // onSubscribe为OnSubscribe（my）
        return subscription;
    }
6>> onSubscribe.call(subscriber) --> OnSubscribe（my）.call(Subscriber#ObserveOnSubscriber)
    public void call(Subscriber<? super String> subscriber) {  // Subscriber#ObserveOnSubscriber
        Log.i("My", "OnSubscribe.call " + Thread.currentThread().getName());
        subscriber.onNext(null);
    }
7>> subscriber.onNext(null) --> Subscriber#ObserveOnSubscriber.onNext(null)
    public void onNext(T t) {
        subscriber.onNext(t);  // subscriber为ObserveOnSubscriber
    }
8>> subscriber.onNext(t) --> ObserveOnSubscriber.onNext(t)
    public void onNext(final T t) {
        schedule();
    }
9>> ObserveOnSubscriber.call()
    public void call() {
        final Subscriber<? super T> localChild = this.child;  // child为mySubscriber
        localChild.onNext(localOn.getValue(v));
    }

线程控制-2

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        Log.i("My", "OnSubscribe.call " + Thread.currentThread().getName());
        subscriber.onNext(null);
    }
});
observable = observable.subscribeOn(Schedulers.io());
observable = observable.subscribeOn(Schedulers.io());
observable.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        Log.i("My", "Action1.call " + Thread.currentThread().getName());
    }
});

  运行结果：
  

  总结：

Observable.create.subscribeOn.subscribeOn
OnSubscribe（my） --> OperatorSubscribeOn（1） --> OperatorSubscribeOn（2）

1>> subscribe(mySubscriber)
    static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
        subscriber.onStart();  // subscriber为mySubscriber
        onSubscribe.call(subscriber);  // OperatorSubscribeOn（2）
        return subscription;
    }
2>> onSubscribe.call(subscriber) --> OperatorSubscribeOn（2）.call(mySubscriber)
    public void call(final Subscriber<? super T> subscriber) {  // subscriber为mySubscriber
        final Worker inner = scheduler.createWorker();
        inner.schedule(new Action0() {
            @Override
            public void call() {
                Subscriber<T> s = new Subscriber<T>(subscriber) {
                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);
                    }
                };
                source.unsafeSubscribe(s);  // source为Observable#OperatorSubscribeOn（1）
            }
        });
    }
3>> source.unsafeSubscribe(s) --> Observable#OperatorSubscribeOn（1）.unsafeSubscribe(Subscriber#mySubscriber)
    public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {  // subscriber为Subscriber#mySubscriber
        subscriber.onStart();
        onSubscribe.call(subscriber);  // onSubscribe为OperatorSubscribeOn（1）
        return subscription;
    }
4>> onSubscribe.call(subscriber) --> OperatorSubscribeOn（1）.call(Subscriber#mySubscriber)
    public void call(final Subscriber<? super T> subscriber) {  // subscriber为Subscriber#mySubscriber
        final Worker inner = scheduler.createWorker();
        inner.schedule(new Action0() {
            @Override
            public void call() {
                Subscriber<T> s = new Subscriber<T>(subscriber) {
                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);
                    }
                };
                source.unsafeSubscribe(s);  // source为Observable#OnSubscribe（my）
            }
        });
    }
5>> source.unsafeSubscribe(s) --> Observable#OnSubscribe（my）.unsafeSubscribe(Subscriber#Subscriber#mySubscriber)
    public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {  // subscriber为Subscriber#Subscriber#mySubscriber
        subscriber.onStart();
        onSubscribe.call(subscriber);  // onSubscribe为OnSubscribe（my）
        return subscription;
    }
6>> onSubscribe.call(subscriber) --> OnSubscribe（my）.call(Subscriber#Subscriber#mySubscriber)
    public void call(Subscriber<? super String> subscriber) {  // Subscriber#Subscriber#mySubscriber
        Log.i("My", "OnSubscribe.call " + Thread.currentThread().getName());
        subscriber.onNext(null);
    }
7>> subscriber.onNext(null) --> mySubscriber.call(null)
    public void call(String s) {
        Log.i("My", "Action1.call " + Thread.currentThread().getName());
    }

  对RxJava的源码分析已经结束了，看完这三篇文章，想必大家对它底层的实现已经有一定深入的了解了吧。在这里感谢你们的耐心阅读，希望我的分享能真正给你们带来好处，还是那句话，写博客不易，喜欢我就“顶”我一下吧~。