RxJava2 (三)線程切換源碼閱讀

當前版本 2.2.19
RxJava2 (一)訂閱流程源碼閱讀
 RxJava2 (二)取消訂閱流程 dispose( ) 源碼閱讀
 RxJava2 (三)線程切換源碼閱讀
 RxJava2 (四)切換UI主線程源碼閱讀
 RxJava2 (五)just操作符源碼閱讀
 RxJava2 (六)map操作符源碼閱讀

代碼示例

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        System.out.println("被觀察者發射數據線程: " + Thread.currentThread().getId());
        emitter.onNext(100);
        emitter.onComplete();
    }
})
        .subscribeOn(Schedulers.io())// 被觀察者發射消息從io線程
        .observeOn(Schedulers.newThread()) // 觀察者接收消息後在Schedulers.newThread()新線程中處理
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("onSubscribe");
            }
            @Override
            public void onNext(Integer integer) {
                System.out.println("觀察者接收數據線程: " + Thread.currentThread().getId());
                System.out.println("onNext: " + integer);
            }
            @Override
            public void onError(Throwable e) {
                System.out.println("onError");
            }
            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        });

`Schedulers`

該類是一個工廠類,可以返回五種不同的父類類型爲Scheduler的單例對象,分別是SINGLE,COMPUTATION,IO,TRAMPOLINE,NEW_THREAD.

public final class Schedulers {
    // 五種單例
    static final Scheduler SINGLE;
    static final Scheduler COMPUTATION;
    static final Scheduler IO;
    static final Scheduler TRAMPOLINE;
    static final Scheduler NEW_THREAD;
    // 靜態代碼塊
    static {
        // SingleTask,ComputationTask,IOTask,NewThreadTask 都是Schedulers類中靜態內部類
        // RxJavaPlugins.initSingleScheduler()最終返回的是一個SingleScheduler對象,其他的XXXTask也是一樣返回XXXScheduler.
        SINGLE = RxJavaPlugins.initSingleScheduler(new SingleTask());
        COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());
        IO = RxJavaPlugins.initIoScheduler(new IOTask());
        TRAMPOLINE = TrampolineScheduler.instance();
        NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
    }
    // SingleTask 實現了唯一的call()方法,
    // ComputationTask,IOTask,NewThreadTask 也是這種套路寫出來的.
    static final class SingleTask implements Callable<Scheduler> {
        @Override
        public Scheduler call() throws Exception {
            // 返回的是SingleScheduler單例對象,下面看分析
            return SingleHolder.DEFAULT;
        }
    }
    // SingleHolder也是一個靜態內部類,它會持有一個SingleScheduler對象的引用.
    static final class SingleHolder {
        static final Scheduler DEFAULT = new SingleScheduler();
    }
}
// RxJavaPlugins類
public final class RxJavaPlugins {
    // 該方法在Schedulers類中的靜態代碼塊中被調用,並最終返回的是SingleScheduler對象
    @NonNull
    public static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler) {
        Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitSingleHandler;
        if (f == null) {
            // defaultScheduler 參數是SingleTask對象,實現了call()方法
            return callRequireNonNull(defaultScheduler);
        }
        return applyRequireNonNull(f, defaultScheduler);
    }
    
    @NonNull
    static Scheduler callRequireNonNull(@NonNull Callable<Scheduler> s) {
        try {
            // 最終這裏調用了s.call(),返回了SingleScheduler對象.
            return ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't be null");
        } catch (Throwable ex) {
            throw ExceptionHelper.wrapOrThrow(ex);
        }
    }
}

`Schedulers.io()`獲取`IoScheduler`單例對象

上面說過Schedulers類中的一些處理,io()方法最終返回了IoScheduler對象

public final class Schedulers {
    static final Scheduler IO;
    @NonNull
    public static Scheduler io() {
        return RxJavaPlugins.onIoScheduler(IO);
    }
}
public final class RxJavaPlugins {
    Function<? super Scheduler, ? extends Scheduler> f = onIoHandler;
    if (f == null) {
        // 將IoScheduler原路返回
        return defaultScheduler;
    }
    return apply(f, defaultScheduler);
}

`.subscribeOn(Schedulers.io())`設置被觀察者發射數據線程

public abstract class Observable<T> implements ObservableSource<T> {
    // 設置被觀察者執行線程
    public final Observable<T> subscribeOn(Scheduler scheduler) {
        // this:是誰調用的subscribeOn()方法?答案是Observable.create()創建的ObservableCreate對象調用了subscribeOn()方法
        // scheduler是Schedulers.io()獲取到的IoScheduler單例對象
        // 最終將創建好的ObservableSubscribeOn對象返回.
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
    }
}

`.observeOn(Schedulers.newThread())`設置觀察者處理數據的線程

Schedulers.newThread()返回的就是NewThreadScheduler對象,和獲取IoScheduler對象時的套路一樣的.

public final class Schedulers {
    static final Scheduler IO;
    static final Scheduler NEW_THREAD;
    @NonNull
    public static Scheduler io() {
        return RxJavaPlugins.onIoScheduler(IO);
    }
    // 返回NewThreadScheduler對象.
    @NonNull
    public static Scheduler newThread() {
        return RxJavaPlugins.onNewThreadScheduler(NEW_THREAD);
    }
}

.observeOn(Schedulers.newThread())設置觀察者處理數據時候的線程

public abstract class Observable<T> implements ObservableSource<T> {
    
    public final Observable<T> observeOn(Scheduler scheduler) {
        // scheduler:就是上面獲取到的NewThreadScheduler對象.
        // 接着向下看
        return observeOn(scheduler, false, bufferSize());
    }
    
    public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        // this: 由誰調用observeOn()方法?由上一步Observable.subscribeOn()所創建的ObservableSubscribeOn對象.
        // scheduler: 是Schedulers.newThread()返回的NewThreadScheduler對象
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }
}

`ObservableObserveOn`對象調用`subscribe()`

首先是調用父類的Observable.subscribe(),因爲ObservableObserveOn是Observable的子類,並且ObservableObserveOn沒有重寫subscribe()方法

public abstract class Observable<T> implements ObservableSource<T> {
    public final void subscribe(Observer<? super T> observer) {
        // 這個方法ObservableObserveOn重寫了,所以調用的是ObservableObserveOn.subscribeActual(observer)
        // observer爲自己手動創建的觀察者對象
        subscribeActual(observer);
    }
}

ObservableObserveOn.subscribeActual(observer)

public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    // 上面解釋過source就是ObservableSubscribeOn對象
    // scheduler是NewThreadScheduler對象
    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是NewThreadScheduler對象.
            // 先看下NewThreadScheduler.createWorker()邏輯
            Scheduler.Worker w = scheduler.createWorker();
            // source就是ObservableSubscribeOn對象,調用subscribe()最終會走ObservableSubscribeOn.subscribeActual()方法
            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
        }
    }
}

NewThreadScheduler.createWorker();
創建NewThreadWorker對象

public final class NewThreadScheduler extends Scheduler {
    final ThreadFactory threadFactory;
    private static final RxThreadFactory THREAD_FACTORY;
    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);
    }
    // 當創建NewThreadScheduler對象的時候,默認會創建一個線程工廠,將RxThreadFactory對象最終賦值給了threadFactory變量.
    public NewThreadScheduler() {
        this(THREAD_FACTORY);
    }
    public NewThreadScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
    }
    // 創建一個NewThreadWorker對象,並且傳入了RxThreadFactory對象.
    public Worker createWorker() {
        return new NewThreadWorker(threadFactory);
    }
}

source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
source明確知道是ObservableSubscribeOn對象,調用subscribe()方法最終會調用到ObservableSubscribeOn中的subscribeActual()方法.和ObservableCreate.subscribe(Observer)是一樣的邏輯.

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    @Override
    public void subscribeActual(final Observer<? super T> observer) {
        // observer是由ObserveOnObserver對象傳入得來,Observer類是ObserveOnObserver的父類.
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
        // 這一步調用的就是手動創建的ObserveOnObserver.onSubscribe(parent)
        // 這一步最終會調用到自己手動創建的Observer.onSubscribe()方法
        observer.onSubscribe(parent);
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }
}

下面再來分析下ObserveOnObserver.onSubscribe(parent)

// ObservableObserveOn.ObserveOnObserver類
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>implements Observer<T>, Runnable {
        // ObservableObserveOn.subscribeActual()方法中創建的ObserveOnObserver對象, 
        // 真的快看不下去了,太饒了...
        ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.downstream = actual; // 這個就是手動創建的Observer對象.
            this.worker = worker;// 這個就是NewThreadWorker對象,他包含了一個線程池對象.
            this.delayError = delayError;
            this.bufferSize = bufferSize;
        }
        
        // 參數d就是上一步說的SubscribeOnObserver對象了.
        @Override
        public void onSubscribe(Disposable d) {
            if (DisposableHelper.validate(this.upstream, d)) {
                ...
                // 這裏是回調手動創建的Observer對象中的onSubscribe(this)方法
                downstream.onSubscribe(this);
            }
        }
    }
}

`Observer.onSubscribe()`走到這裏了,做個總結.

當調用.subscribe(),是由ObservableObserveOn對象調用的,最終會調用到ObservableObserveOn.subscribeActual(Observer)
在ObservableObserveOn.subscribeActual(Observer)中,會調用ObservableSubscribeOn.subscribe(ObserveOnObserver)
在ObservableSubscribeOn.subscribe(ObserveOnObserver)中,會調用ObservableSubscribeOn.subscribeActual(ObserveOnObserver)
在ObservableSubscribeOn.subscribeActual(ObserveOnObserver)中,會調observer.onSubscribe(parent)
在observer.onSubscribe(parent)中最終會調用手動創建的Observer.onSubscribe(Disposable)方法

`ObservableSubscribeOn.subscribeActual()`還沒走完,接着看`parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));`

先看scheduler.scheduleDirect(new SubscribeTask(parent)),scheduler對象就是Schedulers.io(),通過.subscribeOn(Schedulers.io())設置觀察者發射數據在io線程中操作,那麼看IoScheduler中

public final class IoScheduler extends Scheduler {
    // IoScheduler中不存在scheduleDirect()方法,需要看父類Scheduler
}
public abstract class Scheduler {
    // 它這裏傳的是一個Runnable對象,run對象是由ObservableSubscribeOn.subscribeActual()方法中創建的SubscribeTask.
    // SubscribeTask對象中的run()方法最終會調用ObservableCreate中的subscribe()方法.
    public Disposable scheduleDirect(@NonNull Runnable run) {
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }
    @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        // createWorker()調用的是Scheduler子類的IoScheduler,它將返回一個EventLoopWorker對象
        final Worker w = createWorker();
        // 將run對象返回
        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
        DisposeTask task = new DisposeTask(decoratedRun, w);
        // 調用的是EventLoopWorker.schedule()方法,
        // 最終調用的是ThreadWorker對象的scheduleActual()方法
        w.schedule(task, delay, unit);
        // 最終返回DisposeTask
        return task;
    }
}
// IoScheduler.EventLoopWorker類
public final class IoScheduler extends Scheduler {
    static final RxThreadFactory WORKER_THREAD_FACTORY;
    static final CachedWorkerPool NONE;
    
    static {
        // 線程工廠
        WORKER_THREAD_FACTORY = new RxThreadFactory(WORKER_THREAD_NAME_PREFIX, priority);
        // 創建CachedWorkerPool線程池
        NONE = new CachedWorkerPool(0, null, WORKER_THREAD_FACTORY);
        NONE.shutdown();
    }
    // 創建IoScheduler對象
    public IoScheduler() {
        // 傳入線程工廠
        this(WORKER_THREAD_FACTORY);
    }
    public IoScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
        // pool是對象CachedWorkerPool的引用
        this.pool = new AtomicReference<CachedWorkerPool>(NONE);
        start();
    }
    @NonNull
    @Override
    public Worker createWorker() {
        // pool.get() 獲取一個
        return new EventLoopWorker(pool.get());
    }
    // CachedWorkerPool類
    static final class CachedWorkerPool implements Runnable {
        // 從線程池中,取出ThreadWorker對象
        // ThreadWorker繼承自NewThreadWorker,它持有ScheduledExecutorService對象.
        ThreadWorker get() {
            ...
            ThreadWorker w = new ThreadWorker(threadFactory);
            return w;
        }
    }
    
    // EventLoopWorker類
    static final class EventLoopWorker extends Scheduler.Worker {
        EventLoopWorker(CachedWorkerPool pool) {
            this.pool = pool;// 這個就是CachedWorkerPool對象
            this.tasks = new CompositeDisposable();
            this.threadWorker = pool.get();// 得到一個ThreadWorker對象
        }
        @NonNull
        @Override
        public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
            ...
            // 通過ThreadWorker對象調用scheduleActual()方法
            return threadWorker.scheduleActual(action, delayTime, unit, tasks);
        }
    }
    static final class ThreadWorker extends NewThreadWorker {}
}
// 看下ObservableSubscribeOn.SubscribeTask類型
public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
     // 它也是繼承自Runnable, 它的run()方法最終會使得ObservableCreate對象調用subscribe()方法,
     // 在訂閱流程中分析過,ObservableCreate.subscribe()最終會調用手動創建的ObservableOnSubscribe.subscribe(),一般這個方法通過emitter發射數據.
     final class SubscribeTask implements Runnable {
            private final SubscribeOnObserver<T> parent;
    
            SubscribeTask(SubscribeOnObserver<T> parent) {
                this.parent = parent;
            }
    
            @Override
            public void run() {
                // 這裏的sourc就是Observable.create()創建的ObservableCreate對象.
                // parent就是SubscribeOnObserver,
                // SubscribeOnObserver對象中持有ObserveOnObserver對象引用.
                // ObserveOnObserver對象中持有手動創建的Observer引用.
                source.subscribe(parent);
            }
        }
}
// 最後看下 NewThreadWorker.scheduleActual()方法
public class NewThreadWorker extends Scheduler.Worker implements Disposable {
    private final ScheduledExecutorService executor;
    public NewThreadWorker(ThreadFactory threadFactory) {
        // 返回一個線程池支持定時以及週期性執行任務的需求。
        executor = SchedulerPoolFactory.create(threadFactory);
    }
    // run: DisposeTask對象
    @NonNull
    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);
        ...
        Future<?> f;
        try {
            if (delayTime <= 0) {
                // executor線程池將Runnable對象傳入,在此線程上執行任務.
                f = executor.submit((Callable<Object>)sr);
            } else {
                f = executor.schedule((Callable<Object>)sr, delayTime, unit);
            }
            sr.setFuture(f);
        } ...
        return sr;
    }
}

被觀察者能在IO線程中發射數據的邏輯走完了,做個總結.

察者在發射數據的代碼寫在ObservableOnSubscribe.subscribe(ObservableEmitter)方法中.

@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
    System.out.println("被觀察者發射數據線程: " + Thread.currentThread().getId());
    emitter.onNext(100);
}

ObservableOnSubscribe.subscribe()在ObservableCreate.subscribeActual(Observer)方法中被調用
ObservableCreate.subscribeActual(Observer)在(ObservableCreate)Observable.subscribe(SubscribeOnObserver)方法中被調用
(ObservableCreate)Observable.subscribe(SubscribeOnObserver)在SubscribeTask對象的run()方法被調用
SubscribeTask.run()被DisposeTask.run()方法所調用
DisposeTask.run()被ScheduledRunnable.run()方法所調用
最終,ScheduledRunnable.run()被傳遞到了executor.submit(Runnable);中被執行了.
至此,當被觀察者發送數據的代碼就被由IoScheduler中創建的ThreadWorker中的ScheduledExecutorService線程池對象中的某個線程所調用

下面看觀察者在新線程中接收數據

ObservableObserveOn.subscribeActual(Observer)接收到創建的Observer對象
創建ObserveOnObserver對象,該對象持有用戶創建的Observer對象
ObserveOnObserver對象最終被ObservableSubscribeOn.subscribeActual(Observer)方法接收
創建SubscribeOnObserver對象,它持有ObserveOnObserver對象引用
創建SubscribeTask對象,它持有SubscribeOnObserver對象引用
當SubscribeTask對象中的run()方法由IoScheduler中創建的ThreadWorker中的ScheduledExecutorService線程池對象中的某個線程所調用
SubscribeTask對象中的run()最終會將SubscribeTask對象傳遞到ObservableCreate.subscribeActual()中
ObservableCreate.subscribeActual()方法創建CreateEmitter對象,該對象持有SubscribeOnObserver引用.然後調用ObservableOnSubscribe.subscribe(ObservableEmitter)方法
被觀察者持有ObservableEmitter發射數據

emitter.onNext(100);

CreateEmitter調用onNext()將會調用SubscribeOnObserver.onNext()
SubscribeOnObserver.onNext()將會調用ObserveOnObserver.onNext()
ObserveOnObserver中的onNext()方法

// ObservableObserveOn.ObserveOnObserver類
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>implements Observer<T>, Runnable {
        ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.downstream = actual;// 用戶創建的觀察者對象
            this.worker = worker;// 爲通過NewThreadScheduler.createWorker()創建的NewThreadWorker對象,NewThreadWorker對象對象中有一個線程池引用
            this.delayError = delayError;
            this.bufferSize = bufferSize;
        }
        // 觀察者發射的數據最終會調用這裏的onNext()
        @Override
        public void onNext(T t) {
            ...
            schedule();
        }
        
        void schedule() {
            if (getAndIncrement() == 0) {
                // 這裏調用的是NewThreadWorker.schedule()
                worker.schedule(this);
            }
        }
        // 當worker.schedule(this);調用後最終執行到了這個方法中來了.
         @Override
         public void run() {
             if (outputFused) {
                 drainFused();
             } else {
                 drainNormal();
             }
         }
        // 
        void drainNormal() {
            ...
            // downstream:構造方法中說了,downstream就是用戶創建的觀察者對象.
            final Observer<? super T> a = downstream;
            for (;;) {
                ...
                for (;;) {
                    ...
                    // 這就是調用了觀察者中的onNext()方法
                    a.onNext(v);
                }
                ...
            }
        }
        void drainFused() {
            
            for (;;) {
                ...
                // 觀察者中的onNext()被調用.
                downstream.onNext(null);
            }
        }
    }
}
// NewThreadWorker類
public class NewThreadWorker extends Scheduler.Worker implements Disposable {
    @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) {
        ...
        return scheduleActual(action, delayTime, unit, null);
    }
    @NonNull
    public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        ...
        try {
            if (delayTime <= 0) {
                // 最後的最後還是調用了線程池中的submit()方法,並且傳入了
                f = executor.submit((Callable<Object>)sr);
            } else {
                f = executor.schedule((Callable<Object>)sr, delayTime, unit);
            }
            sr.setFuture(f);
        } ..
        return sr;
    }
}

總結下:

當被觀察者發射數據時,最終調用ObserveOnObserver中的onNext(),最後由NewThreadScheduler.createWorker()創建的NewThreadWorker對象中的ScheduledExecutorService線程池對象中的某個線程所調用
ObserveOnObserver實現了Runnable接口,onNext()會將ObserveOnObserver對象傳入到線程池中執行,最終調用了ObserveOnObserver.run()方法
ObserveOnObserver.run()最終會調用用戶創建的觀察者中的onNext()方法.到這裏位置,觀察者接收數據的線程也就從被觀察者發射數據的線程Schedulers.io()切換到了Schedulers.newThread()線程中來了.

RxJava2 (三)線程切換源碼閱讀

代碼示例

`Schedulers`

`Schedulers.io()`獲取`IoScheduler`單例對象

`.subscribeOn(Schedulers.io())`設置被觀察者發射數據線程

`.observeOn(Schedulers.newThread())`設置觀察者處理數據的線程

`ObservableObserveOn`對象調用`subscribe()`

`Observer.onSubscribe()`走到這裏了,做個總結.

`ObservableSubscribeOn.subscribeActual()`還沒走完,接着看`parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));`

被觀察者能在IO線程中發射數據的邏輯走完了,做個總結.

下面看觀察者在新線程中接收數據

Python 潮流週刊#50：我最喜歡的 Python 3.13 新特性！

(二) Jetpack LiveData 源碼分析

(一) Jetpack Lifecycle 源碼分析

Android 8.0 啓動圖標適配

(一) Dagger2 @Inject分析一

(三) Dagger2 @Module分析一

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

RxJava2 (三)線程切換源碼閱讀

代碼示例

Schedulers

Schedulers.io()獲取IoScheduler單例對象

.subscribeOn(Schedulers.io())設置被觀察者發射數據線程

.observeOn(Schedulers.newThread())設置觀察者處理數據的線程

ObservableObserveOn對象調用subscribe()

Observer.onSubscribe()走到這裏了,做個總結.

ObservableSubscribeOn.subscribeActual()還沒走完,接着看parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));

被觀察者能在IO線程中發射數據的邏輯走完了,做個總結.

下面看觀察者在新線程中接收數據

`Schedulers`

`Schedulers.io()`獲取`IoScheduler`單例對象

`.subscribeOn(Schedulers.io())`設置被觀察者發射數據線程

`.observeOn(Schedulers.newThread())`設置觀察者處理數據的線程

`ObservableObserveOn`對象調用`subscribe()`

`Observer.onSubscribe()`走到這裏了,做個總結.

`ObservableSubscribeOn.subscribeActual()`還沒走完,接着看`parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));`