文章目录
RxJava源码分析（一）
Rxjava基础原理基于Hook技术(钩子函数)，即占位替换,动态代理。关键类RxJavaPlugins（小孩子做选择的地
方）
一、基础示例（一）
当前线程中顺序执行的示例
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
//方法体1
}
}).subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
//方法体0
}
@Override
public void onNext(Object o) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
第一步 执行Observable中create静态方法
1.1、首先运行Observable中静态方法create,向RxJavaPlugins中传入ObservableCreate对象
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
//source是ObservableOnSubscribe对象(方法体1所在对象)
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));//对象选择
}
1.2、ObservableCreate初始化,source 是ObservableOnSubscribe对象
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;//关键
}
1.3、调用
RxJavaPlugins中静态方法onAssembly,因初始onObservableAssembly未赋值(为null),所以返回的是ObservableCreate对象
@SuppressWarnings("rawtypes")
@Nullable
static volatile Function<? super Observable, ? extends Observable> onObservableAssembly;
...
@SuppressWarnings({ "rawtypes", "unchecked" })
@NonNull
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;
}
第二步 执行ObservableCreate对象中subscribe方法
2.1、调用ObservableCreate中subscribe方法,因继承自Observable且未重写,所以运行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);//对象选择
...
subscribeActual(observer);//执行ObservableCreate中subscribeActual方法
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
2.2、
先运行RxJavaPlugins中静态方法onSubscribe,因onObservableSubscribe未赋值(为null),所以返回传入的observer对象
@NonNull
public static <T> Observer<? super T> onSubscribe(@NonNull Observable<T> source, @NonNull Observer<? super T> observer) {
BiFunction<? super Observable, ? super Observer, ? extends Observer> f = onObservableSubscribe;
if (f != null) {
return apply(f, source, observer);
}
return observer;
}
2.3、然后运行ObservableCreate中subscribeActual方法,传入2.2中返回的observer对象
(subscribeActual这个函数是Observable中抽象函数,是一个Hook锚点,坑位)
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);//关键点,链接create中ObservableOnSubscribe对象和subscribe中Observer对象
observer.onSubscribe(parent);//执行subscribe函数中Observer对象的onSubscribe方法
try {
source.subscribe(parent);//执行ObservableOnSubscribe中subscribe方法(方法体1)
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
2.4、运行subscribe中Observer对象的onSubscribe方法,传入CreateEmitter对象,即运行示例中方法体0
2.5、再运行create中ObservableOnSubscribe对象的subscribe方法,即运行示例中方法体1.
ObservableOnSubscribe中subscribe方法传入的是CreateEmitter对象
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
...
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
//这里传入的是subscribe中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 (!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);//注意点
} finally {
dispose();
}
return true;
}
return false;
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();//注意点
} finally {
dispose();
}
}
}
...
}
通过以上CreateEmitter源码中注意点可知subscribe中Observer对象中除onSubscribe(即方法体0)外,其余方法都是在create中ObservableOnSubscribe对象的subscribe方法(即方法体1)中通过CreateEmitter对象调用.
总结
基础示例中各方法运行顺序:
| 执行顺序 | 方法名 | 所属对象 |
|---|---|---|
| 1 | create | Observable中静态方法 |
| 2 | subscribe | ObservableCreate |
| 3 | onSubscribe | Observer |
| 4 | subscribe | ObservableOnSubscribe |
| 6 | onNext/onComplete/onError | Observer |
二、基础示例（二）
涉及线程切换的示例
Observable.create(emitter -> {
//方法体1
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
//方法体0
}
@Override
public void onNext(Object o) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
第一步 同基础示例(一)
第二步 执行ObservableCreate对象的subscribeOn方法
Schedulers.io()
@NonNull
static final Scheduler IO;
...
static {
...
IO = RxJavaPlugins.initIoScheduler(new IOTask());
...
}
...
static final class IOTask implements Callable<Scheduler> {
@Override
public Scheduler call() throws Exception {
return IoHolder.DEFAULT;
}
}
...
static final class IoHolder {
static final Scheduler DEFAULT = new IoScheduler();
}
...
@NonNull
public static Scheduler io() {
return RxJavaPlugins.onIoScheduler(IO);//此处返回对象IO
}
RxJavaPlugins
@NonNull
public static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler) {
ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");
Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitIoHandler;//onInitIoHandler未赋值
if (f == null) {
return callRequireNonNull(defaultScheduler);//此处返回defaultScheduler.call()的值
}
return applyRequireNonNull(f, defaultScheduler);
}
...
@NonNull
public static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler) {
Function<? super Scheduler, ? extends Scheduler> f = onIoHandler;//onIoHandler未赋值为null
if (f == null) {
return defaultScheduler;
}
return apply(f, defaultScheduler);
}
...
static Scheduler callRequireNonNull(@NonNull Callable<Scheduler> s) {
try {
//s.call()不为null,直接返回
return ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't be null");
} catch (Throwable ex) {
throw ExceptionHelper.wrapOrThrow(ex);
}
}
总结: Schedulers.io()返回的是IoScheduler对象
IoScheduler
private static final String WORKER_THREAD_NAME_PREFIX = "RxCachedThreadScheduler";
static final RxThreadFactory WORKER_THREAD_FACTORY;
static {
...
int priority = Math.max(Thread.MIN_PRIORITY, Math.min(Thread.MAX_PRIORITY,
Integer.getInteger(KEY_IO_PRIORITY, Thread.NORM_PRIORITY)));
WORKER_THREAD_FACTORY = new RxThreadFactory(WORKER_THREAD_NAME_PREFIX, priority);
...
}
public IoScheduler(ThreadFactory threadFactory) {
this.threadFactory = threadFactory;
this.pool = new AtomicReference<CachedWorkerPool>(NONE);
start();
}
@Override
public void start() {
CachedWorkerPool update = new CachedWorkerPool(KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT, threadFactory);
if (!pool.compareAndSet(NONE, update)) {
update.shutdown();
}
}
static final class CachedWorkerPool implements Runnable {
CachedWorkerPool(long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory) {
...
this.allWorkers = new CompositeDisposable();
this.threadFactory = threadFactory;
...
}
...
ThreadWorker get() {
if (allWorkers.isDisposed()) {//初始为false
return SHUTDOWN_THREAD_WORKER;
}
while (!expiringWorkerQueue.isEmpty()) {
ThreadWorker threadWorker = expiringWorkerQueue.poll();
if (threadWorker != null) {
return threadWorker;
}
}
//找不到缓存的工作进程，因此创建一个新的ThreadWorker对象(继承NewThreadWorker)
ThreadWorker w = new ThreadWorker(threadFactory);
allWorkers.add(w);
return w;
}
...
}
...
public IoScheduler() {
this(WORKER_THREAD_FACTORY);
}
public IoScheduler(ThreadFactory threadFactory) {
this.threadFactory = threadFactory;
this.pool = new AtomicReference<CachedWorkerPool>(NONE);//解决并发修改多个属性问题,当做CachedWorkerPool对象看
start();//更新缓存工作池
}
...
//提前划重点1 下面会用到
@NonNull
@Override
public Worker createWorker() {
return new EventLoopWorker(pool.get());//pool.get()是CachedWorkerPool对象
}
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();//返回一个NewThreadWorker对象
}
...
//提前划重点2 下面会用到
@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;
}
//ThreadWorker未重写scheduleActual,执行NewThreadWorker中scheduleActual方法
//action是DisposeTask对象 下面会提到 tasks是CompositeDisposable对象
return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}
}
subscribeOn
Observable中subscribeOn
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.CUSTOM)
public final Observable<T> subscribeOn(Scheduler scheduler) {
//scheduler是IoScheduler对象(继承自Scheduler)
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
//this是create中生成的ObservableCreate对象
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}
RxJavaPlugins.onAssembly,onObservableAssembly无赋值,返回ObservableSubscribeOn（继承自Observable）对象
public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;//IoScheduler对象(继承自Scheduler)
public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
//这里传入create中生成的ObservableCreate对象
super(source);
this.scheduler = scheduler;
}
//此方法执行时机需结合第二步理解,这里先行分析如何将方法体1放到子线程
//这里传入ObservableObserveOn中ObserveOnObserver对象 见ObservableObserveOn中subscribeActual方法分析
@Override
public void subscribeActual(final Observer<? super T> observer) {
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
//执行ObserveOnObserver对象的onSubscribe方法,执行线程为当前线程
observer.onSubscribe(parent);
//先执行IoScheduler对象的scheduleDirect()
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
...
SubscribeOnObserver(Observer<? super T> downstream) {
this.downstream = downstream;//downstream是ObservableObserveOn中ObserveOnObserver对象
...
}
...
@Override
public void onNext(T t) {
downstream.onNext(t);//执行ObserveOnObserver对象对象onNext(t)
}
@Override
public void onError(Throwable t) {
downstream.onError(t);//执行ObserveOnObserver对象对象onError(t)
}
@Override
public void onComplete() {
downstream.onComplete();//执行ObserveOnObserver对象对象onComplete()
}
...
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() {
/* 重点
* 执行方法体1,指定线程中运行.
* 此处执行ObservableCreate对象中subscribe()方法(继承自Observable,且未重写),
* 由示例(一)知实际执行的是ObservableOnSubscribe对象的subscribe()方法
*/
source.subscribe(parent);
}
}
}
Scheduler
IoScheduler对象的scheduleDirect()未重写父类方法
@NonNull
public Disposable scheduleDirect(@NonNull Runnable run) {
//run是SubscribeTask对象
return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
}
@NonNull
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
//抽象方法此处由IoScheduler实现,返回EventLoopWorker对象 见IoScheduler中重点1
final Worker w = createWorker();
final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);//返回run对象
//decoratedRun是SubscribeTask对象 重点
DisposeTask task = new DisposeTask(decoratedRun, w);
//执行EventLoopWorker对象的schedule()方法 见IoScheduler中重点2
//执行NewThreadWorker.scheduleActual方法
w.schedule(task, delay, unit);
return task;
}
...
static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {
...
DisposeTask(@NonNull Runnable decoratedRun, @NonNull Worker w) {
this.decoratedRun = decoratedRun; //decoratedRun是SubscribeTask对象 重点
this.w = w;//是IoScheduler中EventLoopWorker对象
}
@Override
public void run() {
runner = Thread.currentThread();
try {
decoratedRun.run(); // 重点
} finally {
dispose();
runner = null;
}
}
...
}
}
NewThreadWorker.scheduleActual
private final ScheduledExecutorService executor;
public NewThreadWorker(ThreadFactory threadFactory) {
executor = SchedulerPoolFactory.create(threadFactory);//创建线程池
}
...
@NonNull
public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
//decoratedRun是DisposeTask对象 parent是CompositeDisposable对象 重点
ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
if (parent != null) {
if (!parent.add(sr)) {
return sr;
}
}
Future<?> f;
try {
//提交线程池并执行ScheduledRunnable任务 重点
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;
}
ScheduledRunnable
public ScheduledRunnable(Runnable actual, DisposableContainer parent) {
super(3);
this.actual = actual;//是DisposeTask对象
this.lazySet(0, parent);
}
...
@Override
public void run() {
lazySet(THREAD_INDEX, Thread.currentThread());
try {
try {
actual.run();//执行DisposeTask.run()->执行SubscribeTask.run()->执行方法体1
} catch (Throwable e) {
// Exceptions.throwIfFatal(e); nowhere to go
RxJavaPlugins.onError(e);
}
} finally {
...
}
}
总结
1、将静态方法create()返回的ObservableCreate对象转成subscribeOn方法里返回的ObservableSubscribeOn对象
2、兜兜绕绕一大圈只为将方法体1放到子线程中
第三步 执行ObservableSubscribeOn对象的observeOn方法
AndroidSchedulers.mainThread()
AndroidSchedulers
private static final class MainHolder {
static final Scheduler DEFAULT
= new HandlerScheduler(new Handler(Looper.getMainLooper()), false);//重点
}
private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
new Callable<Scheduler>() {
@Override public Scheduler call() throws Exception {
return MainHolder.DEFAULT;
}
});
public static Scheduler mainThread() {
return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);//返回MAIN_THREAD对象 是HandlerScheduler对象
}
observeOn
Observable中observeOn(subscribeOn中返回的ObservableSubscribeOn对象继承自Observable,且未重写observeOn方法)
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.CUSTOM)
public final Observable<T> observeOn(Scheduler scheduler) {
return observeOn(scheduler, false, bufferSize());
}
...
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.CUSTOM)
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
ObjectHelper.verifyPositive(bufferSize, "bufferSize");
//这里this是上一步产生的ObservableSubscribeOn对象
return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
}
RxJavaPlugins.onAssembly,onObservableAssembly无赋值,返回ObservableObserveOn（继承自Observable）对象
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;
final boolean delayError;
final int bufferSize;
public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
// source是ObservableSubscribeOn对象
super(source);
this.scheduler = scheduler;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
//由基础示例(一)可知Observable中subscribe方法执行会转到这里
@Override
protected void subscribeActual(Observer<? super T> observer) {
// source是ObservableSubscribeOn对象 重点
if (scheduler instanceof TrampolineScheduler) {
//计划在当前线程上工作，但不会立即执行。当前工作单元完成后，将工作放入队列并执行
source.subscribe(observer);
} else {
Scheduler.Worker w = scheduler.createWorker();//调用HandlerScheduler中createWorker()方法 返回HandlerWorker对象
//转到执行ObservableSubscribeOn对象的subscribeActual方法
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
...
ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
this.downstream = actual;//示例中实现observer的匿名内部类对象
this.worker = worker;//HandlerWorker对象
this.delayError = delayError;
this.bufferSize = bufferSize;
}
//传入的是ObservableSubscribeOn对象中的SubscribeOnObserver对象
//在ObservableSubscribeOn对象中subscribeActual方法中调用
@Override
public void onSubscribe(Disposable d) {
if (DisposableHelper.validate(this.upstream, d)) {//upstream未初始化 这里返回true
this.upstream = d;
if (d instanceof QueueDisposable) {
//d是SubscribeOnObserver对象 false
...
}
queue = new SpscLinkedArrayQueue<T>(bufferSize);//T对象队列
downstream.onSubscribe(this);//执行方法体0,在当前线程执行
}
}
//在SubscribeOnObserver对象的onNext()方法中执行
@Override
public void onNext(T t) {
if (done) {//默认初始false
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);//将对象放入队列中
}
schedule();
}
//在SubscribeOnObserver对象的onError()方法中执行
@Override
public void onError(Throwable t) {
if (done) {//默认初始false
RxJavaPlugins.onError(t);
return;
}
error = t;
done = true;
schedule();
}
//在SubscribeOnObserver对象的onComplete()方法中执行
@Override
public void onComplete() {
if (done) {//默认初始false
return;
}
done = true;
schedule();
}
...
void schedule() {
if (getAndIncrement() == 0) {//getAndIncrement()默认为0
worker.schedule(this);//执行HandlerWorker对象的schedule方法
}
}
void drainNormal() {
int missed = 1;
final SimpleQueue<T> q = queue;
final Observer<? super T> a = downstream;
for (;;) {
if (checkTerminated(done, q.isEmpty(), a)) {
return;
}
for (;;) {
boolean d = done;
T v;
try {
v = q.poll();//出栈 q是T对象队列
} catch (Throwable ex) {
...
}
boolean empty = v == null;
if (checkTerminated(d, empty, a)) {//未终止
return;
}
...
a.onNext(v);//a是示例中实现observer的匿名内部类对象
}
...
}
}
boolean checkTerminated(boolean d, boolean empty, Observer<? super T> a) {
if (disposed) {
queue.clear();
return true;
}
if (d) {
Throwable e = error;
if (delayError) {
if (empty) {
disposed = true;
if (e != null) {
a.onError(e);
} else {
a.onComplete();
}
worker.dispose();
return true;
}
} else {
if (e != null) {
disposed = true;
queue.clear();
a.onError(e);
worker.dispose();
return true;
} else
if (empty) {
disposed = true;
a.onComplete();
worker.dispose();
return true;
}
}
}
return false;
}
@Override
public void run() {
if (outputFused) {//默认false
drainFused();
} else {
drainNormal();
}
}
...
}
}
HandlerScheduler
final class HandlerScheduler extends Scheduler {
...
@Override
public Worker createWorker() {
return new HandlerWorker(handler, async);//handler是带Android主线程Looper的自定义Handler对象 详见AndroidSchedulers
}
private static final class HandlerWorker extends Worker {
...
@Override
@SuppressLint("NewApi") // Async will only be true when the API is available to call.
public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
...
run = RxJavaPlugins.onSchedule(run);//run是ObserveOnObserver对象
ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
Message message = Message.obtain(handler, scheduled);
message.obj = this; // Used as token for batch disposal of this worker's runnables.
if (async) {//false 详见AndroidSchedulers
message.setAsynchronous(true);
}
//向Android主线程消息队列发消息 重点
handler.sendMessageDelayed(message, unit.toMillis(delay));
// Re-check disposed state for removing in case we were racing a call to dispose().
if (disposed) {
handler.removeCallbacks(scheduled);
return Disposables.disposed();
}
return scheduled;
}
...
}
private static final class ScheduledRunnable implements Runnable, Disposable {
...
ScheduledRunnable(Handler handler, Runnable delegate) {
this.handler = handler;
this.delegate = delegate;//ObserveOnObserver对象
}
@Override
public void run() {
try {
delegate.run(); //执行ObserveOnObserver对象的run方法
} catch (Throwable t) {
RxJavaPlugins.onError(t);
}
}
...
}
}
第四步 执行ObservableObserveOn对象的subscribe方法
具体实现同基础示例(一)
总结
1、创建ObservableOnSubscribe类型的匿名内部类source
2、执行静态方法Observable.create，传入source对象。创建并返回ObservableCreate对象（传入source对象）
3、执行静态方法Schedulers.io()，创建IoScheduler对象
4、执行ObservableCreate对象的subscribeOn方法，传入IoScheduler对象。创建并返回ObservableSubscribeOn对象（传入ObservableCreate和IoScheduler对象）
5、执行静态方法AndroidSchedulers.mainThread()，创建HandlerScheduler（传入带主消息队列Looper.getMainLooper()的Handler对象）
6、执行ObservableSubscribeOn对象的observeOn方法，传入HandlerScheduler对象。创建并返回ObservableObserveOn对象（传入ObservableSubscribeOn对象、HandlerScheduler对象、false、0）
7、创建Observer类型的匿名内部类，观察者observer对象
8、执行ObservableObserveOn对象subscribe方法，传入observer对象
9、执行ObservableObserveOn对象的subscribeActual方法，传入observer对象。
9.1、执行HandlerScheduler对象的createWorker方法，创建HandlerWorker对象（传入Handler对象）。
9.2、创建ObserveOnObserver对象，传入observer和HandlerWorker对象
9.3、执行ObservableSubscribeOn的subscribe方法，传入ObserveOnObserver对象
10、执行ObservableSubscribeOn的subscribeActual方法，传入ObserveOnObserver对象
10.1、创建SubscribeOnObserver对象，传入ObserveOnObserver对象
10.2、执行ObserveOnObserver的onSubscribe方法，传入SubscribeOnObserver对象
10.2.1、创建SpscLinkedArrayQueue队列（存放source对象中subscribe方法里ObservableEmitter对象的onNext(t)方法中传入的t对象）
10.2.2、执行observer的onSubscribe方法,传入ObserveOnObserver对象。即主线程执行方法体0
10.3、创建SubscribeTask对象，传入ObserveOnObserver对象
10.4、执行IoScheduler的scheduleDirect方法，传入SubscribeTask对象
10.4.1、执行IoScheduler的createWorker方法,创建EventLoopWorker对象(传入CachedWorkerPool对象,IoScheduler初始化时创建。创建ThreadWorker对象，来自CachedWorkerPool)
10.4.2、创建DisposeTask对象，传入SubscribeTask和EventLoopWorker对象
10.4.3、执行EventLoopWorker的schedule方法，传入DisposeTask对象
10.4.4、执行ThreadWorker的scheduleActual方法（继承自NewThreadWorker），传入DisposeTask对象
10.4.5、创建ScheduledRunnable对象（Runnable对象），传入DisposeTask对象
10.4.6、线程池executor（ThreadWorker初始化时创建）提交执行ScheduledRunnable对象，执行ScheduledRunnable的run方法
10.4.7、执行DisposeTask的run方法
10.4.8、执行SubscribeTask的run方法
10.4.9、执行ObservableCreate的subscribe方法，传入ObserveOnObserver对象。
10.4.10、执行ObservableCreate的subscribeActual方法，传入ObserveOnObserver对象。创建CreateEmitter对象（传入ObserveOnObserver对象）
10.4.11、执行source的subscribe方法，传入CreateEmitter对象。即子线程执行方法体1
11、在source的subscribe方法中调用CreateEmitter对象的onNext/onError/onComplete等方法
12、执行ObserveOnObserver对象的onNext/onError/onComplete等方法
12.1、onNext方法会将传入的t对象放入SpscLinkedArrayQueue队列中
12.2、执行ObserveOnObserver的schedule方法
13、执行HandlerWorker的schedule方法，传入ObserveOnObserver对象。创建ScheduledRunnable对象（传入ObserveOnObserver和Handler对象）。创建Message对象（传入ScheduledRunnable和Handler对象），向Android主线程消息队列发送Message消息
14、主线程执行ScheduledRunnable的run方法，执行ObserveOnObserver的run方法
15、执行ObserveOnObserver的drainNormal方法，执行ObserveOnObserver的checkTerminated方法。即主线程执行onNext/onError/onComplete等方法
202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
