RxJava2 实战知识梳理(9) - 使用 timer/interval/delay 实现任务调度

RxJava2 实战系列文章

其实在之前的文章中，我们已经接触过定时/周期执行任务的操作符，例如在 RxJava2 实战知识梳理(5) - 简单及进阶的轮询操作和 RxJava2 实战知识梳理(6) - 基于错误类型的重试请求这两篇文章当中，我们通过 intervalRange 实现了轮询工作，通过 timer 实现了延时的重试请求。

今天这篇文章，我们根据 RxJava-Android-Samples 中总结的几种场景来复习一下可以实现定时调度任务的操作符：


          timer

：创建型操作符，用于延时执行任务。


          interval

：创建型操作符，用于周期执行任务。


          delay

：辅助型操作，用于延时传递数据。

二、timer

2.1 timer 操作符原理

timer 原理图如下所示：

timer 原理图

很简单，在订阅之后，它会在等待一段时间之后发射一个

数据项，然后结束，因此它常常可以用来延时地发送时间，例如 RxJava2 实战知识梳理(5) - 简单及进阶的轮询操作中，我们使用


          repeatWhen

发起重订阅时，就是通过


          timer

实现了延时发送


          onNext

时间来实现时延变长的轮询操作。

2.2 使用 timer 延时 1s 后执行任务，然后结束

我们使用 timer 操作符实现下面的效果：延时 1s 后在子线程执行任务，接着完成，这里我们采用了 timer ，并通过 subscribe 方法让下游运行在子线程当中。

    //延迟 1s 后执行一个任务，然后结束
    private void startTimeDemo1() {
        Log.d(TAG, "startTimeDemo1");
        DisposableObserver<Long> disposableObserver = getTimeDemoObserver();
        Observable.timer(1000, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.io()).subscribe(disposableObserver);
        mCompositeDisposable.add(disposableObserver);
运行结果为：
interval也是一个创建型操作符，它可以间隔一段时间就发送一个数据。
3.2 每隔 1s 执行一次任务，第一次任务执行前有 1s 的间隔，执行无限次
我们先使用interval实现下面这个效果：每隔1s执行一次任务，第一次任务执行前有1s的间隔，执行无限次。这是因为，使用interval操作符时，默认第一次个任务需要延时和指定间隔相同的时间。
    //每隔 1s 执行一次任务，第一次任务执行前有 1s 的间隔，执行无限次
    private void startTimeDemo2() {
        Log.d(TAG, "startTimeDemo2");
        DisposableObserver<Long> disposableObserver = getTimeDemoObserver();
        Observable.interval(1000, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.io()).subscribe(disposableObserver);
        mCompositeDisposable.add(disposableObserver);
运行结果如下所示：
3.3 每隔 1s 执行一次任务，立即执行第一次任务，执行无限次
如果希望立即执行第一次任务，那么可以给它提供额外的参数，指定第一次任务的延时：
    //每隔 1s 执行一次任务，立即执行第一次任务，执行无限次
    private void startTimeDemo3() {
        Log.d(TAG, "startTimeDemo3");
        DisposableObserver<Long> disposableObserver = getTimeDemoObserver();
        Observable.interval(0, 1000, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.io()).subscribe(disposableObserver);
        mCompositeDisposable.add(disposableObserver);
运行结果为：
3.4 每隔 1s 执行一次任务，立即执行第一次任务，只执行五次
在3.3的例子中，我们的任务会无限执行下去，如果我们希望只执行指定次数该怎么办呢，其实在 RxJava2 实战知识梳理(5) - 简单及进阶的轮询操作 中演示固定时延的轮询操作时，我们已经介绍了使用intervalRange来实现，今天，我们采用interval + take的方式来实现，代码如下：
    //每隔 1s 执行一次任务，立即执行第一次任务，只执行五次
    private void startTimeDemo4() {
        Log.d(TAG, "startTimeDemo4");
        DisposableObserver<Long> disposableObserver = getTimeDemoObserver();
        Observable.interval(0, 1000, TimeUnit.MILLISECONDS).take(5).subscribe(disposableObserver);
        mCompositeDisposable.add(disposableObserver);
运行结果为：

当它接受一个时间段时，每当原始的Observable发射了一个数据项时，它就启动一个定时器，等待指定的时间后再将这个数据发射出去，因此表现为发射的数据项进行了平移，但是它只会平移onNext/onComplete，对于onError，它会立即发射出去，并且丢弃之前等待发射的onNext事件。

4.2 先执行一个任务，等待 1s，再执行另一个任务，然后结束
因为delay不是创建型操作符，所以我们可以用来延迟上游发射过来的数据，下面，让我们实现这个效果：先执行一个任务，等待 1s，再执行另一个任务，然后结束。代码如下：
    //先执行一个任务，等待 1s，再执行另一个任务，然后结束
    private void startTimeDemo5() {
        Log.d(TAG, "startTimeDemo5");
        DisposableObserver<Long> disposableObserver = getTimeDemoObserver();
        Observable.just(0L).doOnNext(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.d(TAG, "执行第一个任务");
        }).delay(1000, TimeUnit.MILLISECONDS).subscribe(disposableObserver);
        mCompositeDisposable.add(disposableObserver);
执行效果为：