RxJava2一次流程源码分析总结

//一次调用
 Disposable disposable = Observable
        .create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
            }
        })
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer i) throws Exception {
                return Observable.just(String.valueOf(i));
            }
        })
        .map(new Function<String, String>() {
            @Override
            public String apply(String s) throws Exception {
                return "ssss" + s;
            }
        })
        .subscribe(new Consumer<String>() {
                       @Override
                       public void accept(String s) throws Exception {
                       }
                   }, new Consumer<Throwable>() {
                       @Override
                       public void accept(Throwable throwable) throws Exception {
                       }
                   }, new Action() {
                       @Override
                       public void run() throws Exception {
                       }
                   }, new Consumer<Disposable>() {
                       @Override
                       public void accept(Disposable disposable) throws Exception {
                       }
                   }
        );

create方法：

该方法返回ObservableCreate对象，并将ObservableOnSubscribe的实现类 以source传入。

@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));
}

subscribeOn方法：

将Observable的实现类ObservableCreate 和 IOScheduler传入，构造一个ObservableSubscribeOn 对象。

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.CUSTOM)
public final Observable<T> subscribeOn(Scheduler scheduler) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}

Schedulers.io方法

Scheduler IO = RxJavaPlugins.initIoScheduler(new IOTask());
//这个IO代表IoScheduler的实现
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();
}

IoScheduler类：

传入自定义的线程工厂，创建一个乐观锁的CachedWorkerPool，并开启start方法。

start()：创建一个CachedWorkerPool 并更新pool。

compareAndSet(NONE，update)：期望值应该为NONE，代表没有别的线程更新pool，那么当前线程更新pool，把引用更新为update。期望值不为NONE，代表已经有别的线程更新过pool，那么把当前创建的CachedWorkerPool释放掉。

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();
    }
}

CachedWorkerPool：

它是一个Runnable。保存着threadWorker的存活时间，threadWorker的队列，执行当前runnable的executor，线程工厂。
构造中函数末尾会执行本身这个runnable，调用run方法。并轮训调用evictExpiredWorkers()方法。

private final long keepAliveTime;
private final ConcurrentLinkedQueue<ThreadWorker> expiringWorkerQueue;
final CompositeDisposable allWorkers;
private final ScheduledExecutorService evictorService;
private final Future<?> evictorTask;
private final ThreadFactory threadFactory;
CachedWorkerPool(long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory) {
    this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
    this.expiringWorkerQueue = new ConcurrentLinkedQueue<ThreadWorker>();
    this.allWorkers = new CompositeDisposable();
    this.threadFactory = threadFactory;
    ScheduledExecutorService evictor = null;
    Future<?> task = null;
    if (unit != null) {
        evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
        task = evictor.scheduleWithFixedDelay(this, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS);
    }
    evictorService = evictor;
    evictorTask = task;
}
//在任务释放时，会将threadWorker添加到队列，按顺序添加。
void release(ThreadWorker threadWorker) {
    // Refresh expire time before putting worker back in pool
    threadWorker.setExpirationTime(now() + keepAliveTime);
    expiringWorkerQueue.offer(threadWorker);
}
@Override
public void run() {
    evictExpiredWorkers();
}
//每隔keepAliveTime时间轮训调用该函数一次，找到过期的任务并移除。
void evictExpiredWorkers() {
    if (!expiringWorkerQueue.isEmpty()) {
        long currentTimestamp = now();
        for (ThreadWorker threadWorker : expiringWorkerQueue) {
            if (threadWorker.getExpirationTime() <= currentTimestamp) {
                if (expiringWorkerQueue.remove(threadWorker)) {
                    allWorkers.remove(threadWorker);
                }
            } else {
                // Queue is ordered with the worker that will expire first in the beginning, so when we
                // find a non-expired worker we can stop evicting.
                break;
            }
        }
    }
}

observeOn方法；

将Observable的实现类ObservableSubscribeOn ，scheduler，delayError，bufferSize构造一个ObservableObserveOn 对象

@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");
    return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
}
        a、AndroidSchedulers.mainThread()方法：
private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
        new Callable<Scheduler>() {
            @Override public Scheduler call() throws Exception {
                return MainHolder.DEFAULT;
            }
        });
private static final class MainHolder {
    static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));
}

subscribe方法：

传入的Consumer最终会被包装成LambdaObserver，并进行订阅，最终会调用实现类的subscribeActual方法。

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
        Action onComplete, Consumer<? super Disposable> onSubscribe) {
    ObjectHelper.requireNonNull(onNext, "onNext is null");
    ObjectHelper.requireNonNull(onError, "onError is null");
    ObjectHelper.requireNonNull(onComplete, "onComplete is null");
    ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
    LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
    subscribe(ls);
    return ls;
}
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
    。。。
        observer = RxJavaPlugins.onSubscribe(this, observer);
        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
        subscribeActual(observer);
    。。。
}

subscribeActual方法：

刚才构建Observable的时候是一层一层向后传递：ObservableCreate->ObservableSubscribeOn-ObservableObserveOn
所以会先执行ObservableObserveOn 的subscribeActual方法

ObservableObserveOn#subscribeActual():

@Override
protected void subscribeActual(Observer<? super T> observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else {
        //这里的scheduler便是HandlerScheduler
        //HandlerScheduler#createWorker():返回HandlerWorker
        Scheduler.Worker w = scheduler.createWorker();
        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
    }
}

这里的source便是上一级的Observable，即ObservableSubscribeOn，调用subscribe方法，最终会调用ObservableSubscribeOn的subscribeActual方法，并传入ObserveOnObserver：

ObservableSubscribeOn#subscribeActual():

@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)));
}

这里的参数s，便是 ObserveOnObserver
然后调用ObserveOnObserver的onSubscribe方法；

ObserveOnObserver#onSubscribe()：

@Override
public void onSubscribe(Disposable s) {
    if (DisposableHelper.validate(this.s, s)) {
        this.s = s;
        。。。
        queue = new SpscLinkedArrayQueue<T>(bufferSize);
        actual.onSubscribe(this);
    }
}

这里的actual便是之前最原始的LamdaObserver，所以onSubscribe方法是在当前线程最先被调用的。

EventLoopWorker：

创建时，传入CachedWorkerPool，并从pool中get出threadWorker

@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;
    EventLoopWorker(CachedWorkerPool pool) {
        this.pool = pool;
        this.tasks = new CompositeDisposable();
        this.threadWorker = pool.get();
    }
}

CachedWorkerPool#get():

先从缓存队列中获取，没有则创建新的ThreadWorker

ThreadWorker get() {
    if (allWorkers.isDisposed()) {
        return SHUTDOWN_THREAD_WORKER;
    }
    while (!expiringWorkerQueue.isEmpty()) {
        ThreadWorker threadWorker = expiringWorkerQueue.poll();
        if (threadWorker != null) {
            return threadWorker;
        }
    }
    // No cached worker found, so create a new one.
    ThreadWorker w = new ThreadWorker(threadFactory);
    allWorkers.add(w);
    return w;
}

ThreadWorker：

ThreadWorker(ThreadFactory threadFactory) {
    super(threadFactory);
}
public NewThreadWorker(ThreadFactory threadFactory) {
    executor = SchedulerPoolFactory.create(threadFactory);
}
public static ScheduledExecutorService create(ThreadFactory factory) {
    final ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, factory);
    if (exec instanceof ScheduledThreadPoolExecutor) {
        ScheduledThreadPoolExecutor e = (ScheduledThreadPoolExecutor) exec;
        POOLS.put(e, exec);
    }
    return exec;
}
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue(), threadFactory);
}

最终创建一个核心线程为1，max无限大的线程池。

ThreadWorker#Schedule(task，delay，unit)：

最终走到NewThreadWorker#schedule方法：

@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;
}

最终执行到ObservableSubscribeOn#SubscribeTask#run():

@Override
public void run() {
    source.subscribe(parent);
}

这里的source便是上一级的Observable的实现类ObservableCreate，所以最终会执行ObservableCreate的

subscribeActual方法：

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);
    }
}

这里的observer参数便是SubscribeOnObserver
然后调用SubscribeOnObserver的onSubscribe方法：

@Override
public void onSubscribe(Disposable s) {
    DisposableHelper.setOnce(this.s, s);
}

这里的source是最原始的Observable调用create时的入参

new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        e.onNext(1);
    }
}

所以，到这里subscribe试运行在IoScheduler创建的线程池的那个线程，也就是子线程。
在该方法中调用e.onNext

CreateEmitter#onNext():

从这里开始，observer为订阅时从后面回传的，
所以onNext的顺序为：ObservableEmitter->SubscribeOnObserver->ObserveOnObserver

@Override
public void onNext(T t) {
    。。。
    if (!isDisposed()) {
        observer.onNext(t);
    }
}

ObserveOnObserver#onNext():

@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);
    }
}

最终执行到HandlerWorker的schedule方法

@Override
public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
    if (run == null) throw new NullPointerException("run == null");
    if (unit == null) throw new NullPointerException("unit == null");
    if (disposed) {
        return Disposables.disposed();
    }
    run = RxJavaPlugins.onSchedule(run);
    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.
    handler.sendMessageDelayed(message, Math.max(0L, 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;
}

这里将ScheduledRunnable放入Message，Handler处理消息的时候

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}
private static void handleCallback(Message message) {
    message.callback.run();
}

流程总结：
observable订阅 subscribe为一层一层往上执行。
observer的观察 onNext为一层一层往下执行。