Rxjava2来分析一波

这里主要讲一下rxjava2在面试中回答点。
1、rxjava2的基本使用

   Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("1");  //发起事件源
                emitter.onNext("2");
                emitter.onNext("3");
                emitter.onComplete();

            }
        }).flatMap(new Function<String, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(String s) throws Exception {
                return Observable.just(s);
            }
        }).map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) throws Exception {
                return null;
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "integer = " + integer);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                });

关于使用这里就不过多的介绍来，主要说一下map和flatmap的区别。
map和flatmap功能是一致的都是为了转换对象，map可以转换为任意对象，而flatmap只能转换成ObservableSource对象。

2、rxjava2订阅流程和事件源发出流程分析。
任务链的构建：
每次调用一个操作符，都会生成一个被观察者对象，并且这个被观察者对象持有上一个被观察者的引用，来看一下create操作符的实现。
在Observable中调用cretae操作符代码如下

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

返回了一个ObservableCreate的被观察者对象，里面传了一个source对象，这个source相当要监听的事件源（就相当于source发生了改变它会告诉ObservableCreate对象，observableCrate，接着告诉下一个被观察者）。
接着在observableCrate的基础上又调用了flatmap的操作符，看一下代码

     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
            boolean delayErrors, int maxConcurrency, int bufferSize) {
       //省略代码
        return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));
    }

生成了一个新的观察者ObservableFlatMap，并持有ObservableCreate对象的引用。
接着的map subcribeOn道理一样就不分析了，直接看最后一个observeOn这个操作符代码如下

 @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }

最后直接调用ObservableObserveOn的subcribe方法。
此时从crete到observeOn形成了一个链条，下层的被观察者对象持有上一层被观察者的引用，这就为逆序订阅打下基础。

来看一下ObservableObserveOn的subcribe方法，最终会调用ObservableObserveOn的scribeActual方法具体代码如下

   @Override
    protected void subscribeActual(Observer<? super T> observer) {
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            Scheduler.Worker w = scheduler.createWorker();

            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
        }
    }

生成一个这一层的观察者对象ObserveOnObserver并持有下一层的观察者的引用，这是为事件下发作准备，然后用上一层的观察者引用调用subcribe方法注册这个观察者对象，就这样从下到上层层注册。

当事件源触发的时候会从上到下的出发每一层的观察者最终到我们自己实现的观察者。

AndroidSchedulers.mainThread() 最终是通过handler将上游的数据切换到祝线程的。
Schedules.IO 会创建一个创建一个runnable对象，将上一层的订阅放在这个runnable对象的run方法里面，这个runnable也会被扔进一个线程池中执行。

3、rxjava2使用注意的问题等。
内存泄漏问题（autodispose）和错误处理忘记写
autodispose 原理及其使用