Kotlin SharedFlow联合收割机操作.在特定情况下表现得敏捷

Question

我正在组合两个SharedFlows，然后执行一个长时间的工作操作。

一开始，我知道状态，所以我发出一个"；起始值"；对于两种流。之后，用户可以向任一流发射。

两个流大多是独立的，但在特定情况下，用户可以同时向两个流发出。这样做的结果是，合并被触发两次，长时间工作的作业被执行两次，而事实上，在这种情况下，我只对接收两个值感兴趣，但只执行一次作业。

这是我所拥有的：

val _numbers = MutableSharedFlow<Int>(replay = 0, extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
val numbers: SharedFlow<Int> = _numbers
val _strings = MutableSharedFlow<String>(replay = 0, extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
val strings: SharedFlow<String> = _strings
combine(numbers, strings) { (number, strings) ->
println("values $number - $strings. Starting to perform a long working job")
}
.launchIn(CoroutineScope(Dispatchers.IO))
runBlocking {
delay(500)
// This is the initial values. I always know this at start.
_numbers.emit(0)
_strings.emit("a")
// Depending of user action, number or string is emitted.
delay(100)
_numbers.emit(1)
delay(100)
_numbers.emit(2)
delay(100)
_numbers.emit(3)
delay(100)
_numbers.emit(4)
delay(100)
_strings.emit("b")
delay(100)
_strings.emit("c")
delay(100)
_strings.emit("d")
delay(100)
_strings.emit("e")
delay(100)
// In a specific situation both values need to change but I only want to trigger the long working job once
_numbers.emit(10)
_strings.emit("Z")
}

这可以产生这样的：

values 0 - a. Starting to perform a long working job
values 1 - a. Starting to perform a long working job
values 2 - a. Starting to perform a long working job
values 3 - a. Starting to perform a long working job
values 4 - a. Starting to perform a long working job
values 4 - b. Starting to perform a long working job
values 4 - c. Starting to perform a long working job
values 4 - d. Starting to perform a long working job
values 4 - e. Starting to perform a long working job
values 10 - e. Starting to perform a long working job
values 10 - Z. Starting to perform a long working job

或者这个：

values 0 - a. Starting to perform a long working job
values 1 - a. Starting to perform a long working job
values 2 - a. Starting to perform a long working job
values 3 - a. Starting to perform a long working job
values 4 - a. Starting to perform a long working job
values 4 - b. Starting to perform a long working job
values 4 - c. Starting to perform a long working job
values 4 - d. Starting to perform a long working job
values 4 - e. Starting to perform a long working job
values 10 - Z. Starting to perform a long working job

由于缓冲区溢出，有时我可以实现我想要的(这是最新的(，但在其他情况下，我有我不感兴趣的values 10 - e. Starting to perform a long working job。

有没有什么方法可以强制执行，当向两者发射时，只开始一次长时间的工作？

https://pl.kotl.in/JA1Wdhra9

Answer 1

如果要保留2个流，则单事件和双事件之间的区别必须基于时间。你将无法区分字符串的快速更新和数字的"更新"；双重更新"；。

如果基于时间对你来说还可以，那么在长时间处理之前使用debounce应该是一种方法：

combine(numbers, strings) { (number, string) -> number to string }
.debounce(50)
.onEach { (number, string) ->
println("values $number - $string. Starting to perform a long working job")
}
.launchIn(CoroutineScope(Dispatchers.IO))

这里，combine只从2个流构建对，但仍然获取所有事件，然后debounce忽略快速连续的事件，只发送快速序列中的最新一个。这也会带来轻微的延迟，但这完全取决于你想要实现什么。

如果基于时间的区分不适合您，那么您需要一种方法让生产者以不同于2个单个事件的方式发送双重事件。为此，您可以使用单个事件流，例如，您可以定义这样的事件：

sealed class Event {
data class SingleNumberUpdate(val value: Int): Event()
data class SingleStringUpdate(val value: String): Event()
data class DoubleUpdate(val num: Int, val str: String): Event()
}

但之后你必须写下"；"组合"；自己逻辑(保持最新数字和字符串的状态(：

flow {
var num = 0
var str = "a"
emit(num to str)
events.collect { e ->
when (e) {
is Event.SingleNumberUpdate -> {
num = e.value
}
is Event.SingleStringUpdate -> {
str = e.value
}
is Event.DoubleUpdate -> {
num = e.num
str = e.str
}
}
emit(num to str)
}
}
.onEach { (number, strings) ->
println("values $number - $strings. Starting to perform a long working job")
}
.launchIn(CoroutineScope(Dispatchers.IO))