Rxjava(线程类)--observeOn原理

最新推荐文章于 2022-02-19 17:27:09 发布

原创最新推荐文章于 2022-02-19 17:27:09 发布 · 790 阅读

0 ·

CC 4.0 BY-SA版权

RxJava 同时被 2 个专栏收录

50 篇文章

订阅专栏

RxJava系列文章

46 篇文章

订阅专栏

本文详细解析了RxJava中observeOn操作符的工作原理，通过实例代码展示了如何改变观察者所处的线程，揭示了ScalarSynchronousObservable类型的特殊处理流程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实例代码如下：

        Observable.just(1).observeOn(Schedulers.from(JobExecutor.getInstance())).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("<<<<<<subscribe thread id = " + Thread.currentThread().getId());
            }
        });

执行结果：

<<<<<< main threadid = 1
<<<<<<subscribe thread id = 13

这里主要分析observeOn

    public final Observable<T> observeOn(Scheduler scheduler) {
        return observeOn(scheduler, RxRingBuffer.SIZE);
    }

 public final Observable<T> observeOn(Scheduler scheduler, int bufferSize) {
        return observeOn(scheduler, false, bufferSize);
    }

   public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        if (this instanceof ScalarSynchronousObservable) {
            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
        }
        return lift(new OperatorObserveOn<T>(scheduler, delayError, bufferSize));
    }

这里我们是ScalarSynchronousObservable走上面一个分支

 public Observable<T> scalarScheduleOn(final Scheduler scheduler) {
        Func1<Action0, Subscription> onSchedule;
        if (scheduler instanceof EventLoopsScheduler) {
            final EventLoopsScheduler els = (EventLoopsScheduler) scheduler;
            onSchedule = new Func1<Action0, Subscription>() {
                @Override
                public Subscription call(Action0 a) {
                    return els.scheduleDirect(a);
                }
            };
        } else {
            onSchedule = new Func1<Action0, Subscription>() {
                @Override
                public Subscription call(final Action0 a) {
                    final Scheduler.Worker w = scheduler.createWorker();
                    w.schedule(new Action0() {
                        @Override
                        public void call() {
                            try {
                                a.call();
                            } finally {
                                w.unsubscribe();
                            }
                        }
                    });
                    return w;
                }
            };
        }

        return create(new ScalarAsyncOnSubscribe<T>(t, onSchedule));
    }

这里我们的scheduler不是EventLoopsScheduler走else，新建了一个onSchedule并使用他为参数创建了一个ScalarAsyncOnSubscribe

根据我们前面的分析，接下来subscribe的时候会调用ScalarAsyncOnSubscribe的call函数

  @Override
        public void call(Subscriber<? super T> s) {
            s.setProducer(new ScalarAsyncProducer<T>(s, value, onSchedule));
        }

创建了一个ScalarAsyncProducer并调用setProducer，接着会调用到ScalarAsyncProducer的request函数

        public void request(long n) {
            if (n < 0L) {
                throw new IllegalArgumentException("n >= 0 required but it was " + n);
            }
            if (n != 0 && compareAndSet(false, true)) {
                actual.add(onSchedule.call(this));
            }
        }

这里会回调onSchedule的call并把它添加到actual,我们再看一下onSchedule

            onSchedule = new Func1<Action0, Subscription>() {
                @Override
                public Subscription call(final Action0 a) {
                    final Scheduler.Worker w = scheduler.createWorker();
                    w.schedule(new Action0() {
                        @Override
                        public void call() {
                            try {
                                a.call();
                            } finally {
                                w.unsubscribe();
                            }
                        }
                    });
                    return w;
                }
            };

这里会创建一个Worker，这里创建出来的worker会实现Runnable接口，然后调用他的schedule方法，最终会执行Thread的start方法，进而执行run方法，run又最终调用到schedule里面传递的回调函数call，这时也已经运行在新进程了。

   public void call() {
                            try {
                                a.call();
                            } finally {
                                w.unsubscribe();
                            }
                        }

这里的a是ScalarAsyncProducer类型，调用到他的call方法

 public void call() {
            Subscriber<? super T> a = actual;
            if (a.isUnsubscribed()) {
                return;
            }
            T v = value;
            try {
                a.onNext(v);
            } catch (Throwable e) {
                Exceptions.throwOrReport(e, a, v);
                return;
            }
            if (a.isUnsubscribed()) {
                return;
            }
            a.onCompleted();
        }

最终会调用到我们的onNext

从这里也可以看出observerOn作用于该操作符之后。