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

1、前言

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

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

• timer：建立型操做符，用于延时执行任务。
• interval：建立型操做符，用于周期执行任务。
• delay：辅助型操做，用于延时传递数据。

2、timer

2.1 timer 操做符原理

timer原理图以下所示：

很简单，在订阅以后，它会在等待一段时间以后发射一个 0数据项，而后结束，所以它经常能够用来延时地发送时间，例如 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);
    }
复制代码

运行结果为：

3、interval

3.1 interval 原理

interval的原理图以下所示：

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);
    }
复制代码

运行结果为：

take的原理图以下所示：

它表示咱们只接受前 n个数据项，这样和 interval结合就能够实现固定间隔与固定次数的任务执行。

4、delay

4.1 delay 原理

delay的原理图以下所示：

当它接受一个时间段时，每当原始的 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);
    }
复制代码

执行效果为：

---

更多文章，欢迎访问个人 Android 知识梳理系列：

• Android 知识梳理目录：www.jianshu.com/p/fd82d1899…
• 我的主页：lizejun.cn
• 我的知识总结目录：lizejun.cn/categories/