Question

在kotlin上使用Android应用程序。

我需要设置一个系统，以便能够从实时队列中进行工作（并观察流中工作的结果）。

但我也必须能够切换＆＃34;队列处理＆＃34;取决于一些外部因素（也以流形式出现），如Observable.fromIterable()。

我无法使用Subject<Boolean>?，因为它会立即创建可迭代的内容，此队列将会调整，并且项目可能会被删除。

我需要某种循环来完成项目，检查以确保我们继续前进，然后弹出队列的第一项并执行此操作。

我不确定怎么在订阅中做这样的循环？

队列也可以变空，当重新打开切换时，事情应该重新开始。

也许我应该将这个决定（关于是否处理队列中的下一个项目）推送到var search = instantsearch({ [...], searchParameters: { hierarchicalFacetsRefinements: { // menu is implemented as a hierarchicalFacetsRefinements categories: ['Cell Phones'] }, facetsRefinements: { isPremium: [true] }, disjunctiveFacetsRefinements: { brand: ['Samsung', 'Apple'] }, // Add to "facets" all attributes for which you // do NOT have a widget defined facets: ['isPremium'] }, }); // Below is just a common widget configuration, to show // how it interacts with the above searchParameters search.addWidget( instantsearch.widgets.menu({ [...], attributeName: 'categories' }) ); search.addWidget( instantsearch.widgets.refinementList({ attributeName: 'brand', operator: 'or' }) );，然后订阅该主题再次启动该过程？

的示例：

开启----进程队列顶部，进程队列顶部（以前被轮询掉队列）---关闭 - 不再处理

重新开启 - 处理队列顶部，队列为空 - 停止

将项目添加到队列 - 进程 - 停止队列空白

开启处理 - 将项目添加到队列中 - 直到其重新开启

才进行处理

开启 - 处理热门项目

Answer 1

您可以使用RxJava2Extensions中的valve()运算符。

public PublishProcessor<Boolean> flowControl = PublishProcessor.create();

public void start() {
    Flowable./*...*/
            .compose(FlowableTransformers.valve(flowControl))
            .subscribe(/*...*/);

在这种情况下，flowControl.onNext(true)将启动流，flowControl.onNext(false)将停止并排队。

（必须将任何其他Rx2类型转换为Flowable才能使用它。）

Answer 2

我最近一直在处理这个问题（在管理NIO选择键时听压力），并集中在一个使用普通运算符的相对简单的解决方案上：

Queue<T> queue;

// This controls whether the queue is being polled or not.
// It's probably a good idea to make sure this emits the last value upon
// subscription using a BehaviorProcessor or a ReplayFlowable etc.
Flowable<Boolean> condition;

// This is a "dumb" generator which continuously polls the queue and emits items
Flowable<T> generator = Flowable.generate(emitter -> {
    T item = queue.poll();
    if (item != null) {
        emitter.onNext(item);
    }
});

// We wire our generator and condition together to achieve the expected result.
Flowable<T> drainWhileCondition = condition.distinctUntilChanged()
    .concatMap(c -> c
        ? generator.takeUntil(condition.filter(Boolean.FALSE::equals))
        : Flowable.empty());

您也可以为此创建一个转换器方法：

static <T> FlowableTransformer<T, T> valve(Flowable<Boolean> condition) {
    return upstream -> condition.distinctUntilChanged()
            .concatMap(c -> c
                    ? upstream.takeUntil(condition.filter(Boolean.FALSE::equals))
                    : Flowable.empty());
}

并像这样使用它：

Flowable<T> generator;
Flowable<Boolean> condition;

Flowable<T> valvedGenerator = generator.compose(valve(condition));

RxJava Live Reactive Queue（带开关）

2 个答案: