Question

我有一个问题，其中Reactive Extensions似乎特别适合。我有一个事件源，它在短时间内创建事件，中间有相对较长的空闲时间。我想分批对这些事件进行分组，其中（理想情况下）每一系列事件最终会在一批中结束。使用RxJava，有一个很好的方法吗？ Observable.buffer(Observable)或Observable.buffer(Func0)似乎很有希望，但可以使用Observable.window()或Observable.groupByUntil（）。

Answer 1

以下代码似乎适用于去抖缓冲区：

import java.util.List;
import java.util.concurrent.TimeUnit;

import rx.Observable;
import rx.Subscriber;
import rx.schedulers.Schedulers;

public class DebounceBuffer {

    public static void main(String args[]) {
        // see all bursts in a single sequence
        //        intermittentBursts().toBlocking().forEach(System.out::println);

        // debounce to the last value in each burst
        //        intermittentBursts().debounce(10, TimeUnit.MILLISECONDS).toBlocking().forEach(System.out::println);

        /* The following will emit a buffered list as it is debounced */
        // first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe
        Observable<Integer> burstStream = intermittentBursts().publish().refCount();
        // then we get the debounced version
        Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS);
        // then the buffered one that uses the debounced stream to demark window start/stop
        Observable<List<Integer>> buffered = burstStream.buffer(debounced);
        // then we subscribe to the buffered stream so it does what we want
        buffered.take(20).toBlocking().forEach(System.out::println);
    }

    public static Observable<Integer> intermittentBursts() {
        return Observable.create((Subscriber<? super Integer> s) -> {
            while (!s.isUnsubscribed()) {
                // burst some number of items
                for (int i = 0; i < Math.random() * 20; i++) {
                    s.onNext(i);
                }
                try {
                    // sleep for a random amount of time
                    Thread.sleep((long) (Math.random() * 1000));
                } catch (Exception e) {
                    // do nothing
                }
            }
        }).subscribeOn(Schedulers.newThread()); // use newThread since we are using sleep to block
    }

}

它会发出以下内容：

[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1]
[0, 1, 2, 3, 4, 5]
[0, 1, 2]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3, 4]
[0, 1, 2, 3]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3]
[0]
[0, 1, 2]
[0]

Answer 2

您提到的任何运算符都可以工作，它只取决于您想要的语义。

如果您希望每个组都是List，请使用缓冲区：https://github.com/Netflix/RxJava/wiki/Transforming-Observables#buffer

如果您希望每个组都是一个序列然后使用窗口：https://github.com/Netflix/RxJava/wiki/Transforming-Observables#window

这两者非常相似，只是它们的输出不同。窗口允许您在发出时处理每个组中的每个项目，而缓冲区将等待，直到收集组中的所有项目然后发出。因此，如果要将每个组中的所有项目一起处理，请使用缓冲区。或者，窗口可以与扫描结合使用，在每个窗口中按顺序处理项目，并在它们发出时对它们进行有状态操作。

groupByUntil可能不是你想要的，如果你正在分组时间，因为groupBy / groupByUntil是关于键的分组。

我可以通过缓冲区/窗口看到的一个问题是它们通常具有固定的间隔，或者需要您在窗口开始和结束时通过另一个Observable指定。你似乎想要在闲置一段时间之后触发的东西，这更像是去抖动，但是去抖只会给你最后一个值，而不是整个组。

你可以通过组播流，通过缓冲器路由一个，通过去抖动，并使用去抖输出来指示窗口的开始/结束点，来完成这些的复杂组合。这很棘手但我从未尝试过。

现有的缓冲区/窗口用例是否适用于您，或者您是否需要bufferedDebounce行为？

如何使用Reactive Extensions按空闲时段对事件进行分组

2 个答案: