RxJava操作符-Timer

Observable.timer(1,TimeUnit.SECONDS)
        .subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.d(TAG, "当前值为 " + aLong);
            }
        });

例子如上，那么同其他操作符一样 timer 也会包装成Observable,

public static Observable<Long> timer(long delay, TimeUnit unit) {
    return timer(delay, unit, Schedulers.computation());
}
public static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler) {
    ObjectHelper.requireNonNull(unit, "unit is null");
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableTimer(Math.max(delay, 0L), unit, scheduler));
}

生成了ObservableTimer，如果没有指定调度器，那么默认的调度器为Schedulers.computation() 接着继续看subscribe方法，仍然是在Observable中

—>Observable.java

public final Disposable subscribe(Consumer<? super T> onNext) {
    return subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
        Action onComplete, Consumer<? super Disposable> onSubscribe) {
   ***继续对程序中的匿名consumer类包装成LambdaObserver
    LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
  
    subscribe(ls);
    return ls;
}
public final void subscribe(Observer<? super T> observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);
**** subscribeActual 将会在ObservableTimer中执行****
        subscribeActual(observer);
    } 
//异常处理
    }
}

—>ObservableTimer.java

@Override
public void subscribeActual(Observer<? super Long> observer) {
**将LambdaObserver进一步包装成TimerObserve**
    TimerObserver ios = new TimerObserver(observer);
    observer.onSubscribe(ios);
执行scheduler的scheduleDirect方法，也就是ComputationScheduler的sscheduleDirect
    Disposable d = scheduler.scheduleDirect(ios, delay, unit);
    ios.setResource(d);
}

——》ComputationScheduler.java

public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) {
    PoolWorker w = pool.get().getEventLoop();
****W是NewThreadWorker**
    return w.scheduleDirect(run, delay, unit);
}

—>NewThreadWorker.java

public Disposable scheduleDirect(final Runnable run, long delayTime, TimeUnit unit) {
    ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run));
    try {
        Future<?> f;
        if (delayTime <= 0L) {
        executor实际上是ScheduledExecutorService
            f = executor.submit(task);
        } else {
 执行此方法，那么在delayTime后，还行Runnable的run,也就是传入的TimerObserver的run方法
            f = executor.schedule(task, delayTime, unit);
        }
        task.setFuture(f);
        return task;
    } catch (RejectedExecutionException ex) {
        RxJavaPlugins.onError(ex);
        return EmptyDisposable.INSTANCE;
    }
}
private final ScheduledExecutorService executor

—>TimerObserver.java

@Override
public void run() {
    if (!isDisposed()) {
    ****downstream 是 LambdaObserver
        downstream.onNext(0L);
        lazySet(EmptyDisposable.INSTANCE);
        downstream.onComplete();
    }
}

——》LambdaOberver

@Override
public void onNext(T t) {
    if (!isDisposed()) {
        try {
            onNext.accept(t);
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            get().dispose();
            onError(e);
        }
    }
}

——》调用的具体类了