谜之RxJava （三）update 2 —— subscribeOn 和 observeOn 的区别

开头

之前我们分析过subscribeOn这个函数，
现在我们来看下subscribeOn和observeOn这两个函数到底有什么异同。

用过rxjava的旁友都知道，subscribeOn和observeOn都是用来切换线程用的，可是我什么时候用subscribeOn，什么时候用observeOn呢，我们很少知道这两个区别是啥。

友情提示，如果不想看分析过程的，可以直接跳到下面的总结部分。

subscribeOn

先看下OperatorSubscribeOn的核心代码：

public final class OperatorSubscribeOn implements OnSubscribe {

    final Scheduler scheduler;
    final Observable source;

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

    @Override
    public void call(final Subscriber subscriber) {
        final Worker inner = scheduler.createWorker();
        subscriber.add(inner);
        
        inner.schedule(new Action0() {
        
            @Override
            public void call() {
               
                Subscriber s = new Subscriber(subscriber) {
                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);
                    }
                    
                    @Override
                    public void onError(Throwable e) {
                        try {
                            subscriber.onError(e);
                        } finally {
                            inner.unsubscribe();
                        }
                    }
                    
                    @Override
                    public void onCompleted() {
                        try {
                            subscriber.onCompleted();
                        } finally {
                            inner.unsubscribe();
                        }
                    }
                    
                    ....
                };
                
                source.unsafeSubscribe(s);
            }
        });
    }
}

这里注意两点：

1. 因为OperatorSubscribeOn是个OnSubscribe对象，所以在call参数中传入的subscriber就是我们在外面使用Observable.subscribe(a)传入的对象a。

2. 这里source对象指向的是调用subscribeOn之前的那个Observable序列。

明确了这两点，我们就很好的知道了subscribeOn是如何工作，产生神奇的效果了。
其实最最主要的就是一行函数

source.unsafeSubscribe(s);

并且要注意它所在的位置，是在worker的call里面，说白了，就是把source.subscribe这一行调用放在指定的线程里，那么总结起来的结论就是：

subscribeOn的调用，改变了调用前序列所运行的线程。

observeOn

同样看下OperatorObserveOn这个类的主要代码:

public final class OperatorObserveOn implements Operator {

    private final Scheduler scheduler;
    private final boolean delayError;

    /**
     * @param scheduler the scheduler to use
     * @param delayError delay errors until all normal events are emitted in the other thread?
     */
    public OperatorObserveOn(Scheduler scheduler, boolean delayError) {
        this.scheduler = scheduler;
        this.delayError = delayError;
    }

    @Override
    public Subscriber call(Subscriber child) {
        ....
        ObserveOnSubscriber parent = new ObserveOnSubscriber(scheduler, child, delayError);
        parent.init();
        return parent;
    }

    /** Observe through individual queue per observer. */
    private static final class ObserveOnSubscriber extends Subscriber implements Action0 {
        final Subscriber child;
        final Scheduler.Worker recursiveScheduler;
        final NotificationLite on;
        final boolean delayError;
        final Queue