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 潮流周刊#52：Python 处理 Excel 的资源

(二) 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)));`