RxJava之Schedulers源码介绍

转载请以链接形式标明出处：
本文出自:103style的博客

Base on RxJava 2.X

简介

RxJava 的 Schedulers 提供了以下五种 Scheduler（调度器）：

• SINGLE
• COMPUTATION
• IO
• NEW_THREAD
• TRAMPOLINE

static {
    SINGLE = RxJavaPlugins.initSingleScheduler(new SingleTask());
    COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());
    IO = RxJavaPlugins.initIoScheduler(new IOTask());
    NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
    TRAMPOLINE = TrampolineScheduler.instance();
}

---

以 Schedulers.single() 为例介绍

如果我们没有调用 setInitXXSchedulerHandler 或者 setXXSchedulerHandler 自己实现调度器的话(XX 代表上面除了 TRAMPOLINE 的四种调度器的名字)，我们开发中用到的 Schedulers.io(); Schedulers.computation(); Schedulers.newThread(); Schedulers.single(); 实际上就是对应的 XXTask 的 call()方法返回的 Scheduler 对象，即对应的 XXScheduler 对象。

public static void setInitSingleSchedulerHandler(@Nullable Function, ? extends Scheduler> handler) {
    if (lockdown) {
        throw new IllegalStateException("Plugins can't be changed anymore");
    }
    onInitSingleHandler = handler;
}

public static void setSingleSchedulerHandler(@Nullable Function handler) {
    if (lockdown) {
        throw new IllegalStateException("Plugins can't be changed anymore");
    }
    onSingleHandler = handler;
}

以下是 Schedulers.single() 的源码介绍：

• onSingleScheduler() 中的 onSingleHandler 是通过 setSingleSchedulerHandler() 设置的，默认为 Null ，所以即返回 SINGLE。

  public static Scheduler single() {
      return RxJavaPlugins.onSingleScheduler(SINGLE);
  }
  
  public static Scheduler onSingleScheduler(@NonNull Scheduler defaultScheduler) {
    Function f = onSingleHandler;
      if (f == null) {
          return defaultScheduler;
      }
      return apply(f, defaultScheduler);
  }
  

• SINGLE 是静态常量，通过 RxJavaPlugins.initSingleScheduler(new SingleTask()); 初始化。

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

• initSingleScheduler() 中的 onInitSingleHandler 是通过 setInitSingleSchedulerHandler() 设置的，默认为 Null ，所以即调用 callRequireNonNull(new SingleTask())。

  public static Scheduler initSingleScheduler(@NonNull Callable defaultScheduler) {
      ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");
      Function, ? extends Scheduler> f = onInitSingleHandler;
      if (f == null) {
          return callRequireNonNull(defaultScheduler);
      }
      return applyRequireNonNull(f, defaultScheduler);
  }
  

• callRequireNonNull(new SingleTask()) 即返回 SingleTask对象的 call 方法。

  static Scheduler callRequireNonNull(@NonNull Callable s) {
      try {
          return ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't be null");
      } catch (Throwable ex) {
          throw ExceptionHelper.wrapOrThrow(ex);
      }
  }
  
  static final class SingleTask implements Callable {
      @Override
      public Scheduler call() throws Exception {
          return SingleHolder.DEFAULT;
      }
  }
  

• 即创建了一个 SingleScheduler 对象。

  static final class SingleHolder {
      static final Scheduler DEFAULT = new SingleScheduler();
  }
  

所以 Schedulers.single() 实际返回的是 SingleScheduler 对象.
同样的：
Schedulers.io(); 实际返回的是 IoScheduler 对象
Schedulers.computation(); 实际返回的是 ComputationScheduler 对象
Schedulers.newThread(); 实际返回的是 NewThreadScheduler 对象

---

SingleScheduler 源码介绍

public final class SingleScheduler extends Scheduler {
    final ThreadFactory threadFactory;
    final AtomicReference executor = new AtomicReference();

    private static final String KEY_SINGLE_PRIORITY = "rx2.single-priority";
    private static final String THREAD_NAME_PREFIX = "RxSingleScheduler";

    static final RxThreadFactory SINGLE_THREAD_FACTORY;

    static final ScheduledExecutorService SHUTDOWN;
    static {
        SHUTDOWN = Executors.newScheduledThreadPool(0);
        SHUTDOWN.shutdown();

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

        SINGLE_THREAD_FACTORY = new RxThreadFactory(THREAD_NAME_PREFIX, priority, true);//1.1
    }

    public SingleScheduler() { //1.0
        this(SINGLE_THREAD_FACTORY);
    }

    public SingleScheduler(ThreadFactory threadFactory) {//2.0
        this.threadFactory = threadFactory;
        executor.lazySet(createExecutor(threadFactory));//4.0
    }

    static ScheduledExecutorService createExecutor(ThreadFactory threadFactory) {//3.0
        return SchedulerPoolFactory.create(threadFactory);
    }
    ...
}

• (1.0)默认的构造方法，传入了一个 SINGLE_THREAD_FACTORY的静态常量。(1.1)我们可以看到它是在初始化为 new RxThreadFactory("RxSingleScheduler", 5 , true); 即为 线程名称前缀 为 RxSingleScheduler，优先级为5 不阻塞 的 RxThreadFactory 对象。
• (2.0)然后设置当前的 threadFactory 为此 RxThreadFactory 对象。
• (3.0)然后通过SchedulerPoolFactory.create(threadFactory)创建了一个执行者。
  (3.1)即通过 Executors.newScheduledThreadPool(1, factory)创建了一个核心线程数为 1 的 ScheduledExecutorService(调度线程池)。
  (3.2)并将ScheduledExecutorService 放进 SchedulerPoolFactory的 key 为 ScheduledThreadPoolExecutor的 Map 集合 POOLS中。

  // Upcast to the Map interface here to avoid 8.x compatibility issues.
  // See http://stackoverflow.com/a/32955708/61158
  //这个用map接口是为了解决java8的一个bug，具体可以点击上面的链接查看
  static final Map POOLS =
          new ConcurrentHashMap();
  
  public static ScheduledExecutorService create(ThreadFactory factory) {
      final ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, factory);//3.1
      tryPutIntoPool(PURGE_ENABLED, exec);
      return exec;
  }
  
  static void tryPutIntoPool(boolean purgeEnabled, ScheduledExecutorService exec) {
      if (purgeEnabled && exec instanceof ScheduledThreadPoolExecutor) {
          ScheduledThreadPoolExecutor e = (ScheduledThreadPoolExecutor) exec;
          POOLS.put(e, exec);//3.2
      }
  }
  

• (4.0)然后 将 AtomicReference 对象 executor 的 value 设置为上面创建的 ScheduledExecutorService。

我们之前在 Rxjava之timer和interval操作符源码解析 介绍过 timer操作符在订阅的时候会执行ObservableTimer的 subscribeActual 方法，

public void subscribeActual(Observer observer) {
    TimerObserver ios = new TimerObserver(observer);
    observer.onSubscribe(ios);
    Disposable d = scheduler.scheduleDirect(ios, delay, unit);
    ios.setResource(d);
}

其中的 scheduler.scheduleDirect(ios, delay, unit)中 会通过createWorker()创建一个 Worker。

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

• 我们来看看 SingleScheduler的 createWorker()：

  public Worker createWorker() {
      return new ScheduledWorker(executor.get()); 
  }
  
  static final class ScheduledWorker extends Scheduler.Worker {
      final ScheduledExecutorService executor;
      final CompositeDisposable tasks;
      ScheduledWorker(ScheduledExecutorService executor) {
          this.executor = executor;
          this.tasks = new CompositeDisposable();
      }
      ...
  }
  

  • 通过executor.get()获取 AtomicReference 的value值，通过上面的SingleScheduler 源码(4.0)的介绍，即获取到的是核心线程数为1的 ScheduledExecutorService。
  • 然后将其赋值给 ScheduledWorker的 executor。

• 然后我们看看w.schedule(task, delay, unit)：

  public Disposable schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
      if (disposed) {
          return EmptyDisposable.INSTANCE;
      }
      Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
      ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, tasks);
      tasks.add(sr);
      try {
          Future f;
          if (delay <= 0L) {
              f = executor.submit((Callable