Android RxJava2.0 源码解析

Android RxJava2.0 源码解析

导入包版本信息

implementation 'io.reactivex.rxjava2:rxjava:2.x.y'

因为Android相关的线程调度需要用到Android包，所以导入R小Android包

implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

RxJava 操作符分类以及作用，分别有哪些类型图

RxJava解析实例代码，下面会按照这个示例代码进行讲解。

        Observable.just(1,2,3,4,5)
                .map(new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(@NonNull Integer integer) throws Exception {
                        Log.e(TAG,"apply integer = " + integer);
                        return integer * 10;
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        Log.e(TAG,"onSubscribe");
                    }
                    @Override
                    public void onNext(@NonNull Integer integer) {
                        Log.e(TAG,"onNext integer = " + integer);
                    }
                    @Override
                    public void onError(@NonNull Throwable e) {
                        Log.e(TAG,"onError e = " + e.getMessage());
                    }
                    @Override
                    public void onComplete() {
                        Log.e(TAG,"onComplete");
                    }
                });

示例代码的执行结果

2022-04-21 15:07:18.044 26568-26568/com.lifeon.watch E/TestDemo: onSubscribe
2022-04-21 15:07:18.058 26568-26655/com.lifeon.watch E/TestDemo: apply integer = 1
2022-04-21 15:07:18.060 26568-26655/com.lifeon.watch E/TestDemo: apply integer = 2
2022-04-21 15:07:18.061 26568-26655/com.lifeon.watch E/TestDemo: apply integer = 3
2022-04-21 15:07:18.061 26568-26655/com.lifeon.watch E/TestDemo: apply integer = 4
2022-04-21 15:07:18.061 26568-26655/com.lifeon.watch E/TestDemo: apply integer = 5
2022-04-21 15:07:18.278 26568-26568/com.lifeon.watch E/TestDemo: onNext integer = 10
2022-04-21 15:07:18.278 26568-26568/com.lifeon.watch E/TestDemo: onNext integer = 20
2022-04-21 15:07:18.278 26568-26568/com.lifeon.watch E/TestDemo: onNext integer = 30
2022-04-21 15:07:18.278 26568-26568/com.lifeon.watch E/TestDemo: onNext integer = 40
2022-04-21 15:07:18.278 26568-26568/com.lifeon.watch E/TestDemo: onNext integer = 50
2022-04-21 15:07:18.279 26568-26568/com.lifeon.watch E/TestDemo: onComplete

Observable 属于可被观察的对象
Observer 属于观察者的对象
通过subscribe进行订阅处理

Observable.just(1,2,3,4,5)

开始进行解析，因为我传入的参数是5个 所以直接进入到5个参数的方法中，最多只能传10个这样的参数

Observable #just(T item1, T item2, T item3, T item4, T item5)

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5) {
        ObjectHelper.requireNonNull(item1, "The first item is null"); // 判断参数是否是空 空直接抛出异常处理
        ObjectHelper.requireNonNull(item2, "The second item is null");
        ObjectHelper.requireNonNull(item3, "The third item is null");
        ObjectHelper.requireNonNull(item4, "The fourth item is null");
        ObjectHelper.requireNonNull(item5, "The fifth item is null");
        return fromArray(item1, item2, item3, item4, item5);
    }

ObjectHelper # requireNonNull() // 判空处理 null 抛出空指针异常

    public static <T> T requireNonNull(T object, String message) {
        if (object == null) {
            throw new NullPointerException(message);
        }
        return object;
    }

Observable # fromArray()

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> fromArray(T... items) {
        ObjectHelper.requireNonNull(items, "items is null");
        if (items.length == 0) { 
            return empty(); // 创建一个空对象 new ObservableEmpty()
        } else
        if (items.length == 1) { // 如果数据只有一个
            return just(items[0]); // 开始执行just(item) // 一个参数的代码
        }
        return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
    }

Observable # just(T item)

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> just(T item) {
        ObjectHelper.requireNonNull(item, "The item is null");
        return RxJavaPlugins.onAssembly(new ObservableJust<T>(item)); // 实例化一个ObservableJust对象将item传入
    }

RxJavaPlugins # onAssembly(); Hook方法的调用

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

onObservableAssembly值只有这一个地方进行赋值，我们没有调用过 所以这里直接返回source

    public static void setOnObservableAssembly(@Nullable Function<? super Observable, ? extends Observable> onObservableAssembly) {
        if (lockdown) {
            throw new IllegalStateException("Plugins can't be changed anymore");
        }
        RxJavaPlugins.onObservableAssembly = onObservableAssembly;
    }

上面的代码最终执行到这里new ObservableFromArray(items);
并返回ObservableFromArray() 的对象

.map(new Function<Integer, Integer>()) // 变换操作符

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        // 这里的this 代表的是上一个Observable对象 即ObservableFromArray
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

上面的代码最终执行到这里new ObservableMap<T, R>(this, mapper)
并返回ObservableMap<Integer，Integer>() 的对象

.subscribeOn(Schedulers.io()) // 线程间打调度

Schedulers.io()

    @NonNull
    public static Scheduler io() {
        return RxJavaPlugins.onIoScheduler(IO);
    }

Schedulers

    static {
        SINGLE = RxJavaPlugins.initSingleScheduler(new SingleTask()); 

        COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());

        IO = RxJavaPlugins.initIoScheduler(new IOTask()); 

        TRAMPOLINE = TrampolineScheduler.instance();

        NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
    }

主要看io()相关，创建了一个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();
    }

IoScheduler # IoScheduler()

    public IoScheduler() {
        this(WORKER_THREAD_FACTORY);
    }
    static {
        SHUTDOWN_THREAD_WORKER = new ThreadWorker(new RxThreadFactory("RxCachedThreadSchedulerShutdown"));
        SHUTDOWN_THREAD_WORKER.dispose();
    	// 获取线程优先级 = 5
        int priority = Math.max(Thread.MIN_PRIORITY, Math.min(Thread.MAX_PRIORITY,
                Integer.getInteger(KEY_IO_PRIORITY, Thread.NORM_PRIORITY)));
	    // 创建Rx线程工厂 名称为 WORKER_THREAD_NAME_PREFIX = RxCachedThreadScheduler
	    WORKER_THREAD_FACTORY = new RxThreadFactory(WORKER_THREAD_NAME_PREFIX, priority);
	    
        EVICTOR_THREAD_FACTORY = new RxThreadFactory(EVICTOR_THREAD_NAME_PREFIX, priority);
        
        NONE = new CachedWorkerPool(0, null, WORKER_THREAD_FACTORY);
        NONE.shutdown();
    }
    public IoScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
        this.pool = new AtomicReference<CachedWorkerPool>(NONE); // 原子引用 缓存工作线程池
        start(); // 初始化线程池
    }
    @Override
    public void start() {
    	// KEEP_ALIVE_TIME = 60 KEEP_ALIVE_UNIT = SECOND
        CachedWorkerPool update = new CachedWorkerPool(KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT, threadFactory);
        if (!pool.compareAndSet(NONE, update)) { // 原子操作，对比之前是否是NONE 是 开始更新将数据替换为update
            update.shutdown(); // 将线程池里面所有的线程停止
        }
    }

RxThreadFactory

    public RxThreadFactory(String prefix, int priority) {
        this(prefix, priority, false);
    }
    public RxThreadFactory(String prefix, int priority, boolean nonBlocking) {
        this.prefix = prefix;
        this.priority = priority; // 5
        this.nonBlocking = nonBlocking; // 设置为false
    }

IoScheduler # CachedWorkerPool

        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) { // 时间单位设置不为null时
            	// 创建线程池 核心数为 1 最大线程数为 Integer.Max_Value 线程名称为 RxCachedWorkerPoolEvictor 拒绝策略为 抛出异常
                evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
                task = evictor.scheduleWithFixedDelay(this, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS);
            }
            evictorService = evictor;
            evictorTask = task;
        }

.subscribeOn() // 线程间的调度

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable<T> subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        // 这里的this 代表的是上一个Observable对象 即ObservableMap
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
    }

上面的代码最终执行到这里new ObservableSubscribeOn(this, scheduler)
并返回ObservableSubscribeOn() 的对象

.observeOn(AndroidSchedulers.mainThread()) // 线程间的调度

AndroidSchedulers.mainThread()

    public static Scheduler mainThread() {
        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
    }
   
    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 {
    	// 直接传入主线程的Handler
        static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));
    }

HandlerScheduler 初始化

    HandlerScheduler(Handler handler) {
        this.handler = handler; // 创建在主线程中的Handler
    }

.observeOn() // 线程间的调度

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable<T> observeOn(Scheduler scheduler) {
        return observeOn(scheduler, false, bufferSize());
    }

Observable # bufferSize()

    public static int bufferSize() {
        return Flowable.bufferSize();
    }

Flowable # bufferSize() 返回为BUFFER_SIZE = 128

    static final int BUFFER_SIZE;
    static {
        BUFFER_SIZE = Math.max(1, Integer.getInteger("rx2.buffer-size", 128));
        // 可以看到，原来 Flowable 缓存池的最大值是 128，如果缓存池里由超过 128 个事件就会抛出异常提示你去处理这些事件。
    }
    public static int bufferSize() {
        return BUFFER_SIZE;
    }

Observable # 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 代表的是上一个Observable对象 即ObservableSubscribeOn
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }

上面的代码最终执行到这里new ObservableObserveOn(this, scheduler, delayError, bufferSize)
并返回ObservableObserveOn() 的对象。
下面的代码就要开始订阅了我们先梳理一下上面的代码流程
Observable -> ObservableFromArray -> ObservableMap -> ObservableSubscribeOn -> ObservableObserveOn,目前Observable的this是ObservableObserveOn对象。

.subscribe(new Observer()); 开始订阅

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null"); // 观察者判空处理
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);// hook方法调用
            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
            subscribeActual(observer); // 真正开始订阅被观察者
        } catch (NullPointerException e) { // 空指针异常
            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;
        }
    }

RxJavaPlugins.onSubscribe(this, observer); // Hook方法调用

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

onObservableSubscribe 只有这一个地方进行赋值操作 之前未做调用 直接返回初始化observer

    public static void setOnObservableSubscribe(
            @Nullable BiFunction<? super Observable, ? super Observer, ? extends Observer> onObservableSubscribe) {
        if (lockdown) {
            throw new IllegalStateException("Plugins can't be changed anymore");
        }
        RxJavaPlugins.onObservableSubscribe = onObservableSubscribe;
    }

subscribeActual(observer); Observable # subscribeActual();

    protected abstract void subscribeActual(Observer<? super T> observer);

可以知道这个是一个抽象方法，需要到子类里面去实现，而这个执行方法也可以写成

this.subscribeActual(Observer<? super T> observer);

之前我们说过这个this代表的是ObservableObserveOn类的对象，现在执行肯定也是去这个类去查看源代码。

ObservableObserveOn # subscribeActual()

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
    	// schedule = AndroidSchedulers.mainThread()
        if (scheduler instanceof TrampolineScheduler) { // 判断当前Scheduler是否是这个类 即 Schedulers.trampoline()
            source.subscribe(observer); 
        } else {
        	// 由上面的代码解析 AndroidSchedulers.mainThread() 可以知道 这个Scheduler 是 HandlerScheduler
            Scheduler.Worker w = scheduler.createWorker(); // 所有实现类在 HandlerScheduler
			// 开始执行subscribe方法 worker这里没有做任何的事情，并封装到ObserveOnObserver对象中 向上游传递过去
            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
        }
    }

HandlerScheduler # createWorker()

    @Override
    public Worker createWorker() {
        return new HandlerWorker(handler);
    }

HandlerScheduler # HandlerWorker的构造方法

        HandlerWorker(Handler handler) {
            this.handler = handler;
        }

source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize)); 向上执行订阅

这里将之前new Observer打包成ObserveOnObserver对象

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

实现这个方法的类为：

看实现的代码我们目前使用的Observable类对象，所以执行到Observable的方法中

Observable # subscribe(Observer<? super T> observer)

上面有进行解析，这里就不再复制源代码了，现在我们捋一捋，Observable和observer的情况
Observable ：
Observable -> ObservableFromArray -> ObservableMap -> ObservableSubscribeOn -> ObservableObserveOn(已被执行)
Observable -> ObservableFromArray -> ObservableMap -> ObservableSubscribeOn(执行到这)
Observer ：
Observer -> ObserveOnObserver
由此可知目前开始执行ObservableSubscribeOn中的subscribeActual方法

ObservableSubscribeOn # subscribeActual() // 传入 ObserveOnObserver对象

    @Override
    public void subscribeActual(final Observer<? super T> s) {
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
		// 根据代码开始执行onSubscribe 向下游开始分发
        s.onSubscribe(parent);
		// 将往上游的代码在子线程scheduler中进行执行
		// new SubscribeTask(parent)实例化Runnable对象
		// scheduler.scheduleDirect(Runnable) 将Runnable对象添加到pool线程池中，等待线程调度，开始执行run方法
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

s.onSubscribe(parent);这里的 s = ObserveOnObserver

ObservableObserveOn # ObserveOnObserver # onSubscribe(parent);

        @Override
        public void onSubscribe(Disposable s) { // this.s = null s = SubscribeOnObserver对象实例
            if (DisposableHelper.validate(this.s, s)) { // 这里会返回true 进入到if语句中 由于this.s已经进行了赋值操作 下一次返回false 这个方法只会执行一次
                this.s = s;
                // SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable 
                if (s instanceof QueueDisposable) { // 非队列类型的Disposable
                    @SuppressWarnings("unchecked")
                    QueueDisposable<T> qd = (QueueDisposable<T>) s;
                    int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);
                    if (m == QueueDisposable.SYNC) { // 同步处理
                        sourceMode = m;
                        queue = qd;
                        done = true;
                        actual.onSubscribe(this);
                        schedule();
                        return;
                    }
                    if (m == QueueDisposable.ASYNC) { // 异步处理
                        sourceMode = m;
                        queue = qd;
                        actual.onSubscribe(this);
                        return;
                    }
                }
                queue = new SpscLinkedArrayQueue<T>(bufferSize); // buffersize = 128
                actual.onSubscribe(this); // 开始向下执行onSubscribe方法
            }
        }

DisposableHelper.validate(this.s, s) 验证current是否为null，next是否为not null，否则会向RxJavaPlugins发送错误信号并返回false。

	// 因为current之前没有进行赋值操作 所以这里 current = null 整体返回true
    public static boolean validate(Disposable current, Disposable next) {
        if (next == null) { // next == null 抛出空指针异常
            RxJavaPlugins.onError(new NullPointerException("next is null"));
            return false;
        }
        if (current != null) { // current ！= null 返回false
            next.dispose(); // 开始执行next.dispose方法 判断之前是否有进行执行，已经执行则不管 未执行就进行执行
            reportDisposableSet();
            return false;
        }
        return true;
    }

actual.onSubscribe(this); 这里的actual = Observer 示例里面订阅创建的，执行到onSubscribe开始打印log

                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        Log.e(TAG,"onSubscribe");
                    }

parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));

new SubscribeTask(parent) 创建SubscribeTask任务，并将SubscribeOnObserver对象作为参数传递

    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver<T> parent;

        SubscribeTask(SubscribeOnObserver<T> parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            source.subscribe(parent); // 运行开始向上游执行subscribe的方法
        }
    }

scheduler.scheduleDirect() scheduler = IoScheduler

    @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run) {
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS); // 传入SubscribeTask 0 纳秒
    }

    @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        final Worker w = createWorker(); // 创建工作线程 EventLoopWorker

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run); // Hook方法调用

        DisposeTask task = new DisposeTask(decoratedRun, w); // 实例化DisposeTask实例

        w.schedule(task, delay, unit); // w == EventLoopWorker 对象 开始执行对应对象内的schedule方法

        return task;
    }

createWorker() ------> IoScheduler # createWorker()

    @NonNull
    @Override
    public Worker createWorker() {
        return new EventLoopWorker(pool.get()); // 实例化对象
    }

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(); // 从预期工作队列中拿取ThreadWorker对象，没有就创建一个
        }

        @Override
        public void dispose() {
            if (once.compareAndSet(false, true)) {
                tasks.dispose();

                // releasing the pool should be the last action
                pool.release(threadWorker);
            }
        }

        @Override
        public boolean isDisposed() {
            return once.get();
        }
		// w.schedule(task, delay, unit);调用 开始执行
        @NonNull
        @Override
        public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
            if (tasks.isDisposed()) { // 判断是否已经执行，没有执行则返回false 已经执行就不需要执行了
                // don't schedule, we are unsubscribed
                return EmptyDisposable.INSTANCE; // 不将任务action添加到线程池中
            }
            return threadWorker.scheduleActual(action, delayTime, unit, tasks); // 添加到线程池
        }
    }

threadWorker.scheduleActual(action, delayTime, unit, tasks);

action = ShedulerTask
delayTime = 0L
unit = 纳秒
tasks = CompositeDisposable实例对象

    @NonNull
    public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
		// this.actual = actual; actual = decoratedRun 实例化ScheduleRunnable对象
        ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent); 
        if (parent != null) {
            if (!parent.add(sr)) { // 判断之前是否有执行过dispose 未执行 则 返回 true -> !true
                return sr;
            }
        }
        Future<?> f;
        try {
            if (delayTime <= 0) { // delayTime == 0
                f = executor.submit((Callable<Object>)sr); // 将Runnable实例对方添加到线程池中 等待线程调度 开始 执行run方法
            } else {
                f = executor.schedule((Callable<Object>)sr, delayTime, unit); // 将Runnable添加到线程池 延迟执行时间 延迟执行时间单位
            }
            sr.setFuture(f); // 将执行的结果放入到scheduleRunnable对象
        } catch (RejectedExecutionException ex) {
            if (parent != null) {
                parent.remove(sr);
            }
            RxJavaPlugins.onError(ex);
        }
        return sr;
    }

parent.add()

    @Override
    public boolean add(@NonNull Disposable d) {
        ObjectHelper.requireNonNull(d, "d is null");
        if (!disposed) { // 最初 disposed = false
            synchronized (this) {
                if (!disposed) {
                    OpenHashSet<Disposable> set = resources;
                    if (set == null) {
                        set = new OpenHashSet<Disposable>();
                        resources = set;
                    }
                    set.add(d); // 将数据添加到set集合中
                    return true;
                }
            }
        }
        d.dispose();
        return false;
    }

等到线程调度，开始执行run方法时，先进行执行ScheduledRunnable类的run方法

    @Override
    public void run() {
        lazySet(THREAD_INDEX, Thread.currentThread());
        try {
            try {
                actual.run(); // 开始执行Runnable的run方法 actual = SubscribeTask实例对象
            } catch (Throwable e) {
                // Exceptions.throwIfFatal(e); nowhere to go
                RxJavaPlugins.onError(e);
            }
        } finally {
            lazySet(THREAD_INDEX, null);
            Object o = get(PARENT_INDEX);
            if (o != PARENT_DISPOSED && compareAndSet(PARENT_INDEX, o, DONE) && o != null) {
                ((DisposableContainer)o).delete(this);
            }

            for (;;) {
                o = get(FUTURE_INDEX);
                if (o == SYNC_DISPOSED || o == ASYNC_DISPOSED || compareAndSet(FUTURE_INDEX, o, DONE)) {
                    break;
                }
            }
        }
    }

执行到 ObservableSubscribeOn # SubscribeTask中的source.subscribe(parent);方法 subscribe(parent);在线程池中进行执行
source.subscribe(parent);
–>ObservableSource # subscribe(parent);
–> Observable # subscribe(parent);
–> subscribeActual(observer);

Observable ：
Observable -> ObservableFromArray -> ObservableMap -> ObservableSubscribeOn(已被执行) -> ObservableObserveOn(已被执行)
Observable -> ObservableFromArray -> ObservableMap (执行到这)
Observer ：
Observer -> ObserveOnObserver -> SubscribeOnObserver

执行到 ObservableMap # subscribeActual(observer);方法

    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }

ObservableMap直接开始调用subscribe方法，向上游进行执行
source.subscribe(new MapObserver<T, U>(t, function));
–>ObservableSource # subscribe();
–> Observable # subscribe();
–> subscribeActual(observer);

Observable ：
Observable->ObservableFromArray->ObservableMap(已执行)->ObservableSubscribeOn(已执行)->ObservableObserveOn(已执行)
Observable -> ObservableFromArray(执行到这)
Observer ：
Observer -> ObserveOnObserver -> SubscribeOnObserver -> MapObserver

ObservableFromArray # subscribeActual(observer);方法

    @Override
    public void subscribeActual(Observer<? super T> s) {
        FromArrayDisposable<T> d = new FromArrayDisposable<T>(s, array); // 创建FromArrayDisposable对象
        s.onSubscribe(d); // 开始分发onSubscribe方法 会去执行MapObserver的 onSubscribe 方法
        if (d.fusionMode) { // 未进行赋值 返回为false
            return;
        }
        d.run(); // 开始进行分发数据信息
    }

s.onSubscribe(d); // 开始分发onSubscribe方法 会去执行MapObserver的 onSubscribe 方法

MapObserver并未重写父类BasicFuseableObserver的onSubscribe方法，所以在父类中进行执行

BasicFuseableObserver # onSubscribe()

    @Override
    public final void onSubscribe(Disposable s) { // s = FromArrayDisposable
        if (DisposableHelper.validate(this.s, s)) { // 因为之前没有被执行过 所以this.s = null 最终返回true
            this.s = s; // 设置数据 第二次执行 返回为false 不能进入
            if (s instanceof QueueDisposable) { // FromArrayDisposable 不是 QueueDisposable 类型的对象
                this.qs = (QueueDisposable<T>)s;
            }
            if (beforeDownstream()) {  // 一直返回true
                actual.onSubscribe(this); // 开始向下分发
                afterDownstream(); // 子类未重写父类的方法 父类方法为null 未做任何事
            }
        }
    }

BasicFuseableObserver # beforeDownstream()

    protected boolean beforeDownstream() { // 一直返回true
        return true;
    }

BasicFuseableObserver # afterDownstream()

    protected void afterDownstream() {
        // default no-op
    }

actual.onSubscribe(this); // 开始向下分发

actual = SubscribeOnObserver ，开始执行SubscribeOnObserver onSubscribe(this);方法

ObservableSubscribeOn # SubscribeOnObserver # onSubscribe()

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

DisposableHelper # setOnce(this.s, s) this.s = SubscribeOnObserver s = MapObserver

    public static boolean setOnce(AtomicReference<Disposable> field, Disposable d) {
        ObjectHelper.requireNonNull(d, "d is null"); // 判断MapObserver是否为null
        if (!field.compareAndSet(null, d)) {  // !true = false进当前判断
        // SubscribeOnObserver进行原子引用操作 默认之前为null值，执行到赋值时依旧还是空值，直接将MapObserver类型对象进行设置 
        // 设置成功 则返回true 设置失败 或者 不是期望值null 返回false 因为这个地方没有进行设置过
        // 这里field = SubscribeOnObserver里面value为null 所以返回 true
            d.dispose();
            if (field.get() != DISPOSED) { // 这里返回 false
                reportDisposableSet(); // 记录一次报告
            }
            return false;
        }
        return true;
    }

d.dispose(); d = MapObserver

因为MapObserver没有重写父类dispose()方法，所在父类进行执行

    @Override
    public void dispose() { // 这里的 s = FromArrayDisposable
        s.dispose(); // 将 FromArrayDisposable中的value设置为true 表示已经执行了当前方法
    }

s.dispose(); -》 FromArrayDisposable .dispose()方法

        @Override
        public void dispose() { // 改变disposed状态
            disposed = true;
        }

if (field.get() != DISPOSED) // 判断field的状态是否为DISPOSED field = SubscribeOnObserver

Observable # subscribeActual # d.run(); FromArrayDisposable

        void run() {
            T[] a = array; // {1,2,3,4,5}
            int n = a.length;

            for (int i = 0; i < n && !isDisposed(); i++) { // 判断disposed是否为false
                T value = a[i];
                if (value == null) {
                    actual.onError(new NullPointerException("The " + i + "th element is null"));
                    return;
                }
                actual.onNext(value); // 开始执行Observer # onNext()方法 向下进行分发
            }
            if (!isDisposed()) {
                actual.onComplete();
            }
        }

actual = MapObserver ； MapObserver # onNext();

        @Override
        public void onNext(T t) {
            if (done) { // done = false
                return;
            }

            if (sourceMode != NONE) { // != NONE 有value
                actual.onNext(null);
                return;
            }

            U v;

            try {
            	// mapper.apply(t),开始执行我们使用map操作符中Function的apply方法，并返回value值 v 判空处理
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            actual.onNext(v); // 开始向下进行分发
        }

actual = SubscribeOnObserver ； SubscribeOnObserver # onNext();

        @Override
        public void onNext(T t) {
            actual.onNext(t); // 直接往下发，未做任何操作
        }

actual = ObserveOnObserver ； ObserveOnObserver # onNext();

        @Override
        public void onNext(T t) {
            if (done) { // false
                return;
            }
            if (sourceMode != QueueDisposable.ASYNC) { // 由于上面的代码可以知道 sourceMode=0 ASYNC = 2 执行offer
                queue.offer(t); // 将t = Integer写入到队列中
            }
            schedule();
        }

ObserveOnObserver # schedule();

        void schedule() {
            if (getAndIncrement() == 0) { 
                worker.schedule(this); // worker = HandlerWorker 将Runnable对象放入到主线程Handler中，等待Handler调用进行分发
            }
        }

Scheduler # schedule()

        @NonNull
        public Disposable schedule(@NonNull Runnable run) {
            return schedule(run, 0L, TimeUnit.NANOSECONDS);
        }

HandlerScheduler # 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); // 去消息池里面拿取msg对象 msg复用
            message.obj = this; // Used as token for batch disposal of this worker's runnables.

            handler.sendMessageDelayed(message, unit.toMillis(delay)); // 给主线程Handler发送一条消息

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

等待Handler，直接执行run方法

ObservableObserveOn # ObserveOnObserver # run()

        @Override
        public void run() {
            if (outputFused) { // false
                drainFused();
            } else {
                drainNormal();
            }
        }

ObservableObserveOn # ObserveOnObserver # drainNormal();

        void drainNormal() {
            int missed = 1;

            final SimpleQueue<T> q = queue; // 拿到存放数据的队列
            final Observer<? super T> a = actual; // 拿到下一个订阅者

            for (;;) { // 循环
                if (checkTerminated(done, q.isEmpty(), a)) { // 检查是否终止 done如果为true 队列为null  
                    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; // 是否为null
                    if (checkTerminated(d, empty, a)) { // 检查是否终止 会等onComplete分发 done为true时 执行onComplete
                        return;
                    }
                    if (empty) { // 空，跳出当前循环
                        break;
                    }
                    a.onNext(v); // 开始向下进行分发 a = new Observer的内部类，会执行打印信息
                }
                missed = addAndGet(-missed); // missed = 0
                if (missed == 0) { // 退出循环
                    break;
                }
            }
        }

执行到new Observer # onNext()方法

					public void onNext(@NonNull Integer integer) {
                        Log.e(TAG,"onNext integer = " + integer);
                    }

onComplete跟随onNext一直分发到ObserveOnObserver中，等到onComplete执行之后将done = true；循环执行队列，就会开始执行onComplete向下进行分发，下面的分发就是我们代码中new Observer对象接口的执行 开始打印log，以上整个流程跑完。

下面是一张代码流程图