Rx java 永远定期运行的时间间隔

好的，通常可以使用

Observable.interval（1，TimeUnit.SECONDS）

创建一个每秒都会发出值的Observable

但是

interval

发出一个整数值。如果我们让它一直运行到“NT_MAX”，会发生什么？溢油

是否有一个运算符可以执行同样的操作，即周期性地在没有计数器的情况下发出一个值

---

基本上，我只是想要一个可观察的计划周期性的工作。。。实际上，

interval

发出一个

Long

值，并在内部使用一个

Long

计数器。在实践中，你永远不会达到

Long.MAX_值（每纳秒发出一个值，需要292年才能溢出）
 
间隔
返回
可观察的
。所以计数器显示的值很长

如果我们让它一直运行到LONG_MAX，就会发生溢出。但是
interval
不会停止。
interval
将继续发出如下值：

public class OnSubscribeNoCounterTimerPeriodically  implements Observable.OnSubscribe<Void> {
    final long initialDelay;
    final long period;
    final TimeUnit unit;
    final Scheduler scheduler;

    public OnSubscribeNoCounterTimerPeriodically(long period, TimeUnit unit) {
        this(period, period, unit, Schedulers.computation());
    }

    public OnSubscribeNoCounterTimerPeriodically(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
        this.initialDelay = initialDelay;
        this.period = period;
        this.unit = unit;
        this.scheduler = scheduler;
    }

    @Override
    public void call(final Subscriber<? super Void> child) {
        final Scheduler.Worker worker = scheduler.createWorker();
        child.add(worker);
        worker.schedulePeriodically(new Action0() {
            @Override
            public void call() {
                try {
                    child.onNext(null);
                } catch (Throwable e) {
                    try {
                        worker.unsubscribe();
                    } finally {
                        Exceptions.throwOrReport(e, child);
                    }
                }
            }

        }, initialDelay, period, unit);
    }
}

Observable.create(new OnSubscribeNoCounterTimerPeriodically(1, TimeUnit.SECONDS))


9223372036854775807
-9223372036854775808
-9223372036854775807

如果希望
interval
不带计数器，请按如下方式创建
OnSubscribe
：

public class OnSubscribeNoCounterTimerPeriodically  implements Observable.OnSubscribe<Void> {
    final long initialDelay;
    final long period;
    final TimeUnit unit;
    final Scheduler scheduler;

    public OnSubscribeNoCounterTimerPeriodically(long period, TimeUnit unit) {
        this(period, period, unit, Schedulers.computation());
    }

    public OnSubscribeNoCounterTimerPeriodically(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
        this.initialDelay = initialDelay;
        this.period = period;
        this.unit = unit;
        this.scheduler = scheduler;
    }

    @Override
    public void call(final Subscriber<? super Void> child) {
        final Scheduler.Worker worker = scheduler.createWorker();
        child.add(worker);
        worker.schedulePeriodically(new Action0() {
            @Override
            public void call() {
                try {
                    child.onNext(null);
                } catch (Throwable e) {
                    try {
                        worker.unsubscribe();
                    } finally {
                        Exceptions.throwOrReport(e, child);
                    }
                }
            }

        }, initialDelay, period, unit);
    }
}

Observable.create(new OnSubscribeNoCounterTimerPeriodically(1, TimeUnit.SECONDS))

在实践中，您将无法达到Long.MAX_值。这个数字太大了，我也这么认为。我只是回答问题。