RxJava 源码分析
个人理解，仅供参考！
例子：
Observable observable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
emitter.onNext("1");
emitter.onComplete();
}
});
Observable observable2 = observable.map(new Function() {
@Override
public Integer apply(String s) throws Throwable {
return Integer.parseInt(s);
}
});
Observable observable3 = observable2.subscribeOn(Schedulers.io());
Observable observable4 = observable3.observeOn(AndroidSchedulers.mainThread());
observable4.subscribe(new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onNext(Integer o) {
Log.i("tag","onNext :"+o);
}
@Override
public void onError(@NonNull Throwable e) {
}
@Override
public void onComplete() {
}
}); 源码：
@CheckReturnValue
@NonNull
@SchedulerSupport(SchedulerSupport.NONE)
public static Observable create(@NonNull ObservableOnSubscribe source) {
Objects.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));
} RxJavaPlugins.onAssembly 是hook方法，先不用管，直接看new ObservableCreate<>(source)
ObservableCreate extends Observable
说明ObservableCreate是Observable的子类，Observable是抽象类，实现了ObservableSource接口，该接口的方法是 void subscribe(@NonNull Observer observer);
Observable 实现了subscribe方法，在此方法中调用了subscribeActual(observer);
subscribeActual是抽象类，由具体的子类去实现ObservableCreate对象创建完成之后就返回Observable查看RxJavaPlugins.onAssembly源码可知，传进去的source,再返回回来；
RxJava 中的操作符都是在Observable类中实现的，因此可以继续调用操作符方法，这与Builder模式有点类似，但返回的Observable并不是原来的那个；
例如上面的例子返回observable之后继续调用map方法,如下：
Observable observable2 = observable.map(new Function() {
@Override
public Integer apply(String s) throws Throwable {
return Integer.parseInt(s);
}
}); 查看map源码：
public final Observable map(@NonNull Function mapper) {
Objects.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<>(this, mapper));
} 直接看new ObservableMap<>(this, mapper) ，又实例化了一个ObservableMap对象，看其构造方法：
public ObservableMap(ObservableSource source, Function function) {
super(source);
this.function = function;
} mapper是我们例子中传进来的new Function
this是指observable.map 中的observable，这样的话ObservableMap对象就持有了observable实例，这个是在create中创建出来的，在RxJava中成为上游（Upstream），ObservableMap 也是Observable的子类，然后返回一个Observable，这个返回的Observable 是new出来的，说明不与Create方法返回的不一致；
切换线程操作符 subscribeOn 和 observeOn
例如：
Observable observable3 = observable2.subscribeOn(Schedulers.io());
Observable observable4 = observable3.observeOn(AndroidSchedulers.mainThread());先分析subscribeOn，
You can instruct an Observable to do its work on a particular Scheduler by calling the Observable’s SubscribeOn operator.
翻译：
通过调用Observable的SubscribeOn操作符，可以指示Observable在特定的调度程序上执行其工作。
执行什么样的工作呢?看源码：
public final Observable subscribeOn(@NonNull Scheduler scheduler) {
Objects.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<>(this, scheduler));
} 直接看new ObservableSubscribeOn<>(this, scheduler)，scheduler是我们传进来的参数Schedulers.io()，
追踪源码发现 IO = RxJavaPlugins.initIoScheduler(new IOTask());
最后发现就是一个线程池，仅贴出部分代码：
public ScheduledThreadPoolExecutor(int corePoolSize,
ThreadFactory threadFactory) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue(), threadFactory);
}那我们回到这句代码new ObservableSubscribeOn<>(this, scheduler)
this,指调用该方法的对象也就是例子中的observable2；
ObservableSubscribeOn构造方法：
public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
} ObservableSubscribeOn 也是Observable的实现类，Observable是抽象类，那ObservableSubscribeOn就是具体实现类；
现在我们回到ObservableSubscribeOn 初始化完成之后返回；
在我们的例子中又调用了observeOn操作符：
Observable observable4 = observable3.observeOn(AndroidSchedulers.mainThread());看下源码：
public final Observable observeOn(@NonNull Scheduler scheduler) {
return observeOn(scheduler, false, bufferSize());
} scheduler是AndroidSchedulers.mainThread()
private static final class MainHolder {
static final Scheduler DEFAULT
= new HandlerScheduler(new Handler(Looper.getMainLooper()), true);
}接着看observeOn:
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));
} 还是看new ObservableObserveOn<>(this, scheduler, delayError, bufferSize)，this指例子中的observable3，scheduler是AndroidSchedulers.mainThread()，
public ObservableObserveOn(ObservableSource source, Scheduler scheduler, boolean delayError, int bufferSize) {
super(source);
this.scheduler = scheduler;
this.delayError = delayError;
this.bufferSize = bufferSize;
} 保持了observable3的引用，
初始化完成之后返回；
创建完Observable之后会调用subscribe方法进行订阅，参数是观察者Observer,例子如下：
observable4.subscribe(new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onNext(Integer o) {
Log.i("tag","onNext :"+o);
}
@Override
public void onError(@NonNull Throwable e) {
}
@Override
public void onComplete() {
}
}); 看observable4的subscribe方法，observable4 是observeOn操作符返回的对象，也就是ObservableObserveOn类型的，看其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));
}
}Scheduler.Worker w = scheduler.createWorker(); 是创建一个工作线程，接着看后面一句：source是谁？在本例子中source是实例化ObservableObserveOn时传进来的，也就是observable4，在它之前的称之为上游，后面的称之为下游；
subscribe()参数是ObserveOnObserver的实例，ObserveOnObserver实例持有observer的引用；持有我们自定义的观察者的另一个观察者；
observable3是谁？是observable2调用subscribeOn生成的实例，也就是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)));
}
new SubscribeOnObserver对象，构造函数：
SubscribeOnObserver(Observer downstream) {
this.downstream = downstream;
this.upstream = new AtomicReference<>();
}downstream 是它下游的observer,也就是ObserveOnObserver
接着分析observer.onSubscribe(parent);把SubscribeOnObserver传进ObserveOnObserver的onSubscribe方法中，此方法就不分析了，也是向上回调；
看后面：parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
void setDisposable(Disposable d) {
DisposableHelper.setOnce(this, d);
}说明scheduler.scheduleDirect(new SubscribeTask(parent)) 是Disposable类型的对象，看如何实现的：
public Disposable scheduleDirect(@NonNull Runnable run) {
return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
}说明new SubscribeTask(parent) 是一个Runnable,源码如下：
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver parent;
SubscribeTask(SubscribeOnObserver parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}
} SubscribeTask是在ObservableSubscribeOn 类中的一个自定义Runnable,那么run方法中的source对象就是ObservableSubscribeOn的source，它就是构造函数中传进来的
public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
现在继续分析scheduleDirect方法，参数已经知道了，是一个Runnable,
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 是Scheduler中的抽象方法，我们要去看它具体的实现，它具体的实现方法在Scheduler.io()创建出来的实例中，
其实就是IoScheduler,它里面的createWorker方法：
public Worker createWorker() {
return new EventLoopWorker(pool.get());
}其实就是创建一个线程池；然后用runnable和worker组装成一个DisposeTask，然后调用worker的schedule方法执行，怎么执行的就要看Worker的实现类了，就是Scheduler.io()产生的对象，实现如下：
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 就是线程池中的一个线程，就是在线程池中执行Task,这里的Task不是上面方法中的tasks,是action，tasks是
DisposableContainer,是把Task放进DisposableContainer中，应该是起到监控的作用，具体没分析；这个Task就是上面提到的new SubscribeTask(parent)；SubscribeOn操作符就是把传进来的Observer放到指定的线程池中去执行;这个执行的任务是什么样的任务？就是
source.subscribe(parent);
source就是构造ObservableSubscribeOn对象时传进来的source，也就是上游的observable,parent就是observer;
现在又回到上游的observable的subscribeActual方法，本例中是ObservableMap对象的subscribeActual（），也就是observable2，@Override
public void subscribeActual(Observer t) {
source.subscribe(new MapObserver(t, function));
} source是create操作符中生成的Observable,new MapObserver
然后看create操作符中生成的Observable对象中的subscribeActual方法：
ObservableCreate类实现了subscribeActual方法如下：
@Override
protected void subscribeActual(Observer observer) {
CreateEmitter parent = new CreateEmitter<>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
} 在此方法内部创建了一个CreateEmitter实例，observer是下游observer传进来的参数，然后调用
observer.onSubscribe(parent);
source.subscribe(parent);
source是什么？在ObservableCreate类里面定义如下：
final ObservableOnSubscribe source;
public ObservableCreate(ObservableOnSubscribe source) {
this.source = source;
} source是在ObservableCreate构造函数中赋值的，也就是说实例化ObservableCreate时传进来的ObservableOnSubscribe类型的变量，回到例子中的Observable.create方法的参数：
new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
emitter.onNext("1");
emitter.onComplete();
}
} 调用source.subscribe(parent); 也就是调用上面的subscribe方法;该方法中调用emitter.onNext("1");
看下其实现：
@Override
public void onNext(T t) {
if (t == null) {
onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
return;
}
if (!isDisposed()) {
observer.onNext(t);
}
}调用observer.onNext(t);observer是下游的observer,在我们的例子中是MapObserver,看下MapObserver的onNext实现：public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
U v;
try {
v = Objects.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
downstream.onNext(v);
}对数据t调用mapper.apply(t)，mapper就是传进来的function,变换后的数据当作参数，调用下游的onNext,在我们例子中下游是SubscribeOnObserver，它的onNext方法仅仅是调用downstream.onNext(t)，在我们的例子中它的下游是ObserveOnObserver
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);
}
schedule();
}void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this);
}
}看到没有，observerOn 与SubscribeOn的区别是：observerOn在onNext中执行线程池，SubscribeOn是在subscribeActual()中执行线程池，subscribeActual的执行顺序是从下向上，onNext是从上到下执行，由于产生数据在最上面，所以subscribeOn只有第一个有效；