RxJava之timer和interval操作符源码解析

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

timer 操作符

• timer 操作符实际上返回的是一个 ObservableTimer对象。两个参数的方法默认在 Schedulers.computation()中工作。

   public static Observable timer(long delay, TimeUnit unit) {
       return timer(delay, unit, Schedulers.computation());
   }
   public static Observable timer(long delay, TimeUnit unit, Scheduler scheduler) {
       return RxJavaPlugins.onAssembly(new ObservableTimer(Math.max(delay, 0L), unit, scheduler));
   }
  

• ObservableTimer 源码：

  • 构建了 TimerObserver 对象。
  • 执行 观察者 的 onSubscribe 方法。
  • 通过scheduler.scheduleDirect(ios, delay, unit) 返回一个 Disposable 对象。
  • 将返回的 Disposable 对象传给 TimerObserver 对象的 setResource 方法

  public final class ObservableTimer extends Observable {
      final Scheduler scheduler;
      final long delay;
      final TimeUnit unit;
      public ObservableTimer(long delay, TimeUnit unit, Scheduler scheduler) {
          this.delay = delay;
          this.unit = unit;
          this.scheduler = scheduler;
      }
  
      @Override
      public void subscribeActual(Observer observer) {
          TimerObserver ios = new TimerObserver(observer);
          observer.onSubscribe(ios);
          Disposable d = scheduler.scheduleDirect(ios, delay, unit);
          ios.setResource(d);
      }
      ...
  }
  

• TimerObserver对象源码：

  static final class TimerObserver extends AtomicReference
  implements Disposable, Runnable {
  
      final Observer downstream;
  
      TimerObserver(Observer downstream) {
          this.downstream = downstream;
      }
      ...
      @Override
      public void run() {
          if (!isDisposed()) {
              downstream.onNext(0L);
              lazySet(EmptyDisposable.INSTANCE);
              downstream.onComplete();
          }
      }
  
      public void setResource(Disposable d) {
          DisposableHelper.trySet(this, d);
      }
  }
  

• 首先看 TimerObserver 的 setResource(Disposable d)方法 里的 DisposableHelper.trySet(this, d);：

  public static boolean trySet(AtomicReference field, Disposable d) {
      if (!field.compareAndSet(null, d)) {
          if (field.get() == DISPOSED) {
              d.dispose();
          }
          return false;
      }
      return true;
  }
  

  • d 不为 null，直接 return true；否则判断 是否为 DISPOSED 状态，是的话调用传进来的 Disposable 对象（也就是之前 Scheduler 构建的 DisposeTask 对象）的 dispose 方法。

• scheduler.scheduleDirect(ios, delay, unit) 方法：

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

  • 首先创建了一个 Worker，因为默认是 Schedulers.computation()中工作，查看源码可知 实际调用的是 ComputationScheduler 的 createWorker 方法 。
    Schedulers：

    ...
    static final class ComputationHolder {
        static final Scheduler DEFAULT = new ComputationScheduler();
    }
    ...
    static {
        COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());
        ...
    }
    
    static final class ComputationTask implements Callable {
        @Override
        public Scheduler call() throws Exception {
            return ComputationHolder.DEFAULT;
        }
    }
    

    RxJavaPlugins：

    public static Scheduler initComputationScheduler(@NonNull Callable defaultScheduler) {
        ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");
        Function, ? extends Scheduler> f = onInitComputationHandler;
        if (f == null) {
            return callRequireNonNull(defaultScheduler);
        }
        return applyRequireNonNull(f, defaultScheduler); // JIT will skip this
    }
    
    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);
        }
    }
    

    f 默认为 null，所以返回的是 callRequireNonNull(defaultScheduler)，然后实际调用的是 ComputationTask 的 call 方法。返回的即为 ComputationScheduler 对象。

  • ComputationScheduler 的 createWorker 方法 。

    public ComputationScheduler() {
        this(THREAD_FACTORY);
    }
    
    public ComputationScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
        this.pool = new AtomicReference(NONE);
        start();
    }
    
    public Worker createWorker() {
        return new EventLoopWorker(pool.get().getEventLoop());
    }
    

    • pool.get()通过构造函数我们可知返回的为 NONE = new FixedSchedulerPool(0, THREAD_FACTORY); 所以 pool.get().getEventLoop() 返回的为 SHUTDOWN_WORKER = new PoolWorker(new RxThreadFactory("RxComputationShutdown"));。实际上是创建了一个 executor 为 Executors.newScheduledThreadPool(1, factory) ，即 factory 为 RxThreadFactory("RxComputationShutdown") 的 单线程线程池对象 的 PoolWorker对象

      FixedSchedulerPool(int maxThreads, ThreadFactory threadFactory) {
          this.cores = maxThreads;
          this.eventLoops = new PoolWorker[maxThreads];
          for (int i = 0; i < maxThreads; i++) {
              this.eventLoops[i] = new PoolWorker(threadFactory);
          }
      }
      public PoolWorker getEventLoop() {
          int c = cores;
          if (c == 0) {
              return SHUTDOWN_WORKER;
          }
          return eventLoops[(int)(n++ % c)];
      }
      

    • 所以createWorker 返回的是：poolWorker 是 factory 为 RxThreadFactory("RxComputationShutdown") 的 单线程线程池对象 的 PoolWorker对象

      static final class EventLoopWorker extends Scheduler.Worker {
          private final ListCompositeDisposable serial;
          private final CompositeDisposable timed;
          private final ListCompositeDisposable both;
          private final PoolWorker poolWorker;
      
          volatile boolean disposed;
      
          EventLoopWorker(PoolWorker poolWorker) {
              this.poolWorker = poolWorker;
              this.serial = new ListCompositeDisposable();
              this.timed = new CompositeDisposable();
              this.both = new ListCompositeDisposable();
              this.both.add(serial);
              this.both.add(timed);
          }
      ...
      

  • decoratedRun 即为 TimerObserver 对象。

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

  • 然后构建了一个 DisposeTask 对象。

    static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {
        final Runnable decoratedRun;
        final Worker w;
        Thread runner;
    
        DisposeTask(@NonNull Runnable decoratedRun, @NonNull Worker w) {
            this.decoratedRun = decoratedRun;
            this.w = w;
        }
    
        @Override
        public void run() {
            runner = Thread.currentThread();
            try {
                decoratedRun.run();
            } finally {
                dispose();
                runner = null;
            }
        }
        ...
    }
    

  • createWorker 返回的 poolWorker 是 factory 为 RxThreadFactory("RxComputationShutdown") 的 单线程线程池对象 的 PoolWorker对象，并执行 schedule 方法。
    实际上是执行了 单线程线程池对象 Executors.newScheduledThreadPool(1, factory) 的 schedule(task, delayTime, unit)方法，并将返回值 Future 对象 传给ScheduledRunnable 的 setFuture 方法。

    public Disposable schedule(@NonNull final Runnable action, long delayTime, @NonNull TimeUnit unit) {
        if (disposed) {
            return EmptyDisposable.INSTANCE;
        }
        return scheduleActual(action, delayTime, unit, null);
    }
    
    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) {
                f = executor.submit((Callable