select 表達式 (實驗性
[//]: # (title: select 表達式 (實驗性))
select 表達式讓同時等待多個暫停函數成為可能，並「選擇」第一個可用的函數。
NOTE
select 表達式是 kotlinx.coroutines 的實驗性功能。其 API 預計將在 kotlinx.coroutines 函式庫的未來更新中演進，可能會有破壞性變更。
從通道中選擇
讓我們有兩個字串生產者：fizz 和 buzz。fizz 每 500 毫秒生產一個 "Fizz" 字串：
kotlin
fun CoroutineScope.fizz() = produce<String> {
while (true) { // sends "Fizz" every 500 ms
delay(500)
send("Fizz")
}
}而 buzz 每 1000 毫秒生產一個 "Buzz!" 字串：
kotlin
fun CoroutineScope.buzz() = produce<String> {
while (true) { // sends "Buzz!" every 1000 ms
delay(1000)
send("Buzz!")
}
}使用 receive 暫停函數，我們可以從一個通道或另一個通道「擇一」接收。但 select 表達式允許我們同時從「兩個」通道接收，利用其 onReceive 子句：
kotlin
suspend fun selectFizzBuzz(fizz: ReceiveChannel<String>, buzz: ReceiveChannel<String>) {
select<Unit> { // <Unit> means that this select expression does not produce any result
fizz.onReceive { value -> // this is the first select clause
println("fizz -> '$value'")
}
buzz.onReceive { value -> // this is the second select clause
println("buzz -> '$value'")
}
}
}讓我們將其運行七次：
kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.selects.*
fun CoroutineScope.fizz() = produce<String> {
while (true) { // sends "Fizz" every 500 ms
delay(500)
send("Fizz")
}
}
fun CoroutineScope.buzz() = produce<String> {
while (true) { // sends "Buzz!" every 1000 ms
delay(1000)
send("Buzz!")
}
}
suspend fun selectFizzBuzz(fizz: ReceiveChannel<String>, buzz: ReceiveChannel<String>) {
select<Unit> { // <Unit> means that this select expression does not produce any result
fizz.onReceive { value -> // this is the first select clause
println("fizz -> '$value'")
}
buzz.onReceive { value -> // this is the second select clause
println("buzz -> '$value'")
}
}
}
fun main() = runBlocking<Unit> {
val fizz = fizz()
val buzz = buzz()
repeat(7) {
selectFizzBuzz(fizz, buzz)
}
coroutineContext.cancelChildren() // cancel fizz & buzz coroutines
}NOTE
您可以在此處獲取完整程式碼。
此程式碼的結果是：
text
fizz -> 'Fizz'
buzz -> 'Buzz!'
fizz -> 'Fizz'
fizz -> 'Fizz'
buzz -> 'Buzz!'
fizz -> 'Fizz'
fizz -> 'Fizz'關於關閉的選擇
當通道關閉時，select 中的 onReceive 子句會失敗，導致對應的 select 拋出例外。我們可以使用 onReceiveCatching 子句在通道關閉時執行特定動作。以下範例也顯示 select 是一個表達式，它會返回其所選子句的結果：
kotlin
suspend fun selectAorB(a: ReceiveChannel<String>, b: ReceiveChannel<String>): String =
select<String> {
a.onReceiveCatching { it ->
val value = it.getOrNull()
if (value != null) {
"a -> '$value'"
} else {
"Channel 'a' is closed"
}
}
b.onReceiveCatching { it ->
val value = it.getOrNull()
if (value != null) {
"b -> '$value'"
} else {
"Channel 'b' is closed"
}
}
}讓我們將其與生產 "Hello" 字串四次的通道 a 和生產 "World" 字串四次的通道 b 一起使用：
kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.selects.*
suspend fun selectAorB(a: ReceiveChannel<String>, b: ReceiveChannel<String>): String =
select<String> {
a.onReceiveCatching { it ->
val value = it.getOrNull()
if (value != null) {
"a -> '$value'"
} else {
"Channel 'a' is closed"
}
}
b.onReceiveCatching { it ->
val value = it.getOrNull()
if (value != null) {
"b -> '$value'"
} else {
"Channel 'b' is closed"
}
}
}
fun main() = runBlocking<Unit> {
val a = produce<String> {
repeat(4) { send("Hello $it") }
}
val b = produce<String> {
repeat(4) { send("World $it") }
}
repeat(8) { // print first eight results
println(selectAorB(a, b))
}
coroutineContext.cancelChildren()
}NOTE
您可以在此處獲取完整程式碼。
此程式碼的結果相當有趣，因此我們將更詳細地分析它：
text
a -> 'Hello 0'
a -> 'Hello 1'
b -> 'World 0'
a -> 'Hello 2'
a -> 'Hello 3'
b -> 'World 1'
Channel 'a' is closed
Channel 'a' is closed從中可以得出幾個觀察結果。
首先，select 對於第一個子句是「有偏好的」(biased)。當多個子句同時可選時，它們之中第一個子句會被選中。在此處，兩個通道都在不斷生產字串，因此 a 通道作為 select 中的第一個子句獲勝。然而，由於我們使用的是非緩衝通道，a 會在其 send 調用時不時地暫停，這也給了 b 傳送的機會。
第二個觀察結果是，當通道已經關閉時，onReceiveCatching 會立即被選中。
選擇傳送
select 表達式具有 onSend 子句，結合選擇的偏好性(biased nature)，可以發揮很大的作用。
讓我們寫一個整數生產者的範例，當其主要通道上的消費者無法跟上時，它會將其值傳送到一個「側通道」(side channel)：
kotlin
fun CoroutineScope.produceNumbers(side: SendChannel<Int>) = produce<Int> {
for (num in 1..10) { // produce 10 numbers from 1 to 10
delay(100) // every 100 ms
select<Unit> {
onSend(num) {} // Send to the primary channel
side.onSend(num) {} // or to the side channel
}
}
}消費者將會很慢，處理每個數字需要 250 毫秒：
kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.selects.*
fun CoroutineScope.produceNumbers(side: SendChannel<Int>) = produce<Int> {
for (num in 1..10) { // produce 10 numbers from 1 to 10
delay(100) // every 100 ms
select<Unit> {
onSend(num) {} // Send to the primary channel
side.onSend(num) {} // or to the side channel
}
}
}
fun main() = runBlocking<Unit> {
val side = Channel<Int>() // allocate side channel
launch { // this is a very fast consumer for the side channel
side.consumeEach { println("Side channel has $it") }
}
produceNumbers(side).consumeEach {
println("Consuming $it")
delay(250) // let us digest the consumed number properly, do not hurry
}
println("Done consuming")
coroutineContext.cancelChildren()
}NOTE
您可以在此處獲取完整程式碼。
那麼讓我們看看發生了什麼：
text
Consuming 1
Side channel has 2
Side channel has 3
Consuming 4
Side channel has 5
Side channel has 6
Consuming 7
Side channel has 8
Side channel has 9
Consuming 10
Done consuming選擇延遲值
可以使用 onAwait 子句選擇延遲值。讓我們從一個非同步函數開始，該函數在隨機延遲後返回一個延遲字串值：
kotlin
fun CoroutineScope.asyncString(time: Int) = async {
delay(time.toLong())
"Waited for $time ms"
}讓我們啟動十幾個帶有隨機延遲的這類函數。
kotlin
fun CoroutineScope.asyncStringsList(): List<Deferred<String>> {
val random = Random(3)
return List(12) { asyncString(random.nextInt(1000)) }
}現在，主函數等待它們中的第一個完成，並計算仍處於活躍狀態的延遲值數量。請注意，我們在此處利用了 select 表達式是 Kotlin DSL 的事實，因此我們可以使用任意程式碼為其提供子句。在本例中，我們遍歷延遲值列表，為每個延遲值提供 onAwait 子句。
kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.selects.*
import java.util.*
fun CoroutineScope.asyncString(time: Int) = async {
delay(time.toLong())
"Waited for $time ms"
}
fun CoroutineScope.asyncStringsList(): List<Deferred<String>> {
val random = Random(3)
return List(12) { asyncString(random.nextInt(1000)) }
}
fun main() = runBlocking<Unit> {
val list = asyncStringsList()
val result = select<String> {
list.withIndex().forEach { (index, deferred) ->
deferred.onAwait { answer ->
"Deferred $index produced answer '$answer'"
}
}
}
println(result)
val countActive = list.count { it.isActive }
println("$countActive coroutines are still active")
}NOTE
您可以在此處獲取完整程式碼。
輸出是：
text
Deferred 4 produced answer 'Waited for 128 ms'
11 coroutines are still active切換延遲值通道
讓我們編寫一個通道生產者函數，它會消費一個延遲字串值通道，等待每個接收到的延遲值，但僅限於下一個延遲值到達或通道關閉之前。此範例將 onReceiveCatching 和 onAwait 子句組合在同一個 select 中：
kotlin
fun CoroutineScope.switchMapDeferreds(input: ReceiveChannel<Deferred<String>>) = produce<String> {
var current = input.receive() // start with first received deferred value
while (isActive) { // loop while not cancelled/closed
val next = select<Deferred<String>?> { // return next deferred value from this select or null
input.onReceiveCatching { update ->
update.getOrNull()
}
current.onAwait { value ->
send(value) // send value that current deferred has produced
input.receiveCatching().getOrNull() // and use the next deferred from the input channel
}
}
if (next == null) {
println("Channel was closed")
break // out of loop
} else {
current = next
}
}
}為了測試它，我們將使用一個簡單的非同步函數，它會在指定時間後解析為指定字串：
kotlin
fun CoroutineScope.asyncString(str: String, time: Long) = async {
delay(time)
str
}主函數僅啟動一個協程來列印 switchMapDeferreds 的結果，並向其傳送一些測試資料：
kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.selects.*
fun CoroutineScope.switchMapDeferreds(input: ReceiveChannel<Deferred<String>>) = produce<String> {
var current = input.receive() // start with first received deferred value
while (isActive) { // loop while not cancelled/closed
val next = select<Deferred<String>?> { // return next deferred value from this select or null
input.onReceiveCatching { update ->
update.getOrNull()
}
current.onAwait { value ->
send(value) // send value that current deferred has produced
input.receiveCatching().getOrNull() // and use the next deferred from the input channel
}
}
if (next == null) {
println("Channel was closed")
break // out of loop
} else {
current = next
}
}
}
fun CoroutineScope.asyncString(str: String, time: Long) = async {
delay(time)
str
}
fun main() = runBlocking<Unit> {
val chan = Channel<Deferred<String>>() // the channel for test
launch { // launch printing coroutine
for (s in switchMapDeferreds(chan))
println(s) // print each received string
}
chan.send(asyncString("BEGIN", 100))
delay(200) // enough time for "BEGIN" to be produced
chan.send(asyncString("Slow", 500))
delay(100) // not enough time to produce slow
chan.send(asyncString("Replace", 100))
delay(500) // give it time before the last one
chan.send(asyncString("END", 500))
delay(1000) // give it time to process
chan.close() // close the channel ...
delay(500) // and wait some time to let it finish
}NOTE
您可以在此處獲取完整程式碼。
此程式碼的結果：
text
BEGIN
Replace
END
Channel was closed