简介：
这篇文章不会介绍Rxjava2的使用和操作符等内容，相信大家也或多或少有所了解，网上也有很多此类的文章，如果从未使用过的Rxjava或对其不怎么了解的，可以先简单的了解下Rxjava2的基本使用。
本篇文章主要是跟着源码分析和梳理Rxjava的构建、订阅、事件分发、线程切换等流程。
Observable的构建：
根据Rxjava的官方介绍上我们可以知道，Observable是Rxjava的5大基类之一，也是我们最常用的的被观察者，一切的一切都要从Observable的构建开始说起。
首先我们大致的看一下Observable这个类的源码。可以知道它是一个抽象类并且实现了ObservableSource接口。
/**
* Observable是一个抽象方法，它实现了一个ObservableSource接口
*/
public abstract class Observable<T> implements ObservableSource<T> {
......
}
/**
* ObservableSource接口只有一个抽象方法subscribe
*/
public interface ObservableSource<T> {
/**
* Subscribes the given Observer to this ObservableSource instance.
* @param observer the Observer, not null
* @throws NullPointerException if {@code observer} is null
*/
void subscribe(@NonNull Observer<? super T> observer);
}这个ObservableSource接口，它其实只有一个需要实现的方法subscribe。很熟悉对吧，没错，就是Rxjava中关键的关键--订阅方法。那么我们来看下Observable抽象类中是如何实现subscribe方法的。
@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;
}
}
protected abstract void subscribeActual(Observer<? super T> observer);这里的“observer = RxJavaPlugins.onSubscribe(this, observer);“这句我们先忽略，因为onSubscribe方法的描述中说是一个hook方法，所以Observable中subscribe方法中只有一句重点，那就是“subscribeActual(observer);”。看最后一行我们知道在Observable类中并没有被实现，而是作为一个抽象方法交给了它的子类去实现具体的逻辑。
这里我们推断一下，因为Observable这个类是一个抽象类，并不能创建observable实体，因此可想而知通过create、map、concat等操作符获取的被观察者一定是Observable的子类。是不是找一个看下代码就知道了。
/**
* Observable类中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));
}create操作符最终生成了一个ObservableCreate类。该类继承了Observable并实现了subscribeActual方法。
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@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);
}
}
......
}我们再来看一个map操作符。
/**
* Observable中的map方法
*/
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}该方法最终会生成一个ObservableMap类。该类继承了AbstractObservableWithUpstream类，而AbstractObservable-WithUpstream类又是Observable的子类，因此ObservableMap类也实现了subscribeActual方法。
public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;
public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
@Override
public void subscribeActual(final Observer<? super T> s) {
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
s.onSubscribe(parent);
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
......
}因此我们推断出在Rxjava的链式调用中，直到调用订阅方法subscribe为止，前面的每一个节点都会生成一个新的继承了Observable的拥有具体功能的子类。
其实这种形式类似于设计模式中的建造者（builder）模式，都是讲复杂的构造过程封装起来，通过简单的链式调用完成对象的创建，只不过建造者模式中返回的是它本身，而Observable的构造过程在每一个节点都会创造出新的拥有具体功能的Observable。
subscribe订阅过程：
前面Observable创建过程中我们提到了subscribe订阅方法最终其实就是在最后一个节点的subscribeActual方法中被实现。这里我们以这样一段Rxjava代码为例来说明。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function<Integer, String>() {
@Override
public String apply(@NonNull Integer integer) throws Exception {
return "This is result " + integer;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
tvShow.append("accept : "+s+"\n");
Log.e(TAG, "accept : "+s+"\n");
}
});那么这段代码subscribe最终应该是执行ObservableMap类（这个类怎么来的，前面创建过程有提到）中的subscribeActual方法。
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
......
}可以看到subscribeActual方法中只有一句代码“source.subscribe(new MapObserver<T, U>(t, function));”。不难理解，这里的t既是我们最终new出来的Observer（例子中可以理解为以匿名内部类出现的特殊的Observer）。那么这里的source又是什么呢，看构造函数可知，source应该是在构造的时候传递过来的，我们找到ObservableMap创建时的代码，也就是在Observable的map方法中。
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}是的，通过源码我们能够知道source其实就是上一个节点的引用，我们这里例子中的上一个节点就是create操作符所创建的ObservableCreate对象。也就是最初的节点，我们看下这个类的大致的代码。
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@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方法，在这个方法中首先创建了一个CreateEmitter实例，它是一个内部类，用来过滤和分发事件（这个后面再讲），我们着重关注"source.subscribe(parent);"，不难看出，这里的source是构造函数的传参，也就是我们例子中的下面这个部分。
new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}至此整个订阅过程就结束了。
因此我们可以总结出：
- Rxjava的订阅过程是一个反向的过程，由最后的节点先调用subscribeActual完成订阅，再从后往前层层调用subscribe方法，也就是层层调用自身的subscrubeActual方法完成订阅。
- 在每一个节点的subscrubeActual中都会创建一个Observer使之与该Observable一一对应，该Observer持有下一级Observer的引用。
事件的传递过程：
还是以刚刚的例子来说明，前面订阅过程的最后的source,也就是前面代码贴出来的部分，它是一个ObservableOnSubscribe，看这个内部类中唯一需要实现的方法subscribe，它就是事件的源头，所有的事件都是从这里开始的。注意它的传参ObservableEmitter，它是一个接口。
public interface ObservableEmitter<T> extends Emitter<T> {
/**
* Sets a Disposable on this emitter; any previous Disposable
* or Cancellation will be unsubscribed/cancelled.
* @param d the disposable, null is allowed
*/
void setDisposable(@Nullable Disposable d);
/**
* Sets a Cancellable on this emitter; any previous Disposable
* or Cancellation will be unsubscribed/cancelled.
* @param c the cancellable resource, null is allowed
*/
void setCancellable(@Nullable Cancellable c);
/**
* Returns true if the downstream disposed the sequence.
* @return true if the downstream disposed the sequence
*/
boolean isDisposed();
/**
* Ensures that calls to onNext, onError and onComplete are properly serialized.
* @return the serialized ObservableEmitter
*/
@NonNull
ObservableEmitter<T> serialize();
}
==================================================================================================================================================
public interface Emitter<T> {
/**
* Signal a normal value.
* @param value the value to signal, not null
*/
void onNext(@NonNull T value);
/**
* Signal a Throwable exception.
* @param error the Throwable to signal, not null
*/
void onError(@NonNull Throwable error);
/**
* Signal a completion.
*/
void onComplete();
}
这个接口很简单，就是一些我们Rxjava中常用的方法，那么它到底在哪里被实现了呢？细心的你一定不难发现，在初始节点ObservableCreate的subscribeActual方法中曾创建了一个内部类的对象CreateEmitter。对，就是它实现了ObservableEmitter接口。
static final class CreateEmitter<T> extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@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);
}
}
@Override
public void onError(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);
} finally {
dispose();
}
} else {
RxJavaPlugins.onError(t);
}
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
@Override
public void setDisposable(Disposable d) {
DisposableHelper.set(this, d);
}
@Override
public void setCancellable(Cancellable c) {
setDisposable(new CancellableDisposable(c));
}
@Override
public ObservableEmitter<T> serialize() {
return new SerializedEmitter<T>(this);
}
@Override
public void dispose() {
DisposableHelper.dispose(this);
}
@Override
public boolean isDisposed() {
return DisposableHelper.isDisposed(get());
}
}可以看到，当调用onNext()方法时首先会判断isDisposed（是否被弃置，Rxjava2中常用的开关）。然后在调用当前持有的Observer的onNext()方法。之前我们说过上一级节点Observer会持有下一级节点的Observer引用，所以这里的Observer指的是下级Observer（例子中就是MapObserver）。
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
final Function<? super T, ? extends U> mapper;
MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
actual.onNext(null);
return;
}
U v;
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
actual.onNext(v);
}
......
}
}这里的onNext首先判断事件是否已经结束了（调用了onError或onComplete后done为true）。然后继续调用actual.onNext()方法。这里我们注意下mapper.apply(t)方法，它其实就是MapObserver用来处理数据的，说白了就是map操作符先处理完数据再传递给下级继续处理。
actual是父类的属性。当还存在下一级节点时，则是下一级的Observer引用。当已经是最下级的节点时，则为我们new出来的Observer，也就是事件最终被处理的地方。
new Observer<Integer>() {
private int i;
private Disposable mDisposable;
@Override
public void onSubscribe(@NonNull Disposable d) {
tvShow.append("onSubscribe "+d.isDisposed()+"\n");
Log.e(TAG, "onSubscribe "+d.isDisposed()+"\n");
mDisposable = d;
}
@Override
public void onNext(@NonNull Integer integer) {
tvShow.append("onNext: value : "+integer+"\n");
Log.e(TAG, "onNext: value : "+integer+"\n");
i++;
if (i == 2) {
// 在RxJava 2.x 中，新增的Disposable可以做到切断的操作，让Observer观察者不再接收上游事件
//mDisposable.dispose();
tvShow.append("onNext : isDisposable : " + mDisposable.isDisposed() + "\n");
Log.e(TAG, "onNext : isDisposable : " + mDisposable.isDisposed() + "\n");
}
}
@Override
public void onError(@NonNull Throwable e) {
tvShow.append("onError : value : " + e.getMessage() + "\n");
Log.e(TAG, "onError : value : " + e.getMessage() + "\n" );
}
@Override
public void onComplete() {
tvShow.append("onComplete" + "\n");
Log.e(TAG, "onComplete" + "\n" );
}
});最终事件在自定义的Observer中被我们的逻辑处理和消费。
线程调度原理：
SubscribeOn
SubscribeOn作为操作符之一，和大多数操作符一样都会生成一个新的节点。话不多说，直接看源码。
public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;
public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
@Override
public void subscribeActual(final Observer<? super T> s) {
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
s.onSubscribe(parent);
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
private static final long serialVersionUID = 8094547886072529208L;
final Observer<? super T> actual;
final AtomicReference<Disposable> s;
SubscribeOnObserver(Observer<? super T> actual) {
this.actual = actual;
this.s = new AtomicReference<Disposable>();
}
@Override
public void onSubscribe(Disposable s) {
DisposableHelper.setOnce(this.s, s);
}
@Override
public void onNext(T t) {
actual.onNext(t);
}
@Override
public void onError(Throwable t) {
actual.onError(t);
}
@Override
public void onComplete() {
actual.onComplete();
}
@Override
public void dispose() {
DisposableHelper.dispose(s);
DisposableHelper.dispose(this);
}
@Override
public boolean isDisposed() {
return DisposableHelper.isDisposed(get());
}
void setDisposable(Disposable d) {
DisposableHelper.setOnce(this, d);
}
}
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver<T> parent;
SubscribeTask(SubscribeOnObserver<T> parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}
}
我们会发现subscribeActual内容和其他的节点有所不同，首先它采用了观察者中的onSubscribe方法。然后调用一次性方法设置线程调度目标。这里重点看下scheduler.scheduleDirect方法。
@NonNull
public Disposable scheduleDirect(@NonNull Runnable run) {
return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
}
@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;
}很好理解，创建一个Worker、封装一个Runable，再将Worker和Runnable封装成一个DisposeTask,最后用worker去执行这个task。我们来看下这个Worker到底是个啥。
@NonNull
public abstract Worker createWorker();我们发现createWorker()方法是Scheduler的一个抽象方法，因此我们必须在Scheduler的子类中去查看具体实现。那子类又有哪些呢？
static final class SingleHolder {
static final Scheduler DEFAULT = new SingleScheduler();
}
static final class ComputationHolder {
static final Scheduler DEFAULT = new ComputationScheduler();
}
static final class IoHolder {
static final Scheduler DEFAULT = new IoScheduler();
}
static final class NewThreadHolder {
static final Scheduler DEFAULT = new NewThreadScheduler();
}随便找一个IoScheduler，看看createWorker的实现。
@NonNull
@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();
}
......
@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);
}
}可以看到IoScheduler最终创建了一个EventLoopWorker,而它最终执行的schedule方法返回了“threadWorker.scheduleActual(action, delayTime, unit, tasks);“，我们继续往下看。
@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<Object>)sr);
} else {
f = executor.schedule((Callable<Object>)sr, delayTime, unit);
}
sr.setFuture(f);
} catch (RejectedExecutionException ex) {
if (parent != null) {
parent.remove(sr);
}
RxJavaPlugins.onError(ex);
}
return sr;
}这里的executor就是一个ExecutorService，这里的submit方法，就是将callable丢到线程池中去执行任务了。那么这个任务是什么呢？还记得最开始的scheduler.scheduleDirect(new SubscribeTask(parent)))嘛。这个任务就是SubscribeTask了。
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver<T> parent;
SubscribeTask(SubscribeOnObserver<T> parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}run方法中代码相信都很熟悉了，因此我们可以总结出：SubscribeOn节点在订阅的时候，将它的上游节点的订阅行为，以runnable的形式扔给了一个线程池，也就是说，当订阅流流到SubscribeOn节点时，线程发生了切换，之后流向的节点都在切换后的线程中执行。
observeOn
话不多说，同样是上代码。
@Override
protected void subscribeActual(Observer<? super T> observer) {
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
Scheduler.Worker w = scheduler.createWorker();
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}首先创建一个Worker，然后在订阅的过程中创建ObserveOnObserver并将Worker作为参数传递给它，我们继续看下这个内部类。
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
......
@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);
}
}
......
}明白了吧，其实ObserveOnObserver就是在事件传递的时候调用schedule()方法，进行了线程切换。我们看到schedule方法就是调用worker.schedule方法。我们前面分析了worker.schedule的参数是一个Runable，这里是this，因此我们找到该类run()方法。
@Override
public void run() {
if (outputFused) {
drainFused();
} else {
drainNormal();
}
}
void drainNormal() {
int missed = 1;
final SimpleQueue<T> q = queue;
final Observer<? super T> a = actual;
for (;;) {
if (checkTerminated(done, q.isEmpty(), a)) {
return;
}
for (;;) {
boolean d = done;
T v;
try {
v = q.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
s.dispose();
q.clear();
a.onError(ex);
worker.dispose();
return;
}
boolean empty = v == null;
if (checkTerminated(d, empty, a)) {
return;
}
if (empty) {
break;
}
a.onNext(v);
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
void drainFused() {
int missed = 1;
for (;;) {
if (cancelled) {
return;
}
boolean d = done;
Throwable ex = error;
if (!delayError && d && ex != null) {
actual.onError(error);
worker.dispose();
return;
}
actual.onNext(null);
if (d) {
ex = error;
if (ex != null) {
actual.onError(ex);
} else {
actual.onComplete();
}
worker.dispose();
return;
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
看起来很长，其实也很简单，重点就是继续调用onNext()将事件向下传递。也就是说observeOn会将它下游的onNext操作扔给它切换的线程中，因此ObserveOn影响的是它的下游节点。
