☝点击上方蓝字，关注我们！
在此，我们通过以下代码，在Observable模式下，对订阅流程、线程调度、操作符等完整流程进行源码解析。
实际上，整个的流程操作，包含了对象创建、逆向订阅、任务执行这三个步骤。
Observable代码示例：
1private void observableTest() { 2 Observable.create(new ObservableOnSubscribe<Integer>() { 3 @Override 4 public void subscribe(ObservableEmitter<Integer> emitter) throws Exception { 5 Log.d(TAG, "print create: " + 1); 6 emitter.onNext(1); 7 8 } 9 }).map(new Function<Integer, String>() {10 @Override11 public String apply(Integer integer) throws Exception {12 Log.d(TAG, "print map: " + integer.toString() + " is String!!!");13 return integer.toString() + " is String!!!";14 }15 }).doOnNext(new Consumer<String>() {16 @Override17 public void accept(String s) throws Exception {18 Log.d(TAG, "print doOnNext: " + s);1920 }21 }).subscribeOn(Schedulers.io())22 .observeOn(AndroidSchedulers.mainThread())23 .subscribe(new Consumer<String>() {24 @Override25 public void accept(String s) throws Exception {26 Log.d(TAG, "print success: " + s);27 }28 }, new Consumer<Throwable>() {29 @Override30 public void accept(Throwable throwable) throws Exception {31 Log.d(TAG, "error");32 }33 });34}
步骤：
(1) create一个Observable对象，并在subscribe()回调中执行onNext操作；
(2) 利用map操作符将int类型的数据转换成string类型的数据；
(3) 利用doOnNext操作符对上游发射的字符串进行进一步处理；
(4) 通过subscribeOn进行上游操作的线程调度；
(5) 通过observeOn进行下游操作的线程调度；
(6) 通过subscribe进行订阅，并在Consumer的回调中执行相应代码。
在梳理执行过程之前，我们先看一下Observable这个抽象类：
1public abstract class Observable<T> implements ObservableSource<T>
Observable类实现了ObservableSource接口，ObservableSource接口里定义了一个方法：
1public interface ObservableSource<T> { 23 /** 4 * Subscribes the given Observer to this ObservableSource instance. 5 * @param observer the Observer, not null 6 * @throws NullPointerException if {@code observer} is null 7 */ 8 void subscribe(@NonNull Observer<? super T> observer); 9}
在Observable类中对subscribe()的实现如下：
1@SchedulerSupport(SchedulerSupport.NONE) 2@Override 3public final void subscribe(Observer<? super T> observer) { 4 ObjectHelper.requireNonNull(observer, "observer is null"); 5 try { 6 observer = RxJavaPlugins.onSubscribe(this, observer); 7 8 ObjectHelper.requireNonNull(observer, "Plugin returned null Observer"); 910 subscribeActual(observer); 11 } catch (NullPointerException e) { // NOPMD 12 throw e; 13 } catch (Throwable e) { 14 Exceptions.throwIfFatal(e); 15 // can't call onError because no way to know if a Disposable has been set or not 16 // can't call onSubscribe because the call might have set a Subscription already 17 RxJavaPlugins.onError(e); 1819 NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS"); 20 npe.initCause(e); 21 throw npe; 22 } 23}
从如上代码中，我们看到在进行了一系列错误检查后，我们发现真正执行的代码是：
1subscribeActual(observer);
而这个方法是Observable类中定义的一个抽象方法：
1protected abstract void subscribeActual(Observer<? super T> observer);
到此，我们先记住Observable这个类对subscribe()的实现过程，暂时不对subscribeActual()在各个子类中的具体实现做分析，直接进入代码的执行过程。
1. 对象创建
(1) 从create开始：
1@CheckReturnValue 2@SchedulerSupport(SchedulerSupport.NONE) 3public static <T> Observable<T> create(ObservableOnSubscribe<T> source) { 4 ObjectHelper.requireNonNull(source, "source is null"); 5 return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source)); 6}
我们依然跳过错误检查，直接看：
1return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
onAssembly()实际上是hook function，如果我们没有进行任何配置，返回的就是我们传入的Observable对象：
1@SuppressWarnings({ "rawtypes", "unchecked" }) 2@NonNull 3public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) { 4 Function<? super Observable, ? extends Observable> f = onObservableAssembly; 5 if (f != null) { 6 return apply(f, source); 7 } 8 return source; 9}
在此我们跳过hook,看看ObservableCreate()都做了什么：
1public ObservableCreate(ObservableOnSubscribe<T> source) { 2 this.source = source; 3}
在这个构造方法中，其实只是将我们传入的ObservableOnSubscribe对象存了下来，然后返回一个Observable对象。
(2) map()
接下来我们回到observableTest()中看map方法的执行：
1@CheckReturnValue 2@SchedulerSupport(SchedulerSupport.NONE) 3public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) { 4 ObjectHelper.requireNonNull(mapper, "mapper is null"); 5 return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper)); 6}
依然跳过错误检查和hook，看看ObservableMap和其父类的构造方法：
1public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) { 2 super(source); 3 this.function = function; 4}
父类的构造方法：
1AbstractObservableWithUpstream(ObservableSource<T> source) { 2 this.source = source; 3}
在此我们看到构造方法中依旧只是对传入的ObservableSource对象进行了存储，并返回一个Observable对象。
由此，我们可以推测，步骤3，4，5的流程也是如此：
(3) doOnNext：
1@CheckReturnValue 2@SchedulerSupport(SchedulerSupport.NONE) 3public final Observable<T> doOnNext(Consumer<? super T> onNext) { 4 return doOnEach(onNext, Functions.emptyConsumer(), Functions.EMPTY_ACTION, Functions.EMPTY_ACTION); 5}
1@CheckReturnValue 2@SchedulerSupport(SchedulerSupport.NONE) 3private Observable<T> doOnEach(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate) { 4 ObjectHelper.requireNonNull(onNext, "onNext is null"); 5 ObjectHelper.requireNonNull(onError, "onError is null"); 6 ObjectHelper.requireNonNull(onComplete, "onComplete is null"); 7 ObjectHelper.requireNonNull(onAfterTerminate, "onAfterTerminate is null"); 8 return RxJavaPlugins.onAssembly(new ObservableDoOnEach<T>(this, onNext, onError, onComplete, onAfterTerminate)); 9}
1public ObservableDoOnEach(ObservableSource<T> source, Consumer<? super T> onNext, 2 Consumer<? super Throwable> onError, 3 Action onComplete, 4 Action onAfterTerminate) { 5 super(source); 6 this.onNext = onNext; 7 this.onError = onError; 8 this.onComplete = onComplete; 9 this.onAfterTerminate = onAfterTerminate; 10}
(4) subscribeOn：
1@CheckReturnValue 2@SchedulerSupport(SchedulerSupport.CUSTOM) 3public final Observable<T> subscribeOn(Scheduler scheduler) { 4 ObjectHelper.requireNonNull(scheduler, "scheduler is null"); 5 return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler)); 6}
1public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) { 2 super(source); 3 this.scheduler = scheduler; 4}
(5) observeOn：
1@CheckReturnValue 2@SchedulerSupport(SchedulerSupport.CUSTOM) 3public final Observable<T> observeOn(Scheduler scheduler) { 4 return observeOn(scheduler, false, bufferSize()); 5}
1@CheckReturnValue 2@SchedulerSupport(SchedulerSupport.CUSTOM) 3public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) { 4 ObjectHelper.requireNonNull(scheduler, "scheduler is null"); 5 ObjectHelper.verifyPositive(bufferSize, "bufferSize"); 6 return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize)); 7}
1public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) { 2 super(source); 3 this.scheduler = scheduler; 4 this.delayError = delayError; 5 this.bufferSize = bufferSize; 6}
到此为止，我们发现，前面的一系列操作，都是在构造方法里存储传入的ObservableSource等并返回一个Observable对象。除此之外并没有做什么操作，也没有对上游的数据进行任何处理。那我们来看看最后一步subscribe都做了什么：
1@CheckReturnValue 2@SchedulerSupport(SchedulerSupport.NONE) 3public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) { 4 return subscribe(onNext, onError, Functions.EMPTY_ACTION, Functions.emptyConsumer()); 5}
1@CheckReturnValue 2@SchedulerSupport(SchedulerSupport.NONE) 3public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, 4 Action onComplete, Consumer<? super Disposable> onSubscribe) { 5 ObjectHelper.requireNonNull(onNext, "onNext is null"); 6 ObjectHelper.requireNonNull(onError, "onError is null"); 7 ObjectHelper.requireNonNull(onComplete, "onComplete is null"); 8 ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null"); 910 LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe); 1112 subscribe(ls); 1314 return ls; 15}
在进行了错误检查和hook后，会创建一个LamdaObserver对象：
1public LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError, 2 Action onComplete, 3 Consumer<? super Disposable> onSubscribe) { 4 super(); 5 this.onNext = onNext; 6 this.onError = onError; 7 this.onComplete = onComplete; 8 this.onSubscribe = onSubscribe; 9}
之后执行了Observable的subscribe(ls)方法。到这我们会觉着似曾相识，还记着最上面我们提到Observable类中对subscribe()的实现么?在对subscribe()的实现中，subscribeActual()将被执行。subscribeActual()是Observable类中定义的一个抽象方法，由此可见，在从上游到下游创建了一系列Observable对象后，将在subscribe的过程中逐一被订阅。在此我们推测，这个订阅过程是从下游到上游逆向的。接下来我们看相应的代码实现：
2. 逆向订阅
(1) observeOn：
1@Override 2protected void subscribeActual(Observer<? super T> observer) { 3 if (scheduler instanceof TrampolineScheduler) { 4 source.subscribe(observer); 5 } else { 6 Scheduler.Worker w = scheduler.createWorker(); 7 8 source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize)); 9 } 10}
1ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) { 2 this.actual = actual; 3 this.worker = worker; 4 this.delayError = delayError; 5 this.bufferSize = bufferSize; 6}
在ObservableObserveOn类中对subscribeActual的实现里，我们看到首先创建了一个线程调度相关的Worker对象，之后调用了上游Observable对象的subscribe方法：source.subscribe()，完成了观察者ObserveOnObserver和被观察者之间的订阅流程。接下来我们再看一下上游subscribeOn过程中的subscribeActual的实现。
(2) subscribeOn：
1@Override 2public void subscribeActual(final Observer<? super T> s) { 3 final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s); 45 s.onSubscribe(parent); 67 parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent))); 8}
1SubscribeOnObserver(Observer<? super T> actual) { 2 this.actual = actual; 3 this.s = new AtomicReference<Disposable>(); 4}
SubscribeTask()实际上在实现Runnable接口时，创建一个SubscribeOnObserver对象，并调用了上游Observable对象的subscribe方法进行订阅：source.subscribe(parent)，然后为上游的操作进行线程调度（在此先不对线程调度做深入分析），再交由上游处理，我们接着看上游：
(3) doOnNext：
1@Override 2public void subscribeActual(Observer<? super T> t) { 3 source.subscribe(new DoOnEachObserver<T>(t, onNext, onError, onComplete, onAfterTerminate)); 4}
1DoOnEachObserver( 2 Observer<? super T> actual, 3 Consumer<? super T> onNext, 4 Consumer<? super Throwable> onError, 5 Action onComplete, 6 Action onAfterTerminate) { 7 this.actual = actual; 8 this.onNext = onNext; 9 this.onError = onError; 10 this.onComplete = onComplete; 11 this.onAfterTerminate = onAfterTerminate; 12}
doOnNext创建了一个DoOnEachObserver对象，订阅后直接交由上游处理。
(4) map：
1@Override 2public void subscribeActual(Observer<? super U> t) { 3 source.subscribe(new MapObserver<T, U>(t, function)); 4}
1@Override 2public void subscribeActual(Observer<? super U> t) { 3 source.subscribe(new MapObserver<T, U>(t, function)); 4}
map创建了一个MapObserver对象，订阅后继续交由上游处理：
(5) create：
1@Override 2protected void subscribeActual(Observer<? super T> observer) { 3 CreateEmitter<T> parent = new CreateEmitter<T>(observer); 4 observer.onSubscribe(parent); 5 6 try { 7 source.subscribe(parent); 8 } catch (Throwable ex) { 9 Exceptions.throwIfFatal(ex); 10 parent.onError(ex); 11 } 12}
现在我们回到了最上游，从代码中我们可以看到，首先调用了observer.onSubscribe()，这里的observer来自map。最上游的source.subscribe()的source是我们传入的ObservableOnSubscribe对象，而执行的subscribe()方法会被回调到我们最一开始的示例代码中，执行emitter.onNext()：
1Observable.create(new ObservableOnSubscribe<Integer>() { 2 @Override 3 public void subscribe(ObservableEmitter<Integer> emitter) throws Exception { 4 Log.d(TAG, "print create: " + 1); 5 emitter.onNext(1); 67 } 8})
到此为止，我们可得知整个订阅过程是从下至上逆向的，下一级的Observable会生成一个Observer对象，与上一级的source进行订阅。
在完成了对象创建和订阅的过程，我们终于可以看到代码真正的执行了。
3. 任务执行
(1) create：
接着我们上面的流程继续，emitter.onNext(1)将会被执行，跟踪下去，走到CreateEmitter的onNext方法中去：
1public interface Emitter<T> { 2 3 /** 4 * Signal a normal value. 5 * @param value the value to signal, not null 6 */ 7 void onNext(@NonNull T value); 8 9 /** 10 * Signal a Throwable exception. 11 * @param error the Throwable to signal, not null 12 */ 13 void onError(@NonNull Throwable error); 1415 /** 16 * Signal a completion. 17 */ 18 void onComplete(); 19}
1@Override 2public void onNext(T t) { 3 if (t == null) { 4 onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); 5 return; 6 } 7 if (!isDisposed()) { 8 observer.onNext(t); 9 } 10}
我们可以看到，这里调用了observer的onNext()方法：
1observer.onNext(t);
这里的observer，如逆向订阅流程的分析，便是下游map对应的Observer，既然如此，我们看一下MapObserver的onNext()都做了什么。
(2) map：
1@Override 2public void onNext(T t) { 3 if (done) { 4 return; 5 } 6 7 if (sourceMode != NONE) { 8 actual.onNext(null); 9 return; 10 } 1112 U v; 1314 try { 15 v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value."); 16 } catch (Throwable ex) { 17 fail(ex); 18 return; 19 } 20 actual.onNext(v); 21}
我们看到在做了一些列检查之后，首先调用的是mapper.apply(t)方法，而mapper就是我们传入的function，所以回到我们observableTest()方法，可以看到apply()方法的执行：
1map(new Function<Integer, String>() { 2 @Override 3 public String apply(Integer integer) throws Exception { 4 Log.d(TAG, "print map: " + integer.toString() + " is String!!!"); 5 return integer.toString() + " is String!!!"; 6 } 7})
上面代码中，我们修改了数据类型，返回了一个字符串给MapObserver继续处理，触发actual.onNext(v)的执行。从构造方法中我们可以看到，这个actual就是下游的doOnNext对应的Observer。接下来我们继续看doOnEachObserver中onNext()的代码。
(3) doOnNext：
1@Override 2public void onNext(T t) { 3 if (done) { 4 return; 5 } 6 try { 7 onNext.accept(t); 8 } catch (Throwable e) { 9 Exceptions.throwIfFatal(e); 10 s.dispose(); 11 onError(e); 12 return; 13 } 1415 actual.onNext(t); 16}
我们看到首先执行了onNext.accept(t)，也就是回调到observableTest()里执行的方法：
1doOnNext(new Consumer<String>() { 2 @Override 3 public void accept(String s) throws Exception { 4 Log.d(TAG, "print doOnNext: " + s); 56 } 7})
返回一个字符串给doOnEachObserver处理，再通过actual.onNext()给下游subscribeOn的Observer进行处理。所以我们继续看SubscribeOnObserver中onNext()的实现:
(4) subscribeOn：
1@Override 2public void onNext(T t) { 3 actual.onNext(t); 4}
直接走到下游observeOn传入的Observer的onNext()，即ObserveOnObserver的onNext()：
(5) observeOn：
1@Override 2public void onNext(T t) { 3 if (done) { 4 return; 5 } 6 7 if (sourceMode != QueueDisposable.ASYNC) { 8 queue.offer(t); 9 } 10 schedule(); 11}
在这里进行了线程调度（具体的线程调度流程下一节分析），最后执行了schedule()方法后，走到了Runnable的run()方法里面：
1@Override 2public void run() { 3 if (outputFused) { 4 drainFused(); 5 } else { 6 drainNormal(); 7 } 8}
drainFused()和drainNormal()方法里，最终都是根据场景不同而执行了actual.onNext()，onComplete()或onError()方法，这个actual就是ObserveOnObserver构造时创建的下游Observer，即LambdaObserver。所以接下来会执行LambdaObserver的onNext(), onComplete()和onError()方法。
(6) subscribe：
1@Override 2public void onNext(T t) { 3 if (!isDisposed()) { 4 try { 5 onNext.accept(t); 6 } catch (Throwable e) { 7 Exceptions.throwIfFatal(e); 8 get().dispose(); 9 onError(e); 10 } 11 } 12} 1314@Override 15public void onError(Throwable t) { 16 if (!isDisposed()) { 17 lazySet(DisposableHelper.DISPOSED); 18 try { 19 onError.accept(t); 20 } catch (Throwable e) { 21 Exceptions.throwIfFatal(e); 22 RxJavaPlugins.onError(new CompositeException(t, e)); 23 } 24 } else { 25 RxJavaPlugins.onError(t); 26 } 27} 2829@Override 30public void onComplete() { 31 if (!isDisposed()) { 32 lazySet(DisposableHelper.DISPOSED); 33 try { 34 onComplete.run(); 35 } catch (Throwable e) { 36 Exceptions.throwIfFatal(e); 37 RxJavaPlugins.onError(e); 38 } 39 } 40}
在这里，我们可根据传参，进行最终的数据操作。到此为止，一个完整的Observable流程便走完了。
4. 总流程图
我们将此过程归纳成流程图，红箭头代表着执行过程：
狐友技术团队其他精彩文章
Swift之Codable实战技巧
不了解GIF的加载原理？看我就够了！
安卓系统权限，你真的了解吗？
加入搜狐技术作者天团
千元稿费等你来！
戳这里！☛
