学习笔记RxJava

使用

Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) throws Exception {
            e.onNext("hello world");
            e.onComplete();
        }
    }).map(new Function(){
        @Override
        public String apply(String s) throws Throwable {
            return s+"<<<";
        }
    }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {
                    Log.e("onSubscribe","onSubscribe");
                }
                @Override
                public void onNext(@NonNull String s) {
                    Log.e("onNext","onNext:"+s);
                }
                @Override
                public void onError(@NonNull Throwable e) {
                    Log.e("onError","onError");
                }
                @Override
                public void onComplete() {
                    Log.e("onComplete","onComplete" );
                }
            });

发射一个字符串，经过map转化，然后发到观察者onNext输出数据

查看源码

1、Observable.create(..)

  public static  Observable create(@NonNull ObservableOnSubscribe source) {
      Objects.requireNonNull(source, "source is null");
      return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));
  }

接受一个ObservableOnSubscribe参数，返回一个ObservableCreate对象，并把参数传了进去,RxJavaPlugins 装配这个new的对象，返回Observable,但实质是ObservableCreate

RxJavaPlugins是一个hook类，主要就是把你new出来的对象，使用的操作符转换成RxJava具体操作的一个类

2、.map(new Function(){..})

  public final  Observable map(@NonNull Function mapper) {
        Objects.requireNonNull(mapper, "mapper is null");
        return RxJavaPlugins.onAssembly(new ObservableMap<>(this, mapper));
  }

因为create已经返回了一个Observable对象，直接使用该对象的map方法。同样也是装配了一个ObservableMap(this,mapper)
this就是ObservableCreate对象
mapper是需要转换的方法
这时候ObservableCreate和ObservableMap已经连起来了
3、.subscribeOn(Schedulers.io())

  public final Observable subscribeOn(@NonNull Scheduler scheduler) {
    Objects.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<>(this, scheduler));
  }

装配返回一个Observable对象实质是ObservableSubscribeOn(this, scheduler)
this是ObservableMap对象
scheduler是Schedulers.io()线程调度对象，订阅放到了io线程 或者是newThread、single...
这时候 上游的ObservableMap已经和ObservableSubscribeOn连起来了，并且指定了订阅的地方是在io线程
4、.observeOn(AndroidSchedulers.mainThread())

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

装配返回Observable对象，实质是ObservableObserveOn
this传入的是ObservableSubscribeOn
scheduler是Android的主线程
这时候ObservableSubscribeOn和ObservableObserveOn连起来了
5、.subscribe(new Observer(){onSubscribe、onNext...等方法})

public final void subscribe(@NonNull Observer observer) {
    Objects.requireNonNull(observer, "observer is null");
      try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        Objects.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

        subscribeActual(observer);  //关键方法
      } catch (NullPointerException e) {

      } catch (Throwable e) {

      }
}

主要就是subscribeActual(observer);当前对象是ObservableObserveOn，也就是ObservableObserveOn调用了subscribeActual(observer) 并把观察者的对象传了进来，也就是 onSubscribe、onNext...等方法 的对象

到这里创建、订阅、关联已经基本完成

前面的类名比较乱，什么ObservableObserveOn，又是什么ObservableSubscribeOn，还有Observable，后面还有ObserveOnObserver等等 这些我第一次看也比较晕，绕了半天，后来想想还是根据英文意思来看
比如Observable 中文 可观察的 也就是 被观察者
Observe 中文 观察的
ObservableObserveOn 中文 被观察者 观察 在...　　
ObservableSubscribeOn 被观察者 订阅 在...
接下来是关键

订阅

理一下 ObservableCreate -> ObservableMap -> ObservableSubscribeOn -> ObservableObserveOn -> 执行subscribeActual()
在上面的方法中 执行subscribeActual()对象是最后一个ObservableObserveOn

ObservableObserveOn.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));
    }
  }

第一个判断是判断scheduler对象是否是TrampolineScheduler，这个类里面注释说 在当前线程上工作，内容放入队列，但不会立即执行，暂时忽略
下面创建了一个 Worker ，new了一个对象ObserveOnObserver，这个静态类，继承了Observer(Observer是为了下游对象)和Runnable()(run方法中有个判断默认是false，暂时不知道第一个方法是做什么的暂时忽略，网上说与backpressure有关 不是背后的压力，是后面的压力)。
ObserveOnObserver这个类里面有upstream，有queue，有worker，是用来最后执行，你定义的Observer里面的方法
source订阅了ObserveOnObserver，这个source对象是ObservableSubscribeOn，执行了他的subscribeActual()

ObservableSubscribeOn.subscribeActual()

@Override
public void subscribeActual(final Observer observer) {
      final SubscribeOnObserver parent = new SubscribeOnObserver<>(observer);
      observer.onSubscribe(parent);
      parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}

这个类是  被观察者订阅在   定义的是io线程
首先new了一个对象SubscribeOnObserver 传入了 observer 这个是具体实现最后发射的对象
接着就调用了observer的onSubscribe(parent)方法

  @Override
  public void onSubscribe(Disposable d) {
      if (DisposableHelper.validate(this.upstream, d)) {
          this.upstream = d;
          if (d instanceof QueueDisposable) {
              //去掉其他代码
          }

          queue = new SpscLinkedArrayQueue<>(bufferSize);
          downstream.onSubscribe(this);
      }
  }

这里做一个保留，第二个if判断if (d instanceof QueueDisposable) 判断是否是 一次性队列
接着创建了一个SpscLinkedArrayQueue这个类里面有一个 AtomicReferenceArray 原子的引用集合，保证发射出去的数据是原子操作不可被打断。
最后调用了下游的方法，回调到了我们定义的onSubscribe方法中打印log
回到前面 最后一行

parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));

分部来看
开始new了一个SubscribeTask这一个线程，并把parent传了进去，这个parent可以理解为当前实际操作对象 握着 下游 实例的对象
既然是个线程肯定有run方法

@Override
public void run() {
  source.subscribe(parent);
}

这个source对象 实际是前一个结点的对象也就是map 也就是ObservableMap，这里只定义了还没使用
接着上面的Task交给了scheduler.scheduleDirect

  @NonNull
  public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    final Worker w = createWorker();

    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

    DisposeTask task = new DisposeTask(decoratedRun, w);

    w.schedule(task, delay, unit);

    return task;
  }

createWorker()是IoScheduler中初始化的也就是指定 被观察者 在那个线程执行操作Schedulers.io()

public Worker createWorker() {
  return new EventLoopWorker(pool.get()); //这里的get是返回pool的对象
}

//EventLoopWorker的构造函数
EventLoopWorker(CachedWorkerPool pool) {
  this.pool = pool;
  this.tasks = new CompositeDisposable();
  this.threadWorker = pool.get();   //这里的get是返回pool里一个ThreadWorker对象
}

final AtomicReference pool;

static final class CachedWorkerPool implements Runnable {
   private final ConcurrentLinkedQueue expiringWorkerQueue;
}

这里有 一个pool.get()对象，这是个原子性的缓存工作池
CachedWorkerPool是个static的线程类,里面有个队列的数据结构，pool.get();是返回一个ThreadWorker对象，循环找，找到就返回，找不到就new一个然后添加到pool里再返回，这个类也会定期清理里面的worker

回到scheduleDirect()，第三行 new DisposeTask 一次性的任务 并传入 线程 和 “工作者”对象 。DisposeTask也是一个线程里面的run方法，执行了传入的线程。
w.schedule(task, delay, unit);在IoScheduler中实现

@NonNull
@Override
public Disposable schedule(@NonNull Runnable action, long delayTime,@NonNull TimeUnit unit) {
  if (tasks.isDisposed()) {
    // don't schedule, we are unsubscribed
    return EmptyDisposable.INSTANCE;
  }

  return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}

ThreadWorker继承NewThreadWorker 打开scheduleActual()

  @NonNull
  public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent)      {
      Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

      ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

      if (parent != null) {
          if (!parent.add(sr)) {
              return sr;
            }
          }

          Future f;
          try {
            if (delayTime <= 0) {
              f = executor.submit((Callable