版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/fengluoye2012/article/details/79149201
简介
RxJava一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库；扩展了观察者模式以支持数据/事件的序列，并添加操作符，允许您以声明的方式组合序列，同时抽象出对诸如低层次线程、同步、线程安全和conc等问题的关注。
相关的入门的介绍有很多，可参考https://www.jianshu.com/p/15b2f3d7141a系列的文章介绍的非常全面；这篇文章的主要介绍相关的Observable发送流程，Observer接收流程，并且结合创建操作符ObservableCreate类（位于io.reactivex.internal.operators.observable包），发送事件和接收事件逻辑，给出源码分析；
用法
先了解下最基本的用法：
1）创建一个Observable，调用Observable.create();ObservableEmitter是事件的发送器，可以发送多个onNext()方法；一旦发送onComplete（），onError（）事件之后，后续的事件将不会再发送；
2）创建一个Observer；里面有四个方法：onSubscribe()，onNext()，onError()，onComplete()；
3）stringObservable.subscribe(observer);
Observable<String> stringObservable = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
Log.e(tag, "发送线程：" + Thread.currentThread().getName());
Log.e(tag, "发送：：" + "hello");
emitter.onNext("hello");
Log.e(tag, "发送：：" + "world");
emitter.onNext("world");
Log.e(tag, "发送：：" + "Hello World");
emitter.onNext("Hello World");
Log.e(tag, "发送：：" + "onComplete");
emitter.onComplete();
}
});
Observer<String> observer = new Observer<String>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.e(tag, "onSubscribe");
//销毁资源，后续的方法不在执行；
//d.dispose();
}
@Override
public void onNext(@NonNull String s) {
Log.e(tag, "接收线程：" + Thread.currentThread().getName());
Log.e(tag, "接收：" + s);
}
@Override
public void onError(@NonNull Throwable e) {
Log.e(tag, "onError");
}
@Override
public void onComplete() {
Log.e(tag, "onComplete");
}
};
stringObservable.subscribe(observer);
运行结果
从运行结果发现：stringObservable.subscribe(observer)之后，
1）observer（观察者）最先调用onSubscribe()，参数Disposable相当于阀门，可以调用d.dispose()销毁资源，后续的方法不在执行；
2）然后emitter发送事件，每发送一个事件之后，observer就接收到一个事件，在没有速差存在的情况下，发送和接收是一一对应的；且都运行在主线程；
3）一旦调用onComplete()或者onError()之后，后续的方法将不再执行，onComplete()和onError()相互互斥，只有一个方法会执行；
执行流程
详细解析下以上的执行流程：以rxjava-2.1.8源码来分析的；
Observable：Observable是ObservableSource的实现类，Observable调用create（），ObservableOnSubscribe是一个接口，
Observable<String> stringObservable = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("hello");
emitter.onNext("world");
emitter.onNext("Hello World");
emitter.onComplete();
}
});
create()方法
@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));//调用hook关联方法；
}
先进行非空判断，否则抛出NullPointerException异常，
ObservableOnSubscribe是一个接口，定义了subscribe()方法，用来接收ObservableEmitter的实例，以安全，可取消的方式发送事件；
public interface ObservableOnSubscribe<T> {
void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}
ObservableEmitter是Emitter（发射器）的子类；ObservableEmitter有序的发送onNext()，onError()，onComplete()方法；通过serialize()方法确保按照你想要的顺序发送；
Emitter的源码
public interface Emitter<T> {
void onNext(@NonNull T value);
void onError(@NonNull Throwable error);
void onComplete();
}
Observer是一个接口，为接收基于推的通知提供了一种机制，在observable.subscribe(observer)之后，最先调用onSubscribe()，
然后是数量不等的onNext()，最后仅调用一次onComplete() 或者onError()，这两个相互冲突，只有一个执行；在onSubscribe可以销毁资源，调用d.dispose();调用之后，后面的方法不再执行；
public interface Observer<T> {
void onSubscribe(@NonNull Disposable d);
void onNext(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
}
subscribe（）中的subscribeActual(observer)在Observable是抽象方法，实际的订阅方法；操作符应该实现执行必要业务逻辑的方法，我们看下
ObservableCreate类
@SchedulerSupport(SchedulerSupport.NONE)
@Override
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;
}
}
ObservableCreate是Observable的子类，重写了subscribeActual()方法，
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
//CreateEmitter是静态匿名内部类，实现了ObservableEmitter和Disposable接口；
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
//observer调用onSubscribe（），可以销毁资源
observer.onSubscribe(parent);
try {
//执行subscribe（）方法
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
CreateEmitter内有一个serialize()方法，确保按照你想要的顺序发送事件，返回了一个SerializedEmitter实例；
@Override
public ObservableEmitter<T> serialize() {
return new SerializedEmitter<T>(this);
SerializedEmitter类连续的调用onNext, onError and onComplete，发送事件；在发送事件之前都会判断emitter是否销毁资源或者是否已经调用了onError或者onComplete；如果已经调用，就不在发送事件；
以下是SerializedEmitter发送事件的逻辑判断：
volatile boolean done;
SerializedEmitter(ObservableEmitter<T> emitter) {//构造函数
this.emitter = emitter;
this.error = new AtomicThrowable();
this.queue = new SpscLinkedArrayQueue<T>(16);//事件缓存数量为16；
}
SerializedEmitter的onNext()
@Override
public void onNext(T t) {
if (emitter.isDisposed() || done) {//销毁资源或者done=true(已经执行了onComplete或者)
return;
}
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
// 调用Native方法compareAndSet，执行CAS操作
if (get() == 0 && compareAndSet(0, 1)) {
emitter.onNext(t);//发送onNext()方法
if (decrementAndGet() == 0) {
return;
}
} else {
SimpleQueue<T> q = queue;
synchronized (q) {
q.offer(t);//offer添加一个元素并返回true如果队列已满，则返回false
}
if (getAndIncrement() != 0) {
return;
}
}
drainLoop();
}
drainLoop()方法,内部双层无限循环，
void drainLoop() {
ObservableEmitter<T> e = emitter;
SpscLinkedArrayQueue<T> q = queue;
AtomicThrowable error = this.error;
int missed = 1;
for (;;) {
for (;;) {
if (e.isDisposed()) {//如果已经销毁资源，清空队列，退出循环
q.clear();
return;
}
if (error.get() != null) {//error不为null,队列清空，调用onError（）方法，退出循环
q.clear();
e.onError(error.terminate());
return;
}
boolean d = done;
T v = q.poll();//poll 移除并返回队列头部的元素 如果队列为空，则返回null
boolean empty = v == null;
if (d && empty) {//如果done= true;并且当前事件为nul，调用onComplete（）方法，退出循环
e.onComplete();
return;
}
if (empty) {//当前事件为null;
break;
}
e.onNext(v);//调用onNext（）
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
onError根据tryOnError的返回值
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(Throwable t) {
if (emitter.isDisposed() || done) {//如果已经销毁子资源或者done= true;
return false;
}
if (t == null) {
t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
if (error.addThrowable(t)) {//抛出异常
done = true;
drain();//drain()内部调用drainLoop（）方法
return true;
}
return false;
}
onComplete
@Override
public void onComplete() {
if (emitter.isDisposed() || done) {//资源销毁或者done= true
return;
}
done = true;
drain();
}
SerializedEmitter内的逻辑比较复杂，可自行研究；以上只是个人的粗浅解析；
回到CreateEmitter中，对应的onNext, onError and onComplete，事件发送之后的回调，在调用observer的onNext, onError and onComplete之后，都会先判断isDisposed()，资源是否已经销毁，在没有销毁的前提下，再执行；
onNext：
@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（）方法；
observer.onNext(t);
}
}
onError：一旦执行之后，就会调用dispose()，销毁资源；
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(Throwable t) {
if (t == null) {
t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
if (!isDisposed()) {//资源没有销毁的情况下
try {
observer.onError(t);//observer调用 onError（）方法
} finally {
dispose();//在onError（）方法调用之后，销毁资源，后续的事件将不会再发送；
}
return true;
}
return false;
}
onComplete：一旦执行之后，就会调用dispose()，销毁资源；
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
以上就是Observable发送流程，Observer接收流程的全部过程和部分细节的分析；如有问题，请多指教！