rxJava学习笔记之observeOn

一段最简单的代码

 longOpeSubscription = Observable.create(new Observable.OnSubscribe<String>() {            @Override            public void call(Subscriber<? super String> subscriber) {                printLog("onStart in OnSubscribe");                subscriber.onStart();                int N = data.length;                for (int i = 0; i < N; i++) {                    dosomethingBlockThread();                    printLog("onNext" + data[i] + " in OnSubscribe");                    subscriber.onNext(data[i]);                }                printLog("OnCompleted in OnSubscribe");                subscriber.onCompleted();            }        })                .observeOn(AndroidSchedulers.mainThread())                .subscribe(new Subscriber<String>() {                    @Override                    public void onCompleted() {                        printLog("OnCompleted in Subscriber");//                        mProgressOperationRunning.setVisibility(View.INVISIBLE);                    }                    @Override                    public void onError(Throwable e) {                        printLog("onError in Subscriber");//                        mProgressOperationRunning.setVisibility(View.INVISIBLE);                    }                    @Override                    public void onNext(String s) {                        printLog("onNext " + s + " in Subscriber");                    }                });

和前两篇同样的分析，observeOn最终是通过lift变换来实现的，这里具体的对象是onSubscribeLift，该对象保存第一次的onSubscribe和operator，operator在这里具体是OperatorObserveOn对象。subscribe会调用observeOn中生成的obervable中的onSubscribe对象中call方法也就是onSubscribeLift的call方法。

 @Override    public void call(Subscriber<? super R> o) {        try {            Subscriber<? super T> st = hook.onLift(operator).call(o);            try {                // new Subscriber created and being subscribed with so 'onStart' it                st.onStart();                parent.call(st);            } catch (Throwable e) {                // localized capture of errors rather than it skipping all operators                 // and ending up in the try/catch of the subscribe method which then                // prevents onErrorResumeNext and other similar approaches to error handling                Exceptions.throwIfFatal(e);                st.onError(e);            }        } catch (Throwable e) {            Exceptions.throwIfFatal(e);            // if the lift function failed all we can do is pass the error to the final Subscriber            // as we don't have the operator available to us            o.onError(e);        }    }

这里首先执行operator的call方法，这里的o也就是下面的child就是最终的subscriber，进入OperatorObserveOn中call中

@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;        }    }

这里最终会返回一个parent对象，也就是ObserveOnSubscriber，其中的scheduler就是我们写的ndroidSchedulers.mainThread()。分析到这里我们回到onSubscribeLift的call方法中的 parent.call(st)这行代码，这里的parent就是create中传入的onSubscribe，这里我们再次调用了st的onNext方法，我们再次跳转到OperatorObserveOn.onNext中：

 @Override        public void onNext(final T t) {            if (isUnsubscribed() || finished) {                return;            }            if (!queue.offer(on.next(t))) {                onError(new MissingBackpressureException());                return;            }            schedule();        }

注意这里if (!queue.offer(on.next(t)))，会将值传入queue中。的最终会进入 recursiveScheduler.schedule(this);这个recursiveScheduler又是什么呢，看源码得知这个是由AndroidSchedulers.mainThread().createWorker()产生的，我们再次寻找，最终recursiveScheduler定位到一个HandlerWorker对象，我们看看HandlerWorker的schedule方法

@Override        public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {            if (unsubscribed) {                return Subscriptions.unsubscribed();            }            action = hook.onSchedule(action);            ScheduledAction scheduledAction = new ScheduledAction(action, handler);            Message message = Message.obtain(handler, scheduledAction);            message.obj = this; // Used as token for unsubscription operation.            handler.sendMessageDelayed(message, unit.toMillis(delayTime));            if (unsubscribed) {                handler.removeCallbacks(scheduledAction);                return Subscriptions.unsubscribed();            }            return scheduledAction;        }

有没有很熟悉，这个handler自然是使用主线程looper的handler了，scheduledAction的run最终会调用action的call，这是一个无参方法，定位到OperatorObserveOn的call，调用最终的subscripter的onNext方法。oberservOn分析完毕