Kotlin 朱涛-21 协程 Select 选择最快的结果

本文地址

---

目录

目录

• 目录
• 21 | Select：选择最快的结果
  • 选择最快的结果
    • 不使用 select
    • select + async
    • select + async + Deferred
    • 使用 select 的优势
  • 选择多个结果
    • 不使用 select
    • select + Channel.onReceive
    • onReceive 可能会导致崩溃
    • select + onReceiveCatching
  • 项目实战
  • Deferred、Channel 相关 API
  • 小结

21 | Select：选择最快的结果

和 Kotlin 的 Channel 一样，select 在很多编程语言当中都有类似的实现，比如 Go、Rust 等。不同语言中，select 的语法可能不太一样，但背后的核心理念都是 选择更快的结果 。

select 在 Kotlin 1.6 中，仍然是一个实验性的特性（Experimental）。

选择最快的结果

需求：假如我们想查询一个商品的详情，目前有两个服务，其中缓存服务速度快但信息可能是旧的，而网络服务速度慢但信息是最新的。

不使用 select

data class Product(val id: String, val price: Double, val tag: Any)

fun main() = runBlocking {
    val startTime = System.currentTimeMillis()
    val productId = "xxxId"

    suspend fun getCacheInfo(id: String): Product = delay(200L).let { return Product(id, 9.9, "cache") }
    suspend fun getNetInfo(id: String): Product = delay(200L).let { return Product(id, 9.8, "net") }
    fun updateUI(product: Product) = println("${product}, ${System.currentTimeMillis() - startTime}")

    updateUI(getCacheInfo(productId)) // 先使用缓存
    updateUI(getNetInfo(productId))   // 再查询网络
}

Product(id=xxxId, price=9.9, tag=cache), 218
Product(id=xxxId, price=9.8, tag=net), 431

存在的问题：因为 getCacheInfo() 是一个挂起函数，所以只有这个挂起函数执行完成以后，才可以继续执行后面的任务。

select + async

上面这个场景，我们可以用 async + select 来实现，async 可以实现并发，select 则可以选择最快的结果。

val product = select<Product> { // 使用 select 包裹 async 启动的两个协程，泛型代表要选择的数据类型
    async { getCacheInfo(productId) }.onAwait { it } // async 两个挂起函数，可以让这两个查询并发执行
    async { getNetInfo(productId) }.onAwait { it }   // 使用 onAwait{} 将执行结果回传给 select{}
}

updateUI(product) // 只会打印最快的结果 Product(id=xxxId, price=9.9, tag=cache), 218

存在的问题：上面代码只会选择最快的那个结果，如果缓存是最快的话，就不会再展示最新的 net 内容。

select + async + Deferred

在上面代码的基础上，稍加修改就可以实现，先展示缓存、再展示最新的内容。

val cacheDeferred: Deferred<Product> = async { getCacheInfo(productId) } // 并发执行
val netDeferred: Deferred<Product> = async { getNetInfo(productId) }     // 并发执行
val product = select<Product> {  // 通过 select 选择最快的那个结果
    cacheDeferred.onAwait { it }
    netDeferred.onAwait { it }
}

updateUI(product)
if ("cache" == product.tag) {   // 如果当前结果来自缓存，那么再取最新的网络结果更新 UI
    updateUI(netDeferred.await())
}

Product(id=xxxId, price=9.9, tag=cache), 214
Product(id=xxxId, price=9.8, tag=net), 215

上面代码中，如果缓存是最快的话，就先展示缓存，再展示最新的 net 内容；否则，只展示最新的 net 内容。

使用 select 的优势

这个例子不使用 select 同样也可以实现，不过，select 这样的代码模式的优势在于，扩展性非常好。

可以看到，当增加一个缓存服务进来的时候，我们的代码只需要做很小的改动，就可以实现。

总的来说，对比传统的挂起函数串行的执行流程，select 这样的代码模式，不仅可以提升程序的整体响应速度，还可以大大提升程序的灵活性、扩展性。

选择多个结果

在协程中返回一个内容的时候，我们可以使用挂起函数、async，但如果要返回多个结果的话，就需要用到 Channel 和 Flow。

需求：假如有两个管道，现在需要将它们中的数据收集出来，并逐个打印。

不使用 select

fun main() = runBlocking {
    val startTime = System.currentTimeMillis()
    fun log(text: Any) = println("${text}, ${System.currentTimeMillis() - startTime}")

    val channel1: ReceiveChannel<Int> = produce { (1..2).forEach { send(it);delay(100L) } }
    val channel2: ReceiveChannel<String> = produce { listOf("a", "b").forEach { send(it);delay(100L) } }

    log(">> start channel1")
    channel1.consumeEach { log("consumeEach1 - $it") }
    log(">> start channel2")
    channel2.consumeEach { log("consumeEach2 - $it") } // channel1 执行完毕以后，才会执行 channel2
    log("end")
}

>> start channel1, 9
consumeEach1 - 1, 33
consumeEach1 - 2, 131
>> start channel2, 244
consumeEach2 - a, 244
consumeEach2 - b, 350
end, 458

存在的问题：两个管道是串行执行的，只有当 channel1 执行完毕以后，才会执行 channel2。

select + Channel.onReceive

repeat(4) { // 重复执行 4 次 select，目的是把两个管道中的所有数据都消耗掉
    select {
        log("   select$it")
        channel1.onReceive { log("onReceive1 - $it") } // 注意，onReceive 可能会崩溃
        channel2.onReceive { log("onReceive2 - $it") } // 注意，onReceive 可能会崩溃
    }
}
log("end")

   select0, 15
onReceive1 - 1, 41
   select1, 42
onReceive2 - a, 45
   select2, 45
onReceive1 - 2, 140
   select3, 140
onReceive2 - b, 156
end, 156

onReceive{} 是 Channel 在 select 当中的语法，当 Channel 中有数据以后，它就会被回调，通过这个 Lambda，我们也可以将结果传出去。

注意，上面的代码中的 onReceive 可能会导致崩溃。

onReceive 可能会导致崩溃

如果两个管道中 delay 的时间间隔较大，比如将 channel1 中 delay 值从 100 改为 1000，这时程序就会出问题了。

   select0, 12
onReceive1 - 1, 39
   select1, 39
onReceive2 - a, 43
   select2, 43
onReceive2 - b, 158
Exception in thread "main" ClosedReceiveChannelException: Channel was closed
	at channels.Closed.getReceiveException(AbstractChannel.kt:1108)
	at channels.AbstractChannel$ReceiveSelect.resumeReceiveClosed(AbstractChannel.kt:989)

这是因为，Channel 中的数据发送完数据以后，就会被关闭，此时再调用 onReceive 就会触发 ClosedReceiveChannelException 异常。

select + onReceiveCatching

在 19 讲中讲过，使用 receiveCatching() 可以防止出现 ClosedReceiveChannelException，类似的，当 Channel 与 select 配合的时候，可以使用 onReceiveCatching{} 这个高阶函数。

repeat(5) { // 可以随便重复多少次都不会崩溃
    select {
        log("   select$it")
        channel1.onReceiveCatching { log("onReceive1 - ${it.getOrNull()}") }
        channel2.onReceiveCatching { log("onReceive2 - ${it.getOrNull()}") }
    }
}
log("end")
channel1.cancel() // 主动取消
channel2.cancel()

   select0, 11
onReceive1 - 1, 34
   select1, 35
onReceive2 - a, 38
   select2, 38
onReceive2 - b, 141    // 因为 channel1 还在 delay，所以依旧会选择 channel2
   select3, 141
onReceive2 - null, 249 // 如果获取的结果是空，就代表管道已经被关闭了
   select4, 249
onReceive2 - null, 249
end, 249

使用 onReceiveCatching{} 后就不用担心崩溃的问题了，如果获取的结果是 null，就代表管道已经被关闭了。

上面的代码中，我们在 repeat() 后，主动将 channel1、channel2 取消了。如果不这么做，当得到所有结果以后，程序不会立即退出。这是因为，由于 channel1 没有接收者，所以会一直 delay。

这种将多路数据以非阻塞的方式合并成一路数据的模式，在其他领域也有广泛的应用，比如操作系统、Java NIO 等等。

项目实战

fun main() = runBlocking {
    val startTime = System.currentTimeMillis()
    fun log(text: Any) = println("${text}, ${System.currentTimeMillis() - startTime}")

    suspend fun <T> getFastDeferred(vararg deferreds: Deferred<T>): T = select {
        for (deferred in deferreds) {
            deferred.onAwait { t: T ->
                log("onAwait: $t")
                deferreds.forEach { it.cancel() } // 取消其他的 Deferred
                t   // 返回的是最快的那个结果
            }
        }
    }

    fun <T> getDeferredAsync(result: T): Deferred<T> = async {
        val delayTime = Random.nextLong(1000L)
        log("Deferred: $result, delay=$delayTime")
        delay(delayTime)
        result
    }

    val list: Array<Deferred<Int>> = Array(6) { getDeferredAsync(it) }
    val result: Int = getFastDeferred(*list) // 在前面加一个 * 就变成可变数组了
    log("result: $result")
}

Deferred: 0, delay=703, 12
Deferred: 1, delay=129, 19
Deferred: 2, delay=679, 19
Deferred: 3, delay=318, 19
Deferred: 4, delay=58, 19   // 这个任务最快
Deferred: 5, delay=934, 19
onAwait: 4, 94
result: 4, 96

Deferred、Channel 相关 API

当 Deferred、Channel 与 select 配合的时候，它们原本的 API 会多一个 on 前缀。所以，只要记住了 Deferred、Channel 的 API，不需要额外记忆 select 的 API，只需要在原本的 API 的前面加上一个 on 就行了。

public interface Deferred : CoroutineContext.Element {
    public suspend fun join()
    public suspend fun await(): T
    public val onJoin: SelectClause0
    public val onAwait: SelectClause1<T>
}

public interface SendChannel<in E> {
    public suspend fun send(element: E)
    public val onSend: SelectClause2<E, SendChannel<E>>
}

public interface ReceiveChannel<out E> {
    public suspend fun receive(): E
    public suspend fun receiveCatching(): ChannelResult<E>
    public val onReceive: SelectClause1<E>
    public val onReceiveCatching: SelectClause1<ChannelResult<E>>
}

小结

select，就是选择更快的结果。

当 select 与 async、Channel 搭配以后，我们可以并发执行协程任务，以此提升程序的执行效率，并且还可以改善程序的扩展性、灵活性。

2017-03-20