楼主最近在找实习工作，由于简历上说了解RxJava，所以在面试的时候应该会问到RxJava的知识，于是楼主结合RxJava的源码，对RxJava的工作原理进行初步的了解。也只敢说是初步了解，因为自己也是第一次看RxJava的源码，理解的程度肯定不是很深。还是那样，如果有错误之处，希望各位指正！
本文参考：
1.除非特殊说明，源码来自：2.2.0版本
2.RxJava从源码到应用 移动端开发效率秒提速
1.概述
楼主打算将RxJava的源码分析写成一个系列文章，所以这个是这个系列的第一篇文章，在概述里面还是对RxJava是什么简单的介绍一下，本系列文章不会对RxJava的基本用法进行展开，如果有老哥对RxJava的基本使用掌握的不是很好的话，推荐这个系列的文章：给初学者的RxJava2.0教程(一)。
简单的说一下RxJava，RxJava是基于观察者模式的一个框架，在RxJava中有两个角色，一个Observable，通常被称为被观察者，一个是Observer，通常被称为观察者。总体的架构是，由Observable来处理任务或者发送事件，然后在Observer里面来接受到Observable发送过来的信息。
RxJava有很多的优势，比如线程调度，在Android里面，耗时操作必须放在子线程中，但是同时还需要主线程来更细UI，所以线程调度就显得尤为重要。当然RxJava还有很多重要的操作符，使得我们的开发变得非常的方便。本系列文章不会对每个操作符的基本使用展开，而是对一些比较常用的操作源码分析，所说的常用，也是指楼主用到的！！毕竟是菜鸡，肯定有很多的东西都不太懂。
2.基本元素
想要对RxJava的基本原理有一个更好的了解，必须对它的基本有一个大概的了解。我们先通过一个简单的案例，来对RxJava的基本元素进行提取。
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
在这个简单的案例当中，我们可以提取的元素有:Observable, ObservableOnSubscribe, ObservableEmitter,Observer。
元素还是挺少的，我们现在对每个元素的类结构来进行简单的分析一下。
(1).Observable
public abstract class Observable<T> implements ObservableSource<T> {
}
我们发现Observable本身是一个抽象类，并且实现了ObservableSource接口，在来看看ObservableSource接口里面有什么。
public interface ObservableSource<T> {
void subscribe(@NonNull Observer<? super T> observer);
}
ObservableSource接口里面只有一个subscribe方法,也就是说，RxJava将注册观察者这部分的功能提取成一个接口，从而可以看出来，面向接口编程是多么的重要😂😂。。。
再分别来看看我们上面案例中使用的两个方法--create和subscribe。
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
// 先省略代码部分，待会详细的分析。
}
啊，吓我一跳，我以为create方法的参数又是一个接口类型，还好是ObservableOnSubscribe类型，也是上面提取出来的元素其中之一，关于这个类，待会会详细的分析。
public final void subscribe(Observer<? super T> observer) {
//...
}
这个方法就更加的简单了，就是传递了一个Observer接口的对象。不过需要注意的是这个方法有很多的重载，其中以Consumer类型的操作最为多，不过这个也没什么，最后还是Consumer转换成为了Observer，这个就涉及到Observer接口的一个实现类--LambdaObserver。不要害怕，待会都会一一的讲解的。
(2).Observer
说了被观察者，我们先来看看观察者--Observer。
public interface Observer<T> {
void onSubscribe(@NonNull Disposable d);
void onNext(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
}
哎呀呀，更加的简单了， Observer只是简单的接口，不过我们需要注意的是这个接口定义的4个方法，这里不讲解四个方法的作用，毕竟我们这里将Observable的基本原理🙄🙄。
(3).ObservableOnSubscribe
public interface ObservableOnSubscribe<T> {
void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}
一如既往的接口，subscribe方法里面就是具体做事情的地方，这个相信大佬们应该都知道，我这里就班门弄斧的提醒一下😂😂。
(4).ObservableEmitter
public interface ObservableEmitter<T> extends Emitter<T> {
void setDisposable(@Nullable Disposable d);
void setCancellable(@Nullable Cancellable c);
boolean isDisposed();
ObservableEmitter<T> serialize();
boolean tryOnError(@NonNull Throwable t);
}
ObservableEmitter也是一个接口，同时继承了Emitter接口，我们来看看Emitter接口的定义
public interface Emitter<T> {
void onNext(@NonNull T value);
void onError(@NonNull Throwable error);
void onComplete();
}
作为一个发射器，Emitter里面定义了很多关于发送消息给Observer的方法,Emitter的onNext对应着Observer的onNext方法，其他的方法也是类似的。
3.Observable的工作原理
(1).create方法
我们对相关部分的基本元素有了一个基本的了解，现在我们来对整个流程的工作原理进行分析。首先我们create方法入手
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
create方法没有我们想象中的那么难，就只有两行代码，还有一行用来check的😂😂。对于ObservableCreate类这里先不进行分析，我们来看看 RxJavaPlugins的onAssembly方法。
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
if (f != null) {
return apply(f, source);
}
return source;
}
这里提醒一下，onAssembly方法的参数类型是Observable类型，也就是说ObservableCreate本身就是一个Observable。好了，扯了题外话，来看看onAssembly方法具体是干嘛的。
整个方法的执行过程比较简单，如果onObservableAssembly为null，直接就返回了source,也就是说返回了ObservableCreate本身。而我们在整个Observable的源码中发现，onObservableAssembly初始值本身为null。
public static void reset() {
//······
setOnObservableAssembly(null);
//······
}
为什么需要这样子绕圈子的做呢？这里就是做了钩子，以便于以后的扩展。
所以Observable的create方法就是返回了一个ObservableCreate对象，不过需要注意的是ObservableCreate包裹了一个ObservableOnSubscribe对象，也就是我们在create方法里面new的那个ObservableOnSubscribe对象。
我们先来不急着去理解ObservableCreate是什么，还是来看看subscribe方法为我们做了什么。
(2). subscribe方法
当我们通过Observable的create方法来获取一个Observable对象时，通常还会调用Observable的subscribe方法来注册一个观察者。现在我们来看看subscribe方法的实现。
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, 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;
}
}
整个过程也不是想象中的那么神秘，除去check相关的方法不看，归根结底就是两行代码，先是通过RxJavaPlugins的onSubscribe方法来获取Observer对象，具体操作这里就不说了，肯定跟RxJavaPlugins的onAssembly方法差不多，最后返回的是observer本身，最后调用了subscribeActual方法。这个subscribeActual方法是干嘛的？
protected abstract void subscribeActual(Observer<? super T> observer);
卧了个槽？抽象方法！那我怎么知道调用的是哪个类的subscribeActual方法？不急哈，记得我们之前在create方法返回的Observable对象是哪个类的对象吗？想起来了吧，是ObservableCreate
(3). ObservableCreate
先来看看ObservableCreate类结构。
public final class ObservableCreate<T> extends Observable<T> {
}
我们发现，ObservableCreate继承了Observable,其实在分析create方法时，我也说过哟。
在ObservableCreate类中，只有一个ObservableOnSubscribe类型的成员变量，这个成员变量就是我们在create方法里面new的ObservableOnSubscribe对象
我们再来看看ObservableCreate对subscribeActual方法的实现
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
在subscribeActual方法里面，先是对Observer对象进行一次包装，将它包装在CreateEmitter类中。然后我们会发现两个比较眼熟的方法onSubscribe方法和subscribe方法。其中onSubscribe方法在Observer里面看到过，而这里恰好是通过Observer对象来调用的，没错，这个的observer就是在subscribe方法里面new的对象。可是我们记得onSubscribe方法的参数类型是Disposable,而这里是一个CreateEmitter。我们来看看CreateEmitter的类结构：
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
//······
}
没错，CreateEmitter实现了Disposable接口,所以CreateEmitter本身可以充当Disposable的角色。
调用了Observer的onSubscribe方法之后，然后就会调用ObservableOnSubscribe的subscribe方法。
到这里，我们应该彻底的明白了整个Observable的工作流程。我们通过create方法创建一个ObservableCreate方法，然后调用了subscribe方法来注册了一个观察者，在subscribe方法里面又调用了subscribeActual方法，在subscribeActual方法里面先是调用了Observer的onSubscribe方法，然后调用了
ObservableOnSubscribe的subscribe方法，在ObservableOnSubscribe的subscribe方法当中，具体的做的事有两件：1.做我们自己的事情，比如从服务器上获取数据之类；2.将发送信息到Observer去。
理解了整个流程的工作原理，我们现在来看看CreateEmitter是怎么信息发给Observer的。
4. CreateEmitter的工作原理
我们知道，我们在ObservableOnSubscribe的subscribe方法里面使用ObservableEmitter来发射信息到Observer。现在我们来看看整个CreateEmitter的工作原理，不过，我们还是先来看看这个类的结构，虽然上面已经看了，但是担心大佬们忘了：
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
//······
}
在上面已经说了CreateEmitter实现了Disposable接口，可以作为Disposable对象来操作，在接下来，我们将重点介绍Disposable是怎么控制Observer对信息的接收，同时还会介绍CreateEmitter作为ObservableEmitter接口的那部分功能。
之前在分析基本元素时，已经说了ObservableEmitter这个接口，它实现了Emitter接口。在Emitter接口里面有三个方法用来发送信息给Observer，分别是：onNext，onError，onComplete。而CreateEmitter类则是具体的实现了这三个方法，我们来看看。
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);
}
}
代码是非常的简单，直接调用了Observer的onNext方法，也没用什么高逼格的东西😂😂。其余两个方法也是如此。只不过是，在调用onNext方法时做了一个isDisposed的判断。
所以感觉Disposable才是这个类的核心。我们来看看isDisposed方法:
@Override
public boolean isDisposed() {
return DisposableHelper.isDisposed(get());
}
在isDisposed方法里面调用了DisposableHelper的isDisposed方法。不过这里需要注意的是这里传递过去的是get方法的返回值，这个返回值什么意思？
回到CreateEmitter的类结构，发现它继承了AtomicReference类，所以get方法返回的是一个Disposable对象。
同时，我们发现CreateEmitter的dispose方法也是通过DisposableHelper类进行进行操作的，看看要理解Disposable的功能，必须了解DisposableHelper是怎么操作的。
5.DisposableHelper
从感官上来说，一个发射器是否dispose，直接设置一个boolean类型的flag就OK了，为什么搞得这么复杂，又是AtomicReference，又是DisposableHelper。这一切，我们从DisposableHelper来寻找答案。
首先我们还是来看看DisposableHelper的结构：
public enum DisposableHelper implements Disposable {
DISPOSED
;
}
DisposableHelper本身是一个enum类型，同时实现了Disposable接口。这里使用enum主要是为了做一个DISPOSED的单例。然后在通过isDisposed方法来判断是否dispose，可以直接与DISPOSED比较。
public static boolean isDisposed(Disposable d) {
return d == DISPOSED;
}
既然判断是否dispose是直接与DISPOSED比较，那么如果dispose的话，应该是将AtomicReference里面的值设置为DISPOSED吧？我们来看一下dispose方法：
public static boolean dispose(AtomicReference<Disposable> field) {
Disposable current = field.get();
Disposable d = DISPOSED;
if (current != d) {
current = field.getAndSet(d);
if (current != d) {
if (current != null) {
current.dispose();
}
return true;
}
}
return false;
}
果然，跟我们猜测一样的，AtomicReference里面的值设置为DISPOSED。只是，这里为了线程安全，做了很多的判断操作。
从这里我们可以得到，为什么需要设置DisposableHelper来控制dispose的状态，那是因为线程安全，如果直接设置一个flag，在有些情况下，可能存在线程不安全的风险。同时为了代码的优雅，如果这部分的逻辑写在CreateEmitter里面，会不会显得冗杂呢？
6.总结
写到这里，我感觉也差不多了。这里对着部分的知识做一个总结。
1.在整个流程中，基本有Observable,ObservableOnSubscribe,ObservableEmitter,Observer，如果想要对整个过程有一个大概的理解，必须对这几个元素有基本的认识。
2.Observer的onNext之类方法的触发时机，实际上是Observable的subscribe方法，因为subscribe方法调用了Observable的subscribeActual方法，而在subscribeActual方法里面做了两部分的操作：1.直接调用了Observer的onSubscribe方法；2.使用ObservableEmitter将Observer包裹起来，所以我们在ObservableOnSubscribe的subscribe方法用ObservableEmitter来发射信息，相当于调用了Observer的相关方法。
3.在ObservableEmitter的onNext之类方法里面，存在一种类似AOP的代码，因为在调用Observer的相关方法，做了一些其他的操作。
