RxJava之七——RxJava 2.0 图文分析create()、 subscribe()、map()、observeOn()、subscribeOn()源码

前言

16年 的时候写过两篇关于Rxjava 1.0 的源码分析,时过境迁,现在早已是2.0 了。2.0 的代码逻辑,封装,更为易懂,也包含了 一些新特性背压,面向切面等等。所以决定,写篇文章分析RxJava 2.0

关于RxJava,从表面上看起来很容易使用,但是如果理解不够深刻,使用过程中,往往会出现一些问题,所以我写了系列文章,从入门到精通,从简单的使用到部分源码详解,希望能给读者一个质的飞跃:
1、RxJava之一——一次性学会使用RxJava RxJava简单的使用和使用它的好处
2、RxJava之二——Single和Subject 与Observable举足轻重的类,虽然用的少,但应该知道
3、RxJava之三——RxJava 2.0 全部操作符示例
4、RxJava之四—— Lift()详解 想要了解Operators,Lift()一定要学习
5、RxJava之五—— observeOn()与subscribeOn()的详解Scheduler线程切换的原理
6、RxJava之六——RxBus 通过RxJava来替换EventBus
7、RxJava之七——RxJava 2.0 图文分析create()、 subscribe()、map()、observeOn()、subscribeOn()源码 这张图可能是全网最详细 明了的图

Rxjava2.x 与1.x 的相关文章:

关于 RxJava 最友好的文章—— RxJava 2.0 全新来袭
官方文档:What’s different in 2.0
RxJava github

示例

Rxjava的使用流程,相信大家都很清楚了,以下面这个简单的demo,重点分析一下create()、 subscribe()、map()、observeOn()、subscribeOn()源码。 只要了解这些源码,再去看其他的类都会有似曾相识的感觉

        Observable.create(object : ObservableOnSubscribe<Int> {
            override fun subscribe(emitter: ObservableEmitter<Int>) {
                  emitter.onNext(1)
            }})
            .map(object : Function<Int, String> {
                override fun apply(t: Int): String {
                    return t.toString()
                }}
            )
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(object : Observer<String> {
                override fun onComplete() {
                }

                override fun onSubscribe(d: Disposable) {
                }

                override fun onNext(t: String) {
                }

                override fun onError(e: Throwable) {
                }
            })

在看源代码时,被其中一层一层的封装和调用,类名搞的晕晕的,一不留神就不知道谁是谁。
我把源代码的简单流程 ,画了个图,先脑子里有个整体的轮廓,再去看代码,会清晰很多

关于流程图的介绍:

这张图,可能是全网关于rxjava2 大体流程,最详细的图。为了排版和方便理解,简化了函数的关系,忽略了很多细节
在这里插入图片描述

  • 绿色模块 表示订阅者,例如 ObservableFlowable,或者他们的子类

  • 蓝色模块 表示观察者,例如 ObserverSubscriber,或者他们的子类

  • 青色模块 表示数据发送,例如:ObservableOnSubscribeObservableSource,等等

  • 黄色模块 表示切换了线程

  • 每个模块右上角表示当前类的名称

  • 绿色的线 表示函数调用

  • 蓝色的线 表示订阅

  • 红色的线 表示数据发送

  • 黑色的线 表示对象是什么或者对象从哪里来的

基本流程

还是以上面的demo为例,抛开操作符,只分析主要流程

先来看下,demo中都使用哪些类和接口:

  • Observable 订阅者
  • Observer 观察者
  • ObservableOnSubscribe 数据发送源
public interface ObservableOnSubscribe<T> {

    // ObservableEmitter 也是一个接口,它继承接口Emitter
    void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}

//这个接口,有常见的几种函数。在demo中可以看到,调用的oNext 就是这个接口的函数
public interface Emitter<T> {
    void oNext(@NonNull T value);
    void onError(@NonNull Throwable error);
    void onComplete();
}

下面一步一步进入源码:

create

    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
         // 判断非空
        ObjectHelper.requireNonNull(source, "source is null");
        //RxJavaPlugins 相当于是切面编程,会对所有的中间订阅者进行自定义修改,如果没有设置过。就直接当前参数
        //创建一个 ObservableCreate,它就是上图中的绿色模块
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

来看一个RxJavaPlugins.onAssembly

    public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        // onObservableAssembly  需要手动设置,实现切面效果
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        //如果没有设置 就是null,直接返回参数source
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }

create 传入的是ObservableOnSubscribe 类型参数,需要的Observable返回类型,这里的ObservableCreate 继承了Observable 并实现接口subscribeActual,引用了ObservableOnSubscribe 并调用它的接口subscribe,所以它算是一种适配器模式。

public final class ObservableCreate<T> extends Observable<T> {

    // 每个Observable 的实现类,都有一个source,表示的是上游
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

    // subscribe 最终会调用到这里
    // observer 是观察者,它里面实现了onNext、onSubscribe 等 这些函数
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        //调用了观察者的onSubscribe 方法
        observer.onSubscribe(parent);

        try {
            //这个上游source 就是demo中的ObservableOnSubscribe 实现,
            //调用了subscribe,以本例来说,就会执行 emitter.onNext(1)
            // 那么问题来了,subscribeActual 会在什么时候执行呢?
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

subscribe

需要注意,代码执行到这里,是谁调用了subscribe,create() 返回的是Observable类型 ObservableCreate,所以是ObservableCreate调用了subscribe,那么关于Observable的接口,自然也会调用到ObservableCreate

    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            // 面向切面的设置,如果没有设置,直接返回observer
            observer = RxJavaPlugins.onSubscribe(this, observer);

            ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");
            //以本例来看,就是执行ObservableCreate 中的subscribeActual 
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            ... 省略代码 ...
        }
    }
ObservableCreate 类
    // subscribe 最终会调用到这里
    // observer 是观察者,它里面实现了onNext、onSubscribe 等 这些函数
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
         // 把观察者,封装成CreateEmitter
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        //调用了观察者的onSubscribe 方法
        observer.onSubscribe(parent);

        try {
            //这个上游source 就是demo中的ObservableOnSubscribe 实现,
            //调用了subscribe,以本例来说,就会执行 emitter.onNext(1),也就是执行了parent.onNext(1)
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

最后进入CreateEmitter 来看一下:

 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) {
            //demo 中的observer 最终被传递到这里
            this.observer = observer;
        }

       // 在subscribeActual 调用到这里
        @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()) {
                //如果没有disposed ,就会执行demo中observer的onNext
                observer.onNext(t);
            }
        }
          ... 省略代码 ...

        @Override
        public void onComplete() {
            //如果没有被dispose,会调用Observer的onComplete()方法
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {
                    //执行完调用dispose
                    dispose();
                }
            }
        }

       ... 省略代码 ...
    }

源码看到这里,再去看上图,思路应该更清晰,但是应该对整图还不是很了解。

仔细总结一下会发现,在create后,创建了ObservableCreate ,他知道上游(source),知道被订阅后的处理方式(subscribeActual )也就是如何把数据发给下游,但是它需要等待调用subscribe,才会最终触发这个流程。

而且ObservableCreate 是继承于Observable ,对设计模式敏感的小伙伴,可能会想到装饰着模式,没错,所谓的操作符,无非就是用装饰着模式包裹一层,让他也知道上游(source),知道如何数据发给下游(实现subscribeActual ),最终subscribe 一调用,这个过程就被触发。

如果感觉混乱,没关系,下面跟着源码走一下,就会豁然开朗

map操作符

调用map,会执行下面的函数

    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        //发现了吗,上面的create 创建ObservableCreate  , map 创建了 ObservableMap 
        //没错他们都是Observable的子类
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

有了新的Observable (ObservableMap),那肯定得有新的Observer,不然ObservableMap和谁关联呢?是的,新的Observer就是 MapObserver

//AbstractObservableWithUpstream 继承于Observable,有成员变量source
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;

    //这里传入的是this,也就是本例中的ObservableCreate ,它继承于Observable 继承于ObservableSource
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        // 把上游的源保存起来
        super(source);
        //保存当前的操作函数,也就是demo 中map 里实现的函数
        this.function = function;
    }

    // 太熟悉了,又是它,等ObservableMap 调用subscribe 的时候,会调用到这里
    @Override
    public void subscribeActual(Observer<? super U> t) {
       // 调用了上游(source)的subscribe,这就相当于触发了上游
       // 传入的参数是MapObserver,联想到上面的subscribe 直接订阅Observer
       // 这个MapObserver继承Observer,它的参数t 也是Observer,也就是把下游的Observer 包裹了一层,传递给上游。这正是装饰者模式
       // 本例中emitter.onNext(1)执行后,也就是会执行MapObserver中的onNext
        source.subscribe(new MapObserver<T, U>(t, function));
    }

     //BasicFuseableObserver 继承了Observer,有成员变量downstream、upstream 等
    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) {
            // 把下游的Observer 保存在downstream 中
            super(actual);
            // 保存map 变换操作
            this.mapper = mapper;
        }

        // 本例中,onNext 是在emitter.onNext(1) 执行后,调用到这里的
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                downstream.onNext(null);
                return;
            }
			//目标类型
            U v;

            try {
                // 实现了变化操作,把t 转为 v 
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            
            //调用了下游onNext,继续分发数据,此时的数据是转换后的目标数据
            downstream.onNext(v);
        }

        @Override
        public int requestFusion(int mode) {
            return transitiveBoundaryFusion(mode);
        }

        @Nullable
        @Override
        public U poll() throws Exception {
            T t = qd.poll();
            return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
        }
    }
}

此时再去看看上面的图,是不是有点感觉了,没错,全部都是这个套路,只是每次在装饰的时候,行为不一样

subscribeOn操作符

作用是控制subscribe 的线程,下面来看看subscribeOn 是如何实现的

不仔细看代码,还以为作者直接把实现map的代码拷贝了一份,简直太相似了

    public final Observable<T> subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        //使用原来的Observable 和调度线程,创建一个新的Observable,就是ObservableSubscribeOn
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
    }

依旧是创建新的Observable(ObservableSubscribeOn) 和 Observer (SubscribeOnObserver)

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        // 依旧是保存了上游 ObservableSource
        super(source);
        // 保存了线程调度的Scheduler 
        this.scheduler = scheduler;
    }

    @Override
    public void subscribeActual(final Observer<? super T> observer) {
        // 使用装饰着模式,把原来的Observer 封装了一层
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);

		//注意,这里还没有切换新城,调用了onSubscribe
        observer.onSubscribe(parent);
		//这里是重点,
		//scheduler.scheduleDirect(new SubscribeTask(parent))   在新线程中执行parent,
		//parent.setDisposable  把新线程任务,加入到DisposableHelper,如果手动dispose后,保证线程可以停止
        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> downstream;

        final AtomicReference<Disposable> upstream;

        SubscribeOnObserver(Observer<? super T> downstream) {
            this.downstream = downstream;
            this.upstream = new AtomicReference<Disposable>();
        }

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

       // 下面的常规操作方法,就是调用downstream  的各个操作方法
        @Override
        public void onNext(T t) {
            downstream.onNext(t);
        }

        @Override
        public void onError(Throwable t) {
            downstream.onError(t);
        }

        @Override
        public void onComplete() {
            downstream.onComplete();
        }

        @Override
        public void dispose() {
            DisposableHelper.dispose(upstream);
            DisposableHelper.dispose(this);
        }

        @Override
        public boolean isDisposed() {
            return DisposableHelper.isDisposed(get());
        }

        void setDisposable(Disposable d) {
           //把当前
            DisposableHelper.setOnce(this, d);
        }
    }

    // 实现了线程的Runnable 接口,目的是让线程可以调度
    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver<T> parent;

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

        @Override
        public void run() {
            // 会在新的线程中调用,source是上游的Observable
            source.subscribe(parent);
        }
    }
}

截止到这里,subscribeOn总体的逻辑已经,搞清楚了,再深入一点看一下scheduler.scheduleDirect(new SubscribeTask(parent)) 是如何实现线程切换的

    @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run) {
        //调用scheduleDirect,参数表示立即执行
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }

    @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        //创建了一个worker,注意这里的createWorker(),是一个抽象方法,不同的线程,创建的worker 不一样。
        // 例如:Schedulers.io()  创建的是 EventLoopWorker
        final Worker w = createWorker();

        // 依旧是切面编程,对每个切换线程的, 包裹一层
        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
		//把worker 和 Runnable  封装成DisposeTask ,方便外界调用disposed,来停止它的运行
        DisposeTask task = new DisposeTask(decoratedRun, w);
		//立即开始执行
        w.schedule(task, delay, unit);

        return task;
    }

在深入看一下上面的DisposeTask,是如何封装的。

这段代码,我多说一句,你都会嫌我啰嗦

    static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {

        @NonNull
        final Runnable decoratedRun;

        @NonNull
        final Worker w;

        @Nullable
        Thread runner;

        DisposeTask(@NonNull Runnable decoratedRun, @NonNull Worker w) {
            this.decoratedRun = decoratedRun;
            this.w = w;
        }

        @Override
        public void run() {
            runner = Thread.currentThread();
            try {
                decoratedRun.run();
            } finally {
                dispose();
                runner = null;
            }
        }

        @Override
        public void dispose() {
            if (runner == Thread.currentThread() && w instanceof NewThreadWorker) {
                ((NewThreadWorker)w).shutdown();
            } else {
                w.dispose();
            }
        }

        @Override
        public boolean isDisposed() {
            return w.isDisposed();
        }

        @Override
        public Runnable getWrappedRunnable() {
            return this.decoratedRun;
        }
    }

总结:

现在你再结合上图来理解一下,是不是瞬间感觉,WC,这么简单的代码,也有人写博客发布

懂了subscribeOn的源码,那么想想,大家经常讨论的多个subscribeOn 调用,线程切换的问题,两句话。

  1. subscribeOn 对上游订阅有效
  2. 最上面的subscribeOn 对发送数据有效

observeOn操作符

控制 onNextonComplete 等数据消费方法的线程,

下面的分析略有差异,但总体和上面还是一样的,你也可以自行read fuck source code ,相信你的印象会更加深刻

    public final Observable<T> observeOn(Scheduler scheduler) {
        //为什么这里,有bufferSize()
        //这就是Rxjava 2 所添加背压的概念,rxjava 1  会有一个问题,就是如果上游一直发送数据onNext ,拼命的调用,
        // 但是onNext() 处理的不够快,就会出现栈溢出。这个bufferSize 就是控制了,缓冲区的大小
        return observeOn(scheduler, false, bufferSize());
    }

    public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        //重点ObservableObserveOn
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }

创建新的Observable (ObservableObserveOn) 和 Observer(ObserveOnObserver)

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) {
        //保存上游Observable 
        super(source);
        //保存调度线程
        this.scheduler = scheduler;
        //
        this.delayError = delayError;
        //缓冲区
        this.bufferSize = bufferSize;
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        //TrampolineScheduler 官方文档的解释  * Schedules work on the current thread but does not execute immediately. Work is put in a queue and executed after the current unit of work is completed.
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            // 创建一个worker,线程的调度就是在这里
            Scheduler.Worker w = scheduler.createWorker();
			// 因为observeOn 是控制处理数据的线程,所以在订阅的时候,不去切换线程
			// 把线程worker,缓冲区,下游observer  都都封装进ObserveOnObserver ,等到onSubscribe,onNext 调用到来是,在去切换线程去处理
            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
        }
    }
    
     ...   省略 ObserveOnObserver 代码 ...
}

上面关于 TrampolineScheduler 可以查看这篇文章

下面来看一下 ObserveOnObserver

    static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
    implements Observer<T>, Runnable {

        private static final long serialVersionUID = 6576896619930983584L;
        final Observer<? super T> downstream;
        final Scheduler.Worker worker;
        final boolean delayError;
        final int bufferSize;

        SimpleQueue<T> queue;

        Disposable upstream;

        Throwable error;
        volatile boolean done;

        volatile boolean disposed;

        int sourceMode;

        boolean outputFused;

        ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.downstream = actual;
            this.worker = worker;
            this.delayError = delayError;
            this.bufferSize = bufferSize;
        }


        @Override
        public void onSubscribe(Disposable d) {
            if (DisposableHelper.validate(this.upstream, d)) {
                this.upstream = d;
				// 上游的Observer 被封装成了QueueDisposable,那么使用这里面的sourceMode ,queue  等信息
                if (d instanceof QueueDisposable) {
                    @SuppressWarnings("unchecked")
                    QueueDisposable<T> qd = (QueueDisposable<T>) d;

                    int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);

                    if (m == QueueDisposable.SYNC) {
                        sourceMode = m;
                        queue = qd;
                        done = true;
                        downstream.onSubscribe(this);
                        schedule();
                        return;
                    }
                    if (m == QueueDisposable.ASYNC) {
                        sourceMode = m;
                        queue = qd;
                        downstream.onSubscribe(this);
                        return;
                    }
                }
				//大多数情况会到这里创建一个队列,使用指定的缓冲区
                queue = new SpscLinkedArrayQueue<T>(bufferSize);

                downstream.onSubscribe(this);
            }
        }

        @Override
        public void onNext(T t) {
            //执行过error / complete 会是true
            if (done) {
                return;
            }
			//如果不是异步的,就把数据放到队列中
            if (sourceMode != QueueDisposable.ASYNC) {
                queue.offer(t);
            }
            //开始执行
            schedule();
        }

        @Override
        public void onError(Throwable t) {
            if (done) {
                RxJavaPlugins.onError(t);
                return;
            }
            error = t;
            done = true;
            schedule();
        }

        @Override
        public void onComplete() {
            if (done) {
                return;
            }
            done = true;
            schedule();
        }

        @Override
        public void dispose() {
            if (!disposed) {
                // 结束运行
                disposed = true;
                upstream.dispose();
                worker.dispose();
                if (getAndIncrement() == 0) {
                    queue.clear();
                }
            }
        }

        @Override
        public boolean isDisposed() {
            return disposed;
        }

        void schedule() {
            //该类继承了,AtomicInteger,多线程下保证worker值开启一个线程
            //有可能调用onNext 是在不同的线程
            if (getAndIncrement() == 0) {
                // this 是一个Runable 接口,在新线程中执行
                worker.schedule(this);
            }
        }

        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();
                    } catch (Throwable ex) {
                        Exceptions.throwIfFatal(ex);
                        disposed = true;
                        upstream.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 (disposed) {
                    return;
                }

                boolean d = done;
                Throwable ex = error;

                if (!delayError && d && ex != null) {
                    disposed = true;
                    downstream.onError(error);
                    worker.dispose();
                    return;
                }

                downstream.onNext(null);

                if (d) {
                    disposed = true;
                    ex = error;
                    if (ex != null) {
                        downstream.onError(ex);
                    } else {
                        downstream.onComplete();
                    }
                    worker.dispose();
                    return;
                }

                missed = addAndGet(-missed);
                if (missed == 0) {
                    break;
                }
            }
        }

		//上面work.schedule(this) 后,会执行这里
        @Override
        public void run() {
            if (outputFused) {
                //这里是有关背压的,暂时先不讲解
                drainFused();
            } else {
                drainNormal();
            }
        }

        boolean checkTerminated(boolean d, boolean empty, Observer<? super T> a) {
            if (disposed) {
                queue.clear();
                return true;
            }
            // 是否已经完成
            if (d) {
                Throwable e = error;
                //是否分发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 int requestFusion(int mode) {
           // 这部分也与背压有关,暂时不展开
            if ((mode & ASYNC) != 0) {
                outputFused = true;
                return ASYNC;
            }
            return NONE;
        }

        @Nullable
        @Override
        public T poll() throws Exception {
            return queue.poll();
        }

        @Override
        public void clear() {
            queue.clear();
        }

        @Override
        public boolean isEmpty() {
            return queue.isEmpty();
        }
    }
}

总结:

到这里应该对observeOn 也一定的了解,多个observeOn 嵌套的问题,一句话,只对下游的Observer有效。再结合上图的流程,subscribeOn 和 observeOn 胡乱嵌套,都能理清楚了。

展开阅读全文
©️2020 CSDN 皮肤主题: 撸撸猫 设计师: 设计师小姐姐 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值