subscribeOn源码解析

demo

Observable.just(1)
        .subscribeOn(Schedulers.newThread())
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
            
            }

            @Override
            public void onNext(Integer integer) {
            
            }

            @Override
            public void onError(Throwable e) {
            
            }

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

Schedulers#newThread

public final class Schedulers {
    ...
    static final Scheduler NEW_THREAD;

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

    static {
        ...
        NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
    }
    
    public static Scheduler newThread() {
        return RxJavaPlugins.onNewThreadScheduler(NEW_THREAD);
    }

    static final class NewThreadTask implements Callable<Scheduler> {
        @Override
        public Scheduler call() throws Exception {
            return NewThreadHolder.DEFAULT;
        }
    }
    ...
}

其实质就是返回了一个NewThreadScheduler对象。以后分析。

Observable#subscribeOn

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

subscribeOn就是返回了一个ObservableSubscribeOn对象。

ObservableSubscribeOn

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

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

scheduler在这里是我们传入的NewThreadScheduler对象

AbstractObservableWithUpstream

abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> 
    implements HasUpstreamObservableSource<T> {

    protected final ObservableSource<T> source;

    AbstractObservableWithUpstream(ObservableSource<T> source) {
        this.source = source;
    }

    @Override
    public final ObservableSource<T> source() {
        return source;
    }
}

source在这里表示just方法返回的ObservableJust对象。

Observable#subscribe

public final void subscribe(Observer<? super T> observer) {
    ...
    subscribeActual(observer);
    ... 
}

在这里调用了ObservableSubscribeOn的subscribeActual，传入我们自己的observer

ObservableSubscribeOn#subscribeActual

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    ...
    @Override
    public void subscribeActual(final Observer<? super T> observer) {
        // 1
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
        
        // 2
        observer.onSubscribe(parent);

        // 3
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }
    ...
}

注释1处将我们自定义的Observer包装成了一个SubscribeOnObserver对象。

注释2处调用了我们自己的observer的onSubscribe方法，此时未发生线程切换。

注释3处先创建了一个SubscribeTask对象，然后进行调度。

SubscribeTask

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

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

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

注释4处已经发生了线程切换，即订阅过程发生在指定的线程。

source是我们前面说的just方法返回的ObservableJust对象。

ObservableJust#subscribeActual

public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {

    private final T value;
    public ObservableJust(final T value) {
        this.value = value;
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        ScalarDisposable<T> sd = new ScalarDisposable<T>(observer, value);
        // 1
        observer.onSubscribe(sd);
        // 2
        sd.run();
    }

    @Override
    public T call() {
        return value;
    }
}

注释1处，observer是订阅时传入的SubscribeOnObserver对象。

SubscribeOnObserver#onSubscribe

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

设置upstream的值为Disposable对象

ScalarDisposable#run

public static final class ScalarDisposable<T>
    extends AtomicInteger
    implements QueueDisposable<T>, Runnable {

    private static final long serialVersionUID = 3880992722410194083L;

    final Observer<? super T> observer;

    final T value;

    static final int START = 0;
    static final int FUSED = 1;
    static final int ON_NEXT = 2;
    static final int ON_COMPLETE = 3;

    public ScalarDisposable(Observer<? super T> observer, T value) {
        this.observer = observer;
        this.value = value;
    }
    ...
    @Override
    public void run() {
        if (get() == START && compareAndSet(START, ON_NEXT)) {
            // 1
            observer.onNext(value);
            if (get() == ON_NEXT) {
                lazySet(ON_COMPLETE);
                // 2
                observer.onComplete();
            }
        }
    }
}

注释1，2处的observer在这里表示ObservableSubscribeOn的SubscribeOnObserver对象

ObservableSubscribeOn#SubscribeOnObserver

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

    @Override
    public void onNext(T t) {
        // 1
        downstream.onNext(t);
    }

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

注释1的onNext运行在订阅时的线程

注释2的onComplete运行在订阅时的线程

总结

subscribeOn方法控制的是上游的Observable对象发生订阅的线程。