RxJava2 源码分析笔记(三) 线程切换

RxJava2 源码分析笔记(一)

RxJava2 源码分析笔记(二)

终于来到线程切换

先看一个如何切线程的简略流程图

注： 上面蓝牙主流程中  subscribeOn(Schedulers.io()) ，observeOn(AndroidSchedulers.mainThread())

        但是subscribeOn，observeOn他们即可以传主线程也可以传子线程

        这是让RxJava的线程可以灵活的回切换的关键！

====================================================================

先来看看

subscribeOn(Schedulers.io())

这个分为两个部分

|------ subscribeOn() 创建了一个 Runnable{  run{ source.subscribe(parent);  } },核心是source.subscribe(parent)，并传递  到Schedulers.io()创建的Scheduler中调用。

|------ Schedulers.io()返回一个 Scheduler就是一个用来新建线程并调度使用；

 

接下来就先看subscribeOn()是如何实现的（和map等数据变换操作一样，结构都是类似的）

/**
 *    subscribeOn  核心是new ObservableSubscribeOn(this, scheduler)
 */   
 @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
    }

ObservableSubscribeOn源码 ↓ 

public final class ObservableSubscribeOn extends AbstractObservableWithUpstream {
    final Scheduler scheduler;

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

    @Override
    public void subscribeActual(final Observer s) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(s);

        s.onSubscribe(parent);
        
        //核心代码就是这句
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

    static final class SubscribeOnObserver extends AtomicReference implements Observer, Disposable {
 
        //...省略其他代码...
        
        @Override
        public void onNext(T t) {
            actual.onNext(t);
        }

       
    }

    //核心代码
    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent;

        SubscribeTask(SubscribeOnObserver parent) {
            this.parent = parent;
        }

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

这里面核心代码

public void subscribeActual(final Observer s) {
    final SubscribeOnObserver parent = new SubscribeOnObserver(s);

    s.onSubscribe(parent);

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

首先创建了一个 SubscribeOnObserver   parent 并传递到new SubscribeTask中 ,SubscribeTask就是一个Runnable

在它的run方法里面执行了source.subscribe(parent); 这样往前回调的subscribe准备好了

 final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent;

        SubscribeTask(SubscribeOnObserver parent) {
            this.parent = parent;
        }

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

然后就是将这个Runnable传到调度器中 scheduler.scheduleDirect(new SubscribeTask(parent))

调度器scheduler是哪来的的呢，还记得前面 subscribeOn(Scheduler scheduler)么，它就是我们传递过来的 Schedulers.io() 。

那就看一下 Schedulers.io() 是什么样的

    //源码点进去就是这个
  
    @NonNull
    public static Scheduler io() {
        return RxJavaPlugins.onIoScheduler(IO);
    }

 而 RxJavaPlugins.onIoScheduler(IO) 返回的就是 IO,我们去看IO就可以了

public final class Schedulers {
    
    ......

    @NonNull
    static final Scheduler IO;


    static {
        SINGLE = RxJavaPlugins.initSingleScheduler(new SingleTask());

        COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());

        // IO 在这里初始化
        IO = RxJavaPlugins.initIoScheduler(new IOTask());

        TRAMPOLINE = TrampolineScheduler.instance();

        NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
    }


    ......

}

而 RxJavaPlugins.initIoScheduler(new IOTask()); 最后返回的就是new IOTask()的返回值为啥这么说呢

RxJavaPlugins.initIoSchedule →  callRequireNonNull(defaultScheduler) 

static Scheduler callRequireNonNull(@NonNull Callable s) {
    try {
        注释：s就是传递过来的 new IOTask()
        return ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't be                 
            null");
    } catch (Throwable ex) {
        throw ExceptionHelper.wrapOrThrow(ex);
    }
}
而ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't benull");
实现是下面这样的，就是将s.call()不为null原样返回
public final class ObjectHelper {

     public static  T requireNonNull(T object, String message) {
        if (object == null) {
            throw new NullPointerException(message);
        }
        return object;
    }

}

  s.call 方法返回的  IoHolder.DEFAULT

 static final class IOTask implements Callable {
        @Override
        public Scheduler call() throws Exception {
            return IoHolder.DEFAULT;
        }
    }

而  IoHolder.DEFAULT = new IoScheduler()；

 static final class IoHolder {
        static final Scheduler DEFAULT = new IoScheduler();
    }

最终我们得到了一个继承自 Scheduler 的  IoScheduler(IoScheduler源码在下面)

 

这样两个部分我们都已经得到接下来就看他们之间是如何调用的

调用开始的地方是这行代码：subscribeActual中的scheduler.scheduleDirect(new SubscribeTask(parent))

首先发现 IoScheduler 中并没有 scheduleDirect 方法，是因为这个是在其父类Scheduler 实现的

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

    public abstract Worker createWorker();

    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit 
       unit) {
        核心代码 ↓  createWorker在Scheduler中是抽象方法具体实现在子类IoScheduler中
        final Worker w = createWorker();

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        DisposeTask task = new DisposeTask(decoratedRun, w);
        
        这里就是子类createWorker得到 Worker w 调用schedule
        task就是subscribeOn创建的Runnable
            ↓
        w.schedule(task, delay, unit);

        return task;
    }

}

public final class IoScheduler extends Scheduler {

    注释：createWorker创建并返回了一个EventLoopWorker对象
    public Worker createWorker() {
        return new EventLoopWorker(pool.get());
    }
                            ↓
    static final class EventLoopWorker extends Scheduler.Worker {
        
        private final ThreadWorker threadWorker;

        
        EventLoopWorker(CachedWorkerPool pool) {
            this.pool = pool;
            this.tasks = new CompositeDisposable();
            this.threadWorker = pool.get();
        }

        
        @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;
            }
            
            注释: threadWorker = pool.get(),
                  而pool.get()点进看到返回的是一个ThreadWorker
                  最终执行的是ThreadWorker.scheduleActual(action, delayTime, unit, tasks)
            return threadWorker.scheduleActual(action, delayTime, unit, tasks);
        }
    }
                            ↓
    static final class ThreadWorker extends NewThreadWorker {
        private long expirationTime;
        
        注释：但是在ThreadWorker 中并没有scheduleActual
             这个方法是在其父类NewThreadWorker中
        ThreadWorker(ThreadFactory threadFactory) {
            super(threadFactory);
            this.expirationTime = 0L;
        }

        public long getExpirationTime() {
            return expirationTime;
        }

        public void setExpirationTime(long expirationTime) {
            this.expirationTime = expirationTime;
        }
    }
      
}

下面就看NewThreadWorker 源码

public class NewThreadWorker extends Scheduler.Worker implements Disposable {

    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 {
            注释: 最后Runnable在这里执行
            if (delayTime <= 0) {
                f = executor.submit((Callable