Rxjava2.x使用源码分析杂记

1.RxJava2.x基本使用
    1.1 Observable被观察者创建:
         Observable stringObservable = Observable.create(new ObservableOnSubscribe() {
            @Override
             public void subcribe(ObservableEmitter e) throws Exception {
                e.onNext(); //反射数据
             }
         });
         Observable::create
         @SchedulerSupport(SchedulerSupport.NONE)
         public static  Observable create(ObservableOnSubscribe source) {
             ObjectHelper.requireNonNull(source, "source is null");
             return RxJavaPlugins.onAssembly(new ObservableCreate(source));
         }
        使用装饰器模式创建一个ObservableCreate修饰ObservableOnSubscribe并返回，ObservableCreate是Observable的一个实现类，
        返回的stringObservable就是ObservableCreate对象。
    1.2 绑定观察者，也就是订阅过程 Observer订阅被观察者，此时还未涉及到线程切换，所有的操作均是在demo主线程运行
        stringObservable.subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                // 1.所有操作中最先被调用
            }

            @Override
            public void onNext(String value) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
        此时调用ObservableCreate的subscribe方法 -> 也就是Observable的subscribe方法:
            @SchedulerSupport(SchedulerSupport.NONE)
            @Override
            public final void subscribe(Observer observer) {
                ObjectHelper.requireNonNull(observer, "observer is null");
                try {
                    observer = RxJavaPlugins.onSubscribe(this, observer); //这里直接将传入的observer返回

                    ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");//判空操作

                    subscribeActual(observer);
                } catch (NullPointerException e) { // NOPMD
                    throw e;
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    // can't call onError because no way to know if a Disposable has been set or not
                    // can't call onSubscribe because the call might have set a Subscription already
                    RxJavaPlugins.onError(e);

                    NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
                    npe.initCause(e);
                    throw npe;
                }
            }
        真正调用到具体实现类的subscribeActual方法，也就是ObservableCreate的subscribeActual方法:
          @Override
            protected void subscribeActual(Observer observer) {
                CreateEmitter parent = new CreateEmitter(observer); //同样对传入的观察者进行了一层封装
                observer.onSubscribe(parent); //此时调用观察者的onSubscribe 所以该方法是在所有方法中最先调用的

                try {
                    source.subscribe(parent); //source也就是 ObservableCreate修饰的内部类(称之为上游)
                } catch (Throwable ex) {
                    Exceptions.throwIfFatal(ex);
                    parent.onError(ex);
                }
            }
        subscribeActual的作用是将当前订阅传入的observer观察者进行一次封装，使用封装类去订阅当前Observable的上游，也可以理解为最外层的observer修饰类去订阅最内层的被修饰的Observable
        也就是CreateEmitter订阅到了ObservableOnsubscribe。
    1.3 数据的发射      CreateEmitter.onNext()
        ObservableCreate::CreateEmitter CreateEmitter是ObservableCreate的一个内部类
        @Override
            public void onNext(T t) {
                if (t == null) {
                    onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                    return;
                }
                if (!isDisposed()) {
                    observer.onNext(t); //
                }
            }
        CreateEmitter的next内部调用了被CreateEmitter修饰的内部observer的onNext，这里也就是最内层被修饰的观察者

    1.4 subscribeOn数据发射线程的切换
         Observable stringObservable = Observable.create(new ObservableOnSubscribe() {
            @Override
             public void subcribe(ObservableEmitter e) throws Exception {
                e.onNext(); //反射数据
             }
         })
         .subscribeOn();
        调用到ObservableCreate的subscribeOn方法 -> 也就是Observable的subscribeOn:
            @SchedulerSupport(SchedulerSupport.CUSTOM)
            public final Observable subscribeOn(Scheduler scheduler) {
                ObjectHelper.requireNonNull(scheduler, "scheduler is null");
                return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
            }
        可见直接将上游的Observable(这里暂且把上游Observable作为ObservableCreate来分析)再次进行一次封装修饰，并将ObservableSubscribeOn对象返回。
        来到ObservableSubscribeOn的subscribe订阅过程 -> ObservableSubscribeOn.subscribe ->  ObservableSubscribeOn.subscribeActual:
            @Override
            public void subscribeActual(final Observer s) {
                final SubscribeOnObserver parent = new SubscribeOnObserver(s); //同样也是将对应的观察者进行一次修饰
        
                s.onSubscribe(parent); //这里对修饰的观察者是否解绑校验判断之类的
        
                parent.setDisposable(scheduler.scheduleDirect(new Runnable() {
                    @Override
                    public void run() {
                        source.subscribe(parent); //封装之后的observer订阅上游观察者
                    }
                }));
            }
            
            这里的scheduler以IoScheduler为例分析 scheduler.scheduleDirect:
            public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) {
                    final Worker w = createWorker(); //自己创建自己当前scheduler对应的worker
            
                    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
            
                    w.schedule(new Runnable() { //此时的线程处于IoScheduler创建worker的线程  
                        @Override
                        public void run() {
                            try {
                                decoratedRun.run(); //最终执行调用传入的runnable的run方法 也就是scheduler.scheduleDirect传入的runnable
                            } finally {
                                w.dispose();
                            }
                        }
                    }, delay, unit);
            
                    return w;
                }
         1.5 订阅过程线程切换 为何subscribeOn调用只有第一次有效   
            创建worker -> IoScheduler::createWorker -> IoScheduler:: EventLoopWorker -> EventLoopWorker.schedule
             @Override
             public Worker createWorker() {
                 return new EventLoopWorker(pool.get());
             }
                 static final class EventLoopWorker extends Scheduler.Worker {
                     private final CompositeDisposable tasks;
                     private final CachedWorkerPool pool;
                     private final ThreadWorker threadWorker;
             
                     final AtomicBoolean once = new AtomicBoolean();
             
                     EventLoopWorker(CachedWorkerPool pool) {
                         this.pool = pool;
                         this.tasks = new CompositeDisposable();
                         this.threadWorker = pool.get();
                     }   
                 }
             EventLoopWorker.schedule -> ThreadWorker.schedulerActual -> NewThreadWorker.schedulerActual -> ScheduledExecutorService.submit()
             最后会有ScheduledExecutorService执行1.4中ObservableSubscribeOn的subscribe订阅过程中传入的runnable，
             也就是在SubscribeOn传入的scheduler线程中完成修饰者订阅上游被观察者的过程，所以调用一次subscribeOn改变的是订阅上游被观察者的订阅线程，
             而订阅过程都是由最外层到最内层的，所以不管subscribeOn多少次，上游的发射数据的线程永远都是以最上游的一次subscribeOn的线程为准
             

1.6  数据的发射接收 也就是调用了observeOn
     Observable stringObservable = Observable.create(new ObservableOnSubscribe() {
        @Override
         public void subcribe(ObservableEmitter e) throws Exception {
            e.onNext(); //反射数据
         }
     })
     .subscribeOn() //这一步返回一个ObservableSubscribeOn对象
     .observeOn; //返回 ObservableObserveOn 对象
     开始订阅observeOn 的订阅流程subscribe 直接调用subscribeActual方法:
         @Override
         protected void subscribeActual(Observer observer) {
             if (scheduler instanceof TrampolineScheduler) {
                 source.subscribe(observer);
             } else {
                 Scheduler.Worker w = scheduler.createWorker();

                 source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize)); //ObserveOnObserver实现了runnable接口
             }
         }
     可以看出，订阅流程只是创建了一个对应scheduler的worker,同样将传入的observer进行一次封装并订阅当前Observable的上游Observable(也就是source)，
     与ObservableSubscribeOn的订阅subscribe不同的是 ObservableObserveOn的上游observable的订阅是在当前线程进行的，并没有改变订阅所在的线程。
     而数据的接收是由observer的onNext onError onComplete传递，以onNext为例 -> 直接找到 ObserveOnObserver的onNext :
       public void onNext(T t) {
           if (done) {
               return;
           }

           if (sourceMode != QueueDisposable.ASYNC) {
               queue.offer(t);  //将当前数据放置到queue中
           }
           schedule(); 
       } 
        void schedule() {
            if (getAndIncrement() == 0) {
                worker.schedule(this); //直接调用到传入的worker的schedule //此时的线程依旧没变 
            }
        }           
      worker.schedule(this)方法的的执行流程与1.5.1类似,将runnable传入，通过ScheduledExecutorService将runnnable放入到scheduler指定的线程中执行，
      此时的runnable就是this -> 也就是实现了runnable接口ObserveOnObserver对象，最后执行的是ObserveOnObserver的run方法:
         @Override
         public void run() { //此时的run方法是在scheduler指定的线程中执行的 
             if (outputFused) { //默认是false
                 drainFused();
             } else {
                 drainNormal(); //
             }
         }
         ------>  drainNormal()
         void drainNormal() {
             int missed = 1;
 
             final SimpleQueue q = queue;  
             final Observer a = actual;
 
             for (;;) {
                 if (checkTerminated(done, q.isEmpty(), a)) {
                     return;
                 }
 
                 for (;;) {
                     boolean d = done;
                     T v;
 
                     try {
                         v = q.poll(); //从queue中取出数据
                     } catch (Throwable ex) {
                         Exceptions.throwIfFatal(ex);
                         s.dispose();
                         q.clear();
                         a.onError(ex);
                         return;
                     }
                     boolean empty = v == null;
 
                     if (checkTerminated(d, empty, a)) { //判断消息是都都传递完了
                         return;
                     }
 
                     if (empty) {
                         break;
                     }
 
                     a.onNext(v); //调用上游的observer onNext传递数据
                 }
 
                 missed = addAndGet(-missed);
                 if (missed == 0) {
                     break;
                 }
             }
         }
       
       ObserveOnObserver简单的数据传递流程: 
       ObserveOnObserver.onNext() -> ObserveOnObserver.schedule() -> ObserveOnObserver.run() -> 上游observer(被修饰的observer).onNext()