Android flatMapFirst:flatMap，仅当前一个观察值结束时才添加新的观察值
如何实现类似于Android flatMapFirst:flatMap，仅当前一个观察值结束时才添加新的观察值,android,rx-java,rx-java2,Android,Rx Java,Rx Java2,如何实现类似于flatMap的flatMapFirst操作符，但仅在前一个操作符结束时添加新的可观察对象？如果前一个仍在运行，它只会忽略新的可观察对象。如何在rxjava2中实现它 它已经存在于培根- 在凯菲尔- 您不需要新的运营商，而是需要现有运营商的组合： source.onBackpressureLatest().flatMap(function, 1) FlatMap将一次运行1个内部源，如果在FlatMap运行1个内部源时没有需求，onBackpressureLatest将继续删除外
flatMapflatMapFirst您不需要新的运营商，而是需要现有运营商的组合：
source.onBackpressureLatest().flatMap(function, 1)
如果您不想继续从源代码中获得最新的可用性，请考虑使用<代码> OnButlook PraseRead < /COD>。
< P>不需要新的操作符，但现有的组合：source.onBackpressureLatest().flatMap(function, 1)
如果您不想继续从源代码中获得最新的可用性，请考虑使用<代码> OnButlook PraseRead < /C> >。
后续。如果您想在RxJava 2
中使用flatMapFirst
，而不是Flowable
，下面是一个快速的Kotlin实现：
fun <T, R> Observable<T>.flatMapFirst(transform: (T) -> Observable<R>) =
toFlowable(BackpressureStrategy.DROP)
.flatMap({ transform(it).toFlowable(BackpressureStrategy.BUFFER) }, 1)
.toObservable()
fun Observable.flatMapFirst（转换：（T）->Observable）=
toFlowable（背压稳定下降）
.flatMap（{transform（it）.toFlowable（BackpressureStrategy.BUFFER）}，1）
.TooObservable（）文件
UPD.基于David Karnok建议的替代实施方案：
fun <T, R> Observable<T>.flatMapFirst(transform: (T) -> Observable<R>) =
Observable.defer {
val busy = AtomicBoolean()
return@defer this
.filter { busy.compareAndSet(false, true) }
.flatMap {
transform(it).doAfterTerminate { busy.set(false) }
}
}
fun Observable.flatMapFirst（转换：（T）->Observable）=
可观察的{
val busy=AtomicBoolean（）
return@defer这
.filter{busy.compareAndSet（false，true）}
.平面图{
transform（it）.doAfterTerminate{busy.set（false）}
}
}
一项后续行动。如果您想在RxJava 2中使用flatMapFirst
，而不是Flowable
，下面是一个快速的Kotlin实现：
fun <T, R> Observable<T>.flatMapFirst(transform: (T) -> Observable<R>) =
toFlowable(BackpressureStrategy.DROP)
.flatMap({ transform(it).toFlowable(BackpressureStrategy.BUFFER) }, 1)
.toObservable()
fun Observable.flatMapFirst（转换：（T）->Observable）=
toFlowable（背压稳定下降）
.flatMap（{transform（it）.toFlowable（BackpressureStrategy.BUFFER）}，1）
.TooObservable（）文件
UPD.基于David Karnok建议的替代实施方案：
fun <T, R> Observable<T>.flatMapFirst(transform: (T) -> Observable<R>) =
Observable.defer {
val busy = AtomicBoolean()
return@defer this
.filter { busy.compareAndSet(false, true) }
.flatMap {
transform(it).doAfterTerminate { busy.set(false) }
}
}
fun Observable.flatMapFirst（转换：（T）->Observable）=
可观察的{
val busy=AtomicBoolean（）
return@defer这
.filter{busy.compareAndSet（false，true）}
.平面图{
transform（it）.doAfterTerminate{busy.set（false）}
}
}
我成功地解决了这个问题：
/**
* Flatmaps upstream items into [source] items.
* Ignores upstream items if there is any [source] instance currently running.
*
* ```
* upstream ----u-----u---u-------u---------------|-->
* ↓ ↓ ↓
* source ---s-------|-> ---s-------|-> ↓
* ↓ ↓ ↓
* result -------s-----------------s------------|-->
* ```
*/
fun <T, R> Observable<T>.flatMapWithDrop(source: Observable<R>): Observable<R> {
return this.toFlowable(BackpressureStrategy.DROP)
.flatMap({ source.toFlowable(BackpressureStrategy.MISSING) }, 1)
.toObservable()
}
/**
*Flatmaps将上游项目映射到[源]项目。
*如果当前正在运行任何[source]实例，则忽略上游项。
*
* ```
*上游----u----u----u----u----u--------->
* ↓ ↓ ↓
*来源--s-------->--s-------->↓
* ↓ ↓ ↓
*结果------s-----------s---------------|-->
* ```
*/
有趣的可观察。flatMapWithDrop（来源：Observable）：可观察{
返回此.toFlowable（背压等级下降）
.flatMap（{source.toFlowable（BackpressureStrategy.MISSING）}，1）
.TooObservable（）文件
}
我成功地解决了这个问题：
/**
* Flatmaps upstream items into [source] items.
* Ignores upstream items if there is any [source] instance currently running.
*
* ```
* upstream ----u-----u---u-------u---------------|-->
* ↓ ↓ ↓
* source ---s-------|-> ---s-------|-> ↓
* ↓ ↓ ↓
* result -------s-----------------s------------|-->
* ```
*/
fun <T, R> Observable<T>.flatMapWithDrop(source: Observable<R>): Observable<R> {
return this.toFlowable(BackpressureStrategy.DROP)
.flatMap({ source.toFlowable(BackpressureStrategy.MISSING) }, 1)
.toObservable()
}
/**
*Flatmaps将上游项目映射到[源]项目。
*如果当前正在运行任何[source]实例，则忽略上游项。
*
* ```
*上游----u----u----u----u----u--------->
* ↓ ↓ ↓
*来源--s-------->--s-------->↓
* ↓ ↓ ↓
*结果------s-----------s---------------|-->
* ```
*/
有趣的可观察。flatMapWithDrop（来源：Observable）：可观察{
返回此.toFlowable（背压等级下降）
.flatMap（{source.toFlowable（BackpressureStrategy.MISSING）}，1）
.TooObservable（）文件
}
它似乎与onBackpressureDrop（）一起工作，而不是与OnBackPressureRelatest（）一起工作。onBackpressureDrop（）是正确的吗？我将把它更正为onBackpressureDrop（），如果是错误的话，请随意更正它。它们有不同的语义含义：对于onBackpressureDrop
，如果源代码在突发事件后由于某种原因暂停，您可能会在处理过程中出现间隙。@akarnokd，似乎这只适用于可流动的
-s。对于可观察的
，是否有flatMapFirst
的捷径模拟，而不转换为可流动的
？否，这是一种通过可流动的
廉价获得的背压效应。您必须编写一个自定义的Observable
操作符。它似乎与onBackpressureDrop（）而不是onBackpressureLatest（）一起工作。onBackpressureDrop（）是正确的吗？我将把它更正为onBackpressureDrop（），如果是错误的话，请随意更正它。它们有不同的语义含义：对于onBackpressureDrop
，如果源代码在突发事件后由于某种原因暂停，您可能会在处理过程中出现间隙。@akarnokd，似乎这只适用于可流动的
-s。对于可观察的
，是否有flatMapFirst
的捷径模拟，而不转换为可流动的
？否，这是一种通过可流动的
廉价获得的背压效应。您必须编写一个自定义的可观察的操作符。BackpressureStrategy.MISSING是错误的策略。您需要应用onbackpressurexx
运算符，否则flatMap很可能会溢出其内部队列。@akarnokd，据我所知。BUFFER
相当于SpscLinkedArrayQueue在hoo下的行为