间隔调度的RxJava可观察对象花费的时间比指定时间更长

Question

在以下代码中，可观察对象应该每300毫秒触发一次。 我通过模拟耗时1秒的背景活动来提高效果。 我期待着，因为我正在使用在下面使用线程池的调度程序，因此可观察到的间隔将每300毫秒不断触发一个新线程。 而是发生的是，可观察到的间隔每次等待一整秒，然后再次触发。 这是理想的行为吗？ 如果一项任务花费的时间超过了要求的时间，那么如何迫使它并行执行？

这是代码：

Observable
            .interval(300, TimeUnit.MILLISECONDS, Schedulers.io())
                .doOnNext(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        System.out.println("action thread: " + Thread.currentThread());
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                })
                .map(new Func1<Long, Float>() {
                    @Override
                    public Float call(Long aLong) {
                        final double result = Math.random();
                        return new Float(result);
                    }
                })
                .takeWhile(new Func1<Float, Boolean>() {
                    @Override
                    public Boolean call(Float aFloat) {
                        return aFloat >= 0.01f;
                    }
                })
            .subscribe(new Action1<Float>() {
                @Override
                public void call(Float aFloat) {
                    System.out.println("observing thread: " + Thread.currentThread());
                    System.out.println(aFloat);
                }
            });

Answer 1

可观察的对象本质上是顺序的，因此如果您像例中那样睡觉，则会阻塞整个序列。 要进行后台计算，您必须通过observeOn或subscribeOn将其移动到另一个线程。 在这种情况下，您可以在另一个可观察的可观察concatMapEager中进行flatMap / concatMapEager并将其合并回主序列：

Observable.interval(300, TimeUnit.MILLISECONDS)
.flatMap(t -> Observable.fromCallable(() -> { 
        Thread.sleep(1000);
     }).subscribeOn(Schedulers.io()))
.map(...)
.takeWhile(...)
.subscribe(...)