RxJava3.1.3-源码阅读

华仔学习
494 阅读15分钟

1.简单的例子

最简单的例子，麻雀虽小但五脏俱全。

TextView tv = findViewById(R.id.textView);
Single<String> single = Single.just("1");
single.subscribe(new SingleObserver<String>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onSuccess(@NonNull String s) {
        tv.setText(s);
    }

    @Override
    public void onError(@NonNull Throwable e) {

    }
});

当single加入订阅时，会先后触发onSubscribe方法和onSuccess方法。由于SingleJust是瞬时完成，没有延迟，也没有后续的。效果如下： Screenshot_20230523_133146.png

1.1 源码阅读

例子简单两三行，很好理解。现在进入源码康康吧

1.1.1 just方法

public static <@NonNull T> Single<T> just(T item) {
    Objects.requireNonNull(item, "item is null");
    // 这个调用的是个钩子方法，咱们只需要管里面实例的对象即可
    return RxJavaPlugins.onAssembly(new SingleJust<>(item));
}

public final class SingleJust<T> extends Single<T> {

    final T value;

    public SingleJust(T value) {
        this.value = value;
    }

    @Override
    protected void subscribeActual(SingleObserver<? super T> observer) {
        observer.onSubscribe(Disposable.disposed());
        observer.onSuccess(value);
    }

}

昂，这个类就一个subsribeActual方法啊？！，在方法体中直接调用了onSubscribe方法和onSuccess方法。看到这，只需要对subscribeActual留住印象即可。那just方法就到这了。 接下去看subscribe方法。

1.1.2 subscribe方法

public final void subscribe(@NonNull SingleObserver<? super T> observer) {
    Objects.requireNonNull(observer, "observer is null");

    observer = RxJavaPlugins.onSubscribe(this, observer);

    Objects.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null SingleObserver. Please check the handler provided to RxJavaPlugins.setOnSingleSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

    try {
        // 关键代码
        subscribeActual(observer);
    } catch (NullPointerException ex) {
        throw ex;
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        NullPointerException npe = new NullPointerException("subscribeActual failed");
        npe.initCause(ex);
        throw npe;
    }
}

这个方法刚开始就做判断，直到调用subscribeActual方法。

protected abstract void subscribeActual(@NonNull SingleObserver<? super T> observer);

看到subscribeActual方法时，就想起了刚才的那个SingleJust。

@Override
protected void subscribeActual(SingleObserver<? super T> observer) {
    observer.onSubscribe(Disposable.disposed());
    observer.onSuccess(value);
}

小结：整个流程就通了。在just方法中实例化了一个SingleJust对象，在subscribe方法中把observer传进方法中调用subscribeActual方法，最后直接调用了observer的onSubscribe方法和onSuccess方法。

这边使用扔物线大佬的图片。让大家更好理解

image.png

2.Single.Map()

我们把最初的例子改一改，改成下面这个样子

Single<String> single = Single.just("1");
Single<Integer> single1 = single.map(new Function<String, Integer>() {
    @Override
    public Integer apply(String s) throws Throwable {
        return Integer.parseInt(s) + 3;
    }
});
single1.subscribe(new SingleObserver<Integer>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onSuccess(@NonNull Integer s) {
        tv.setText(s.toString());
    }

    @Override
    public void onError(@NonNull Throwable e) {

    }
});

较于最初的例子，只是新弄出了一个map对象。然后给map添加了订阅，最后却能从singleJust中拿到值。来康康源码 4.png

2.1 map源码

just就不看了，直接撸map的源码。

public final <@NonNull R> Single<R> map(@NonNull Function<? super T, ? extends R> mapper) {
    Objects.requireNonNull(mapper, "mapper is null");
    return RxJavaPlugins.onAssembly(new SingleMap<>(this, mapper));
}

和看just一样，咱们只关注里面的实例类。

public final class SingleMap<T, R> extends Single<R> {
    final SingleSource<? extends T> source;

    final Function<? super T, ? extends R> mapper;

    // 首先this是singleJust，mapper是我们map方法给的回调方法。
    public SingleMap(SingleSource<? extends T> source, Function<? super T, ? extends R> mapper) {
        this.source = source;
        this.mapper = mapper;
    }

    @Override
    protected void subscribeActual(final SingleObserver<? super R> t) {
        source.subscribe(new MapSingleObserver<T, R>(t, mapper));
    }

从我们代码看，SingleMap的subscribeActual给SingleJust添加了一个订阅（因为我们调用的是singleJust的map方法。所以是SingleJust）。那经过1的阅读源码我们知道，当subsribeActual执行的时候，SingleJust会直接调用MapSingleObserver的onSubscribe方法和onSuccess方法。所以我们直接看MapSingleObserver类的代码即可。

static final class MapSingleObserver<T, R> implements SingleObserver<T> {
    // 是给SingleMap传回调(subscribe方法)的时候的回调
    final SingleObserver<? super R> t;
    // map方法中传入的回调（single.map(.......)）
    final Function<? super T, ? extends R> mapper;

    MapSingleObserver(SingleObserver<? super R> t, Function<? super T, ? extends R> mapper) {
        this.t = t;
        this.mapper = mapper;
    }

    @Override
    public void onSubscribe(Disposable d) {
        // 直接往下传
        t.onSubscribe(d);
    }

    @Override
    public void onSuccess(T value) {
        R v;
        try {
            // 调用map回调
            v = Objects.requireNonNull(mapper.apply(value), "The mapper function returned a null value.");
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // 当apply返回回来空时，走错误
            onError(e);
            return;
        }
        // 往下传
        t.onSuccess(v);
    }

    @Override
    public void onError(Throwable e) {
        // 直接往下传
        t.onError(e);
    }
}

看到这里，头脑开始清晰了。MapSingleObserver中相关回调都直接调用了SingleMap的传来的回调，只有在onSuccess中调用了map中的apply方法。然后做了空判断。如果是空，就走入错误回调。那么到这，应该就很清楚整个流程了吧。

小结：当给SingleMap添加订阅时，它内部的subscribeActual给SingleJust添加了一个订阅，再触发onSubscribe和onError都直接传给了SingleMap的订阅。不同的在于在onSuccess会先传给SingleMap的apply方法然后非空后往下传。重要的是把下面SingleMap的订阅和SingleJust连接起来了。

照例使用扔物线大佬的图片。让大家更好理解

当然我的例子范型上是跟大佬反着来的，扔物线大佬just出来的是整形的。map出来的是String的。 image.png

当然多个map也是一样的逻辑，会先给上方添加一个订阅者，然后给下方传。

image.png

3.Observable.interval()

Observable.interval(0, 1, TimeUnit.SECONDS)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
            }

            @Override
            public void onNext(@NonNull Long aLong) {
                tv.setText(aLong.toString());
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

效果如下：

6.gif 先看interval，先介绍3个参数。第一个是初始延迟时间，第二个是间隔时间，第三个是时间单位。我这里设置的是1秒执行一次。康康源码

3.1 interval

public static Observable<Long> interval(long initialDelay, long period, @NonNull TimeUnit unit) {
    // 第四个参数是计时任务所在线程。默认再computation线程
    return interval(initialDelay, period, unit, Schedulers.computation());
}

public static Observable<Long> interval(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) {
    Objects.requireNonNull(unit, "unit is null");
    Objects.requireNonNull(scheduler, "scheduler is null");

    return RxJavaPlugins.onAssembly(new ObservableInterval(Math.max(0L, initialDelay), Math.max(0L, period), unit, scheduler));
}

我们这里无需多在意，只需在意线程Schedulers.computation()以及里面的实现类ObservableInterval。

在这里需要提一下，之前没怎么提Disposable，以及onSubscibe方法中做的事情。其实这里面跟取消任务有关系，但之前的例子，瞬时就完成了，所以就不涉及取消这个操作。onsubscribe方法里就直接调用了Disposable.disposed()来遗弃这个Disposable了。

但这个interval就存在着取消的概念了。当我们取消的时候不仅仅是停止页面渲染（往下面订阅回调），计时任务咱们也是需要一并停止的。来看看ObservableInterval代码。

@Override
public void subscribeActual(Observer<? super Long> observer) {
    IntervalObserver is = new IntervalObserver(observer);
    observer.onSubscribe(is);

    Scheduler sch = scheduler;

    if (sch instanceof TrampolineScheduler) {
        Worker worker = sch.createWorker();
        is.setResource(worker);
        worker.schedulePeriodically(is, initialDelay, period, unit);
    } else {
        // 1.这边让它去线程中跑计时任务，返回一个Disposable
        Disposable d = sch.schedulePeriodicallyDirect(is, initialDelay, period, unit);
        // 2.is是我们的订阅
        is.setResource(d);
    }
}

切线程的事情后面再说，先搞流程。在这里主要做了两件事，一是去线程跑任务，而是将返回的Disposable设置给订阅者。那我们看订阅者代码。

static final class IntervalObserver
extends AtomicReference<Disposable>
implements Disposable, Runnable {

    private static final long serialVersionUID = 346773832286157679L;

    final Observer<? super Long> downstream;

    long count;

    IntervalObserver(Observer<? super Long> downstream) {
        this.downstream = downstream;
    }

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

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

    @Override
    public void run() {
        // 在没有被遗弃的情况下
        if (get() != DisposableHelper.DISPOSED) {
            downstream.onNext(count++);
        }
    }

    public void setResource(Disposable d) {
        // 只能设置一次
        DisposableHelper.setOnce(this, d);
    }
}

看这个类的结构觉得有点搞人，extends AtomicReference<Disposable> implements Disposable, Runnable。AutomicRefrence是为了保证线程安全，实现Disposable是在内部遗弃整个任务。实现Runnable是直接给线程执行的。

刚开始就setResource并把计时任务传进来了。所以遗弃的就是它。然后在没有被遗弃的情况下，每次run方法都会执行订阅者（下游）的next方法。这样就不仅遗弃了计时任务了，同时还不会往下游传了。最重要的是这操作都是在其他线程，如果在回调中需要更新ui，需要把线程切换回来喔.observeOn(AndroidSchedulers.mainThread())

4.Delay

Single.just("1")
        .delay(1, TimeUnit.SECONDS)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new SingleObserver<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onSuccess(@NonNull String s) {
                tv.setText(s);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }
        });

效果如图：

delay.gif 代码延迟1秒，然后执行。按照刚才阅读源码的感想，想想如果取消分为几种情况？

2种情况：1、首先数据还没发下来的时候取消，直接取消上游。 2、已经发下来了，但还在延时的任务中，取消计时任务即可。想想是不是这样的呢？看源码

public final Single<T> delay(long time, @NonNull TimeUnit unit) {
    return delay(time, unit, Schedulers.computation(), false);
}

public final Single<T> delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) {
    Objects.requireNonNull(unit, "unit is null");
    Objects.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new SingleDelay<>(this, time, unit, scheduler, delayError));
}

和interval一样，需要注意线程和实例。因为延迟有计时任务，所以放到其他线程。

public SingleDelay(SingleSource<? extends T> source, long time, TimeUnit unit, Scheduler scheduler, boolean delayError) {
    this.source = source;
    this.time = time;
    this.unit = unit;
    this.scheduler = scheduler;
    this.delayError = delayError;
}

@Override
protected void subscribeActual(final SingleObserver<? super T> observer) {

    final SequentialDisposable sd = new SequentialDisposable();
    observer.onSubscribe(sd);
    source.subscribe(new Delay(sd, observer));
}

在subscribeActual中传了Dalay给上游just。看看delay

final class Delay implements SingleObserver<T> {
    private final SequentialDisposable sd;
    final SingleObserver<? super T> downstream;

    Delay(SequentialDisposable sd, SingleObserver<? super T> observer) {
        this.sd = sd;
        this.downstream = observer;
    }

    @Override
    public void onSubscribe(Disposable d) {
        // 上游触发我onSubscribe时将我当前的Disposable替换成上游的
        sd.replace(d);
    }

    @Override
    public void onSuccess(final T value) {
        // 成功返回下来后 Disposable换成计时任务
        sd.replace(scheduler.scheduleDirect(new OnSuccess(value), time, unit));
    }

    @Override
    public void onError(final Throwable e) {
        // 失败返回下来后 Disposable换成计时任务
        sd.replace(scheduler.scheduleDirect(new OnError(e), delayError ? time : 0, unit));
    }

    final class OnSuccess implements Runnable {
        private final T value;

        OnSuccess(T value) {
            this.value = value;
        }

        @Override
        public void run() {
            // 返回给订阅者（下游）
            downstream.onSuccess(value);
        }
    }

    final class OnError implements Runnable {
        private final Throwable e;

        OnError(Throwable e) {
            this.e = e;
        }

        @Override
        public void run() {
            // 返回给订阅者（下游）
            downstream.onError(e);
        }
    }
}

在拿到成功失败回调之前，Disposable是上游的，在成功失败回调的时候Disposable就是计时任务的。这样我在对应情况下调用遗弃方法的时候，就能把所有东西都移除了。

5.Observable.map

Observable.interval(0, 1, TimeUnit.SECONDS)
        .map(new Function<Long, String>() {
            @Override
            public String apply(Long aLong) throws Throwable {
                return aLong.toString();
            }
        })
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
            }

            @Override
            public void onNext(@NonNull String aLong) {
                tv.setText(aLong);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

效果跟之前SingleMap是一样的，我们直接看源码吧。

public final <@NonNull R> Observable<R> map(@NonNull Function<? super T, ? extends R> mapper) {
    Objects.requireNonNull(mapper, "mapper is null");
    return RxJavaPlugins.onAssembly(new ObservableMap<>(this, mapper));
}

public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
    super(source);
    this.function = function;
}

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

和SingleMap的极其相似，订阅回调以及map方法中的回调。

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) {
        super(actual); // 把下游传给父类
        this.mapper = mapper;
    }

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

        if (sourceMode != NONE) {
            // 直接往下游推
            downstream.onNext(null);
            return;
        }

        U v;

        try {
            // 调用map回调
            v = Objects.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
        } catch (Throwable ex) {
            fail(ex);
            return;
        }
        // 直接往下游推
        downstream.onNext(v);
    }

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

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

在这个类中我们只找到了onNext方法没有看到onSuccess和onSubscribe方法。那就只好去它的父类中找了。

public BasicFuseableObserver(Observer<? super R> downstream) {
    this.downstream = downstream;
}

@Override
public final void onSubscribe(Disposable d) {
    // 把上游的Disposable几乎就是传给了下游
    if (DisposableHelper.validate(this.upstream, d)) {

        this.upstream = d;
        if (d instanceof QueueDisposable) {
            this.qd = (QueueDisposable<T>)d;
        }

        if (beforeDownstream()) {
            
            downstream.onSubscribe(this);

            afterDownstream();
        }

    }
}

protected final void fail(Throwable t) {
    Exceptions.throwIfFatal(t);
    upstream.dispose();
    onError(t);
}

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

@Override
public void dispose() {
    // 遗弃
    upstream.dispose();
}

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

public static boolean validate(Disposable current, Disposable next) {
    if (next == null) {
        RxJavaPlugins.onError(new NullPointerException("next is null"));
        return false;
    }
    if (current != null) { 
        next.dispose();
        reportDisposableSet();
        return false;
    }
    // 上游传下来的不能为空 并且这是第一次赋值
    return true;
}

5.Observable.Delay

public final Observable<T> delay(long time, @NonNull TimeUnit unit) {
    return delay(time, unit, Schedulers.computation(), false);
}

public final Observable<T> delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) {
    Objects.requireNonNull(unit, "unit is null");
    Objects.requireNonNull(scheduler, "scheduler is null");

    return RxJavaPlugins.onAssembly(new ObservableDelay<>(this, time, unit, scheduler, delayError));
}

public ObservableDelay(ObservableSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) {
    super(source);
    this.delay = delay;
    this.unit = unit;
    this.scheduler = scheduler;
    this.delayError = delayError;
}

@Override
@SuppressWarnings("unchecked")
public void subscribeActual(Observer<? super T> t) {
    Observer<T> observer;
    if (delayError) {
        observer = (Observer<T>)t;
    } else {
        observer = new SerializedObserver<>(t);
    }
    
    // 计时任务所在线程
    Scheduler.Worker w = scheduler.createWorker();

    source.subscribe(new DelayObserver<>(observer, delay, unit, w, delayError));
}

static final class DelayObserver<T> implements Observer<T>, Disposable {
    final Observer<? super T> downstream;
    final long delay;
    final TimeUnit unit;
    final Scheduler.Worker w;
    final boolean delayError;

    Disposable upstream;

    DelayObserver(Observer<? super T> actual, long delay, TimeUnit unit, Worker w, boolean delayError) {
        super();
        this.downstream = actual;
        this.delay = delay;
        this.unit = unit;
        this.w = w;
        this.delayError = delayError;
    }

    @Override
    public void onSubscribe(Disposable d) {
        // 设置上游的disposable以及下游onSubscribe
        if (DisposableHelper.validate(this.upstream, d)) {
            this.upstream = d;
            downstream.onSubscribe(this);
        }
    }

    @Override
    public void onNext(final T t) {
        // 放到线程中执行
        w.schedule(new OnNext(t), delay, unit);
    }

    @Override
    public void onError(final Throwable t) {
        // 放到线程中执行
        w.schedule(new OnError(t), delayError ? delay : 0, unit);
    }

    @Override
    public void onComplete() {
        // 放到线程中执行
        w.schedule(new OnComplete(), delay, unit);
    }

    @Override
    public void dispose() {
        // 遗弃时 上游和计时任务同时遗弃
        upstream.dispose();
        w.dispose();
    }

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

    final class OnNext implements Runnable {
        private final T t;

        OnNext(T t) {
            this.t = t;
        }

        @Override
        public void run() {
            downstream.onNext(t);
        }
    }

    final class OnError implements Runnable {
        private final Throwable throwable;

        OnError(Throwable throwable) {
            this.throwable = throwable;
        }

        @Override
        public void run() {
            try {
                downstream.onError(throwable);
            } finally {
                w.dispose();
            }
        }
    }

    final class OnComplete implements Runnable {
        @Override
        public void run() {
            try {
                downstream.onComplete();
            } finally {
                w.dispose();
            }
        }
    }
}

6.subscribeOn

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

public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
    super(source);
    this.scheduler = scheduler;
}

@Override
public void subscribeActual(final Observer<? super T> observer) {
    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<>(observer);

    observer.onSubscribe(parent);
    // 1.直接用传入的线程来执行
    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<>();
    }

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

    @Override
    public void onNext(T t) {
        // 制定方法中调用下游方法
        downstream.onNext(t);
    }

    @Override
    public void onError(Throwable t) {
        // 3.制定方法中调用下游方法
        downstream.onError(t);
    }

    @Override
    public void onComplete() {
        // 3.制定方法中调用下游方法
        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);
    }
}

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

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

    @Override
    public void run() {
        // 2.给上游添加订阅
        source.subscribe(parent);
    }
}

注释都写上了，再描述一下。

小结：在设置订阅后，在subscribeActual方法中会直接切换线程来执行，然后run方法中给上游添加了订阅关系，在制定的方法中（onComplete、onError、onNext）直接往下游传下去了，在取消的时候又把线程任务以及上游Disposable遗弃了。

照例扔物线大佬的图伺候

image.png

思考：那如果多个subscribeOn会怎样的线程调度呢？

记得上面原来的逻辑嘛，是先切线程再给上游添加订阅！所以，应该是这样的。

image.png

7.observableOn

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

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

public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
    super(source);
    this.scheduler = scheduler;
    this.delayError = delayError;
    this.bufferSize = bufferSize;
}

@Override
protected void subscribeActual(Observer<? super T> observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else {
        Scheduler.Worker w = scheduler.createWorker();

        source.subscribe(new ObserveOnObserver<>(observer, w, delayError, bufferSize));
    }
}

这里和subscribeOn不同，这里并没有先切线程，而是先给上游添加订阅。

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

            downstream.onSubscribe(this);
        }
    }

    @Override
    public void onNext(T t) {
        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 (!outputFused && getAndIncrement() == 0) {
                queue.clear();
            }
        }
    }

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

    void schedule() {
        if (getAndIncrement() == 0) {
            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;
            }
        }
    }

    @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;
            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 Throwable {
        return queue.poll();
    }

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

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

代码很多。关注onComplete、onNext、onError方法即可，再这些方法中切线程再去做一系列判断后调用对应方法。所以应该线程切换如下图所示

image.png 那多个observeOn呢？

image.png

image.png 和subscribeOn串用的话，是这个效果：

image.png

8.如何调度线程的呢？

刚才讲到很多线程相关的方法，都避开了没说。 先来看看subscribeOn记得切换线程的方法是

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

我们来看看scheduleDirect方法。

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

@NonNull
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    // 1。这个worker是啥
    final Worker w = createWorker();
    // 钩子 就不看了
    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
    // 2.DisposeTask是啥
    DisposeTask task = new DisposeTask(decoratedRun, w);
    // 3.执行了
    w.schedule(task, delay, unit);

    return task;
}

这里有3个是不怎么看得懂的，第一个是worker，但这是schedulers类中的，所以我们就应该传过来的Scheduler中的这个方法了，因为它是个抽象方法。

@NonNull
public abstract Worker createWorker();

先来说Schedulers.newThread()

.subscribeOn(Schedulers.newThread())

public static Scheduler newThread() {
    return RxJavaPlugins.onNewThreadScheduler(NEW_THREAD);
}

@NonNull
static final Scheduler NEW_THREAD;

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

static final class NewThreadTask implements Supplier<Scheduler> {
    @Override
    public Scheduler get() {
        return NewThreadHolder.DEFAULT;
    }
}

static final class NewThreadHolder {
    static final Scheduler DEFAULT = new NewThreadScheduler();
}

public final class NewThreadScheduler extends Scheduler {

    final ThreadFactory threadFactory;

    private static final String THREAD_NAME_PREFIX = "RxNewThreadScheduler";
    private static final RxThreadFactory THREAD_FACTORY;

    /** The name of the system property for setting the thread priority for this Scheduler. */
    private static final String KEY_NEWTHREAD_PRIORITY = "rx3.newthread-priority";

    static {
        int priority = Math.max(Thread.MIN_PRIORITY, Math.min(Thread.MAX_PRIORITY,
                Integer.getInteger(KEY_NEWTHREAD_PRIORITY, Thread.NORM_PRIORITY)));

        THREAD_FACTORY = new RxThreadFactory(THREAD_NAME_PREFIX, priority);
    }

    public NewThreadScheduler() {
        this(THREAD_FACTORY);
    }

    public NewThreadScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
    }

    @NonNull
    @Override
    public Worker createWorker() {
        return new NewThreadWorker(threadFactory);
    }
}

这里终于看到了我们想要看到的createWorker方法了，但是它内部又实例了一个对象出来，继续深入

public NewThreadWorker(ThreadFactory threadFactory) {
    executor = SchedulerPoolFactory.create(threadFactory);
}

public class NewThreadWorker extends Scheduler.Worker implements Disposable {
    private final ScheduledExecutorService executor;

    volatile boolean disposed;

    public NewThreadWorker(ThreadFactory threadFactory) {
        executor = SchedulerPoolFactory.create(threadFactory);
    }

    @NonNull
    @Override
    public Disposable schedule(@NonNull final Runnable run) {
        return schedule(run, 0, null);
    }

    @NonNull
    @Override
    public Disposable schedule(@NonNull final Runnable action, long delayTime, @NonNull TimeUnit unit) {
        if (disposed) {
            return EmptyDisposable.INSTANCE;
        }
        return scheduleActual(action, delayTime, unit, null);
    }
    
public Disposable scheduleDirect(final Runnable run, long delayTime, TimeUnit unit) {
    ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run), true);
    try {
        Future<?> f;
        if (delayTime <= 0L) {
            f = executor.submit(task);
        } else {
            f = executor.schedule(task, delayTime, unit);
        }
        task.setFuture(f);
        return task;
    } catch (RejectedExecutionException ex) {
        RxJavaPlugins.onError(ex);
        return EmptyDisposable.INSTANCE;
    }
}
    
    @Override
    public boolean isDisposed() {
        return disposed;
    }
}

当然内部还有很多其他方法，就没有一一弄出来了，我们看的出来内部线程调度其实还是一个Disposable，其实就是这个因为它是一个Disposable，才会方便我们去取消它。也看到了内部线程的本质其实还是原生的线程。newThread每次都会从线程池中创建一个线程出来。

现在来看io的线程，我就不一个一个点下去了。

@Override
public void start() {
    CachedWorkerPool update = new CachedWorkerPool(KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT, threadFactory);
    if (!pool.compareAndSet(NONE, update)) {
        update.shutdown();
    }
}

public IoScheduler(ThreadFactory threadFactory) {
    this.threadFactory = threadFactory;
    this.pool = new AtomicReference<>(NONE);
    start();
}

@NonNull
@Override
public Worker createWorker() {
    return new EventLoopWorker(pool.get());
}

而io则是从缓存池中拿。

扯远了，回归刚才的代码

public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    // 这一步走完了
    final Worker w = createWorker();

    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

    DisposeTask task = new DisposeTask(decoratedRun, w);
    // 接下来就是到了线程中执行了
    w.schedule(task, delay, unit);

    return task;
}

在线程中执行的代码是

// newThread出来的
@NonNull
@Override
public Disposable schedule(@NonNull final Runnable action, long delayTime, @NonNull TimeUnit unit) {
    if (disposed) {
        return EmptyDisposable.INSTANCE;
    }
    return scheduleActual(action, delayTime, unit, null);
}
// io出来的
@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;
    }

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

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

其实我上边也有贴这块代码，这边就是直接调用了原生线程的submit和schedule了。

9.如何切的主线程

一路点下来之后发现

private static final class MainHolder {
    static final Scheduler DEFAULT
        = new HandlerScheduler(new Handler(Looper.getMainLooper()), true);
}

@Override
@SuppressLint("NewApi") // Async will only be true when the API is available to call.
public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) {
    if (run == null) throw new NullPointerException("run == null");
    if (unit == null) throw new NullPointerException("unit == null");

    run = RxJavaPlugins.onSchedule(run);
    ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
    Message message = Message.obtain(handler, scheduled);
    if (async) {
        message.setAsynchronous(true);
    }
    handler.sendMessageDelayed(message, unit.toMillis(delay));
    return scheduled;
}

@Override
@SuppressLint("NewApi") // Async will only be true when the API is available to call.
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 Disposable.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.

    if (async) {
        message.setAsynchronous(true);
    }

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

    return scheduled;
}

发现它一路上也是通过handler切换主线程的，然后在对应改切线程的地方handler.sendMessageDelayed了。这就到了主线程中。 当然了AndroidSchedulers不会只有主线程的还提供了一个from方法让我们自己提供looper来到制定的线程中。

public static Scheduler from(Looper looper, boolean async) {
    if (looper == null) throw new NullPointerException("looper == null");

    // Below code exists in androidx-core as well, but is left here rather than include an
    // entire extra dependency.
    // https://developer.android.com/reference/kotlin/androidx/core/os/MessageCompat?hl=en#setAsynchronous(android.os.Message,%20kotlin.Boolean)
    if (Build.VERSION.SDK_INT < 16) {
        async = false;
    } else if (async && Build.VERSION.SDK_INT < 22) {
        // Confirm that the method is available on this API level despite being @hide.
        Message message = Message.obtain();
        try {
            message.setAsynchronous(true);
        } catch (NoSuchMethodError e) {
            async = false;
        }
        message.recycle();
    }
    return new HandlerScheduler(new Handler(looper), async);
}

到这就结束了。

avatar
文章
阅读
粉丝