前言
协程通讯三剑客：Channel、Select、Flow，上篇现已剖析了Channel的深水区，本篇将会要点剖析Select的运用及原理。
经过本篇文章，你将了解到：
- Select 的引进
- Select 的运用
- Invoke函数 的妙用
- Select 的原理
- Select 注意事项
1. Select 的引进
多路数据的挑选
串行履行
如今的二维码辨认运用场景越来越广了，前期运用比较广泛的辨认SDK如zxing、zbar，它们各有各的特色，也存在辨认不出来的状况，为了将两者优势结合起来，咱们想到的办法是同一份二维码图片分别给两者进行辨认。
如下：
//从zxing 获取二维码信息
suspend fun getQrcodeInfoFromZxing(bitmap: Bitmap?): String {
//模仿耗时
delay(2000)
return "I'm fish"
}
//从zbar 获取二维码信息
suspend fun getQrcodeInfoFromZbar(bitmap: Bitmap?): String {
delay(1000)
return "I'm fish"
}
fun testSelect() {
runBlocking {
var bitmap = null
var starTime = System.currentTimeMillis()
var qrcoe1 = getQrcodeInfoFromZxing(bitmap)
var qrcode2 = getQrcodeInfoFromZbar(bitmap)
println("qrcode1=$qrcoe1 qrcode2=$qrcode2 useTime:${System.currentTimeMillis() - starTime} ms")
}
}
检查打印，终究花费的时刻：
qrcode1=I’m fish qrcode2=I’m fish useTime:3013 ms
当然这是串行的方法功率比较低，咱们想到了用协程来优化它。
协程并行履行
如下：
fun testSelect1() {
var bitmap = null;
var starTime = System.currentTimeMillis()
var deferredZxing = GlobalScope.async {
getQrcodeInfoFromZxing(bitmap)
}
var deferredZbar = GlobalScope.async {
getQrcodeInfoFromZbar(bitmap)
}
runBlocking {
//挂起等候辨认成果
var qrcoe1 = deferredZxing.await()
//挂起等候辨认成果
var qrcode2 = deferredZbar.await()
println("qrcode1=$qrcoe1 qrcode2=$qrcode2 useTime:${System.currentTimeMillis() - starTime} ms")
}
}
检查打印，终究花费的时刻：
qrcode1=I’m fish qrcode2=I’m fish useTime:2084 ms
能够看出，花费时刻显着变少了。
与上个Demo 相比，尽管辨认进程是放在协程里并行履行的，但是在等候辨认成果却是串行的。咱们引进两个辨认库的初衷是哪个辨认快就用哪个的成果，为了达成这个意图，传统的方法是：
一起监听并记载辨认成果的回来。
一起监听多路成果
如下：
fun testSelect2() {
var bitmap = null;
var starTime = System.currentTimeMillis()
var deferredZxing = GlobalScope.async {
getQrcodeInfoFromZxing(bitmap)
}
var deferredZbar = GlobalScope.async {
getQrcodeInfoFromZbar(bitmap)
}
var isEnd = false
var result: String? = null
GlobalScope.launch {
if (!isEnd) {
//没有结束，则持续辨认
var resultTmp = deferredZxing.await()
if (!isEnd) {
//辨认没有结束，阐明自己是第一个回来成果的
result = resultTmp
println("zxing recognize ok useTime:${System.currentTimeMillis() - starTime} ms")
//符号辨认结束
isEnd = true
}
}
}
GlobalScope.launch {
if (!isEnd) {
var resultTmp = deferredZbar.await()
if (!isEnd) {
//辨认没有结束，阐明自己是第一个回来成果的
result = resultTmp
println("zbar recognize ok useTime:${System.currentTimeMillis() - starTime} ms")
isEnd = true
}
}
}
//检测是否有成果回来
runBlocking {
while (!isEnd) {
delay(1)
}
println("recognize result:$result")
}
}
经过检测isEnd 符号来判别是否有某个模块回来成果。
成果如下：
- zbar recognize ok useTime:1070 ms
- recognize result:I’m fish
因为模仿设定的zbar 解析速度快，因而每次都是采用的是zbar的成果，所花费的时刻大幅减少了，该成果契合预期。
Select 闪亮上台
尽管上个Demo成果契合预期，但是多了许多额定的代码、多引进了其它协程，并且需求子模块对符号进行赋值（对”isEnd”进行赋值），没有抵达解耦的意图。咱们期望子模块的任务是单一且闭环的，假如能在一个函数里统一检测成果的回来就好了。
Select 就是为了解决多路数据的挑选而生的。
来看看它是怎么解决该问题的：
fun testSelect3() {
var bitmap = null;
var starTime = System.currentTimeMillis()
var deferredZxing = GlobalScope.async {
getQrcodeInfoFromZxing(bitmap)
}
var deferredZbar = GlobalScope.async {
getQrcodeInfoFromZbar(bitmap)
}
runBlocking {
//经过select 监听zxing、zbar 成果回来
var result = select<String> {
//监听zxing
deferredZxing.onAwait {value->
//value 为deferredZxing 辨认的成果
"zxing result $value"
}
//监听zbar
deferredZbar.onAwait { value->
"zbar result $value"
}
}
//运转到此，阐明现已有成果回来
println("result from $result useTime:${System.currentTimeMillis() - starTime}")
}
}
成果如下：
result from zbar result I’m fish useTime:1079
契合预期，一起能够看出：相比上个Demo，这样写简洁了许多。
2. Select 的运用
除了能够监听async的成果，Select 还能够监听Channel的发送方/接收方 数据，咱们以监听接收方数据为例：
fun testSelect4() {
runBlocking {
var bitmap = null;
var starTime = System.currentTimeMillis()
var receiveChannelZxing = produce {
//生产数据
var result = getQrcodeInfoFromZxing(bitmap)
//发送数据
send(result)
}
var receiveChannelZbar = produce {
var result = getQrcodeInfoFromZbar(bitmap)
send(result)
}
var result = select<String> {
//监听是否有数据发送过来
receiveChannelZxing.onReceive {
value->"zxing result $value"
}
receiveChannelZbar.onReceive {
value->"zbar result $value"
}
}
println("result from $result useTime:${System.currentTimeMillis() - starTime}")
}
}
成果如下：
result from zbar result I’m fish useTime:1028
不论是async还是Channel，Select 都能够监听它们的数据，从而形成多路复用的作用。
在监听协程里调用select 表达式，表达式{}内声明需求监听的协程的数据，关于select 来说有两种场景：
- 没有数据，则select 挂起协程并等候直到其它协程数据准备完成后再次康复select 地点的协程。
- 有数据，则select 正常履行并回来获取的数据。
3. Invoke函数 的妙用
在剖析Select 原理之前，需求弄理解invoke函数的原理。
关于Kotlin 类来说，都能够重写其invoke函数。
operator fun invoke():String {
return "I'm fish"
}
如上，重写了SelectDemo里的invoke函数，和普通成员函数相同，咱们能够经过目标调用它。
fun main(args: Array<String>) {
var selectDemo = SelectDemo()
var result = selectDemo.invoke()
println("result：$result")
}
当然，能够进一步简化：
fun main(args: Array<String>) {
var selectDemo = SelectDemo()
var result = selectDemo()
println("result：$result")
}
这里触及到了kotlin的语法糖：目标居然能够像函数相同调用。
作为函数，invoke 当然也能够接收高阶函数作为参数：
operator fun invoke(block: (Int) -> String): String {
return block(3)
}
fun main(args: Array<String>) {
var selectDemo = SelectDemo()
var result = selectDemo { age ->
when (age) {
3 -> "I'm fish3"
4 -> "I'm fish4"
else -> "error"
}
}
println("result：$result")
}
因而，当看到目标作为函数调用时，实际上调用的是invoke函数，详细的逻辑需求检查其invoke函数的完成。
4. Select 的原理
上篇剖析过Channel，因而本篇抓住时机，经过Select 监听Channel数据的改变来剖析其原理，为方便讲解，咱们先以监听一个Channel的为例。
先从select 表达式自身下手。
fun testSelect5() {
runBlocking {
var starTime = System.currentTimeMillis()
var receiveChannelZxing = produce {
//发送数据
send("I'm fish")
}
//确保channel 数据现已send
delay(1000)
var result = select<String> {
//监听是否有数据发送过来
receiveChannelZxing.onReceive { value ->
"zxing result $value"
}
}
println("result from $result useTime:${System.currentTimeMillis() - starTime}")
}
}
select 是挂起函数，因而协程运转到此有可能被挂起。
#Select.kt
public suspend inline fun <R> select(crossinline builder: SelectBuilder<R>.() -> Unit): R {
//...
return suspendCoroutineUninterceptedOrReturn { uCont ->
//传入父协程体
val scope = SelectBuilderImpl(uCont)
try {
//履行builder
builder(scope)
} catch (e: Throwable) {
scope.handleBuilderException(e)
}
//经过回来值判别是否需求挂起协程
scope.getResult()
}
}
要点看builder(scope)，builder 是高阶函数，实际上就是履行了select花括号里的内容，而它里面就是监听数据是否回来。
receiveChannelZxing.onReceive
刚开端看的时分势必以为onReceive是个函数，但是它是ReceiveChannel 里的成员变量：
#Channel.kt
public val onReceive: SelectClause1<E>
经过上一节的剖析可知，关键是要找到SelectClause1 的invoke的完成。
#Select.kt
public interface SelectBuilder<in R> {
//block 有个入参
//声明了SelectClause1的扩展函数invoke
public operator fun <Q> SelectClause1<Q>.invoke(block: suspend (Q) -> R)
}
override fun <Q> SelectClause1<Q>.invoke(block: suspend (Q) -> R) {
//SelectBuilderImpl 完成了 SelectClause1 的invoke函数
registerSelectClause1(this@SelectBuilderImpl, block)
}
再看onReceive 的赋值：
#AbstractChannel.kt
final override val onReceive: SelectClause1<E>
get() = object : SelectClause1<E> {
@Suppress("UNCHECKED_CAST")
override fun <R> registerSelectClause1(select: SelectInstance<R>, block: suspend (E) -> R) {
registerSelectReceiveMode(select, RECEIVE_THROWS_ON_CLOSE, block as suspend (Any?) -> R)
}
}
因而，简单总结调用栈如下：
当调用receiveChannelZxing.onReceive{}，实际上调用了SelectClause1.invoke()，而它里面又调用了SelectClause1.registerSelectClause1()，终究调用了AbstractChannel.registerSelectReceiveMode。
AbstractChannel. registerSelectReceiveMode
#AbstractChannel.kt
private fun <R> registerSelectReceiveMode(select: SelectInstance<R>, receiveMode: Int, block: suspend (Any?) -> R) {
while (true) {
//假如现已有成果了，则直接回来------->①
if (select.isSelected) return
if (isEmptyImpl) {
//没有发送者在等候，则入队等候，并回来 ------->②
if (enqueueReceiveSelect(select, block, receiveMode)) return
} else {
//直接取出值------->③
val pollResult = pollSelectInternal(select)
when {
pollResult === ALREADY_SELECTED -> return
pollResult === POLL_FAILED -> {} // retry
pollResult === RETRY_ATOMIC -> {} // retry
//调用block------->④
else -> block.tryStartBlockUnintercepted(select, receiveMode, pollResult)
}
}
}
}
分为4个点，接着来一一剖析。
①
select 一起监听多个值，若是有1个契合要求的数据回来了，那么该isSelected 符号为true，当检测到该符号为true时直接退出。
结合之前的Demo，zbar 现已辨认出成果了，当select 检测zxing的成果时直接回来。
②
#AbstractChannel.kt
private fun <R> enqueueReceiveSelect(
select: SelectInstance<R>,
block: suspend (Any?) -> R,
receiveMode: Int
): Boolean {
//结构为Node元素
val node = AbstractChannel.ReceiveSelect(this, select, block, receiveMode)
//添加到Channel队列里
val result = enqueueReceive(node)
if (result) select.disposeOnSelect(node)
return result
}
当select 时，发现Channel里没有数据，阐明Channel还没有开端send，因而结构了Node(ReceiveSelect)加入到Channel queue里。当send数据时，会查找queue里是否有接收者等候，若有则调用Node(ReceiveSelect.completeResumeReceive)：
#AbstractChannel.kt
override fun completeResumeReceive(value: E) {
block.startCoroutineCancellable(
if (receiveMode == RECEIVE_RESULT) ChannelResult.success(value) else value,
select.completion,
resumeOnCancellationFun(value)
)
}
block 被调度履行，终究会康复select 协程的履行。
③
取出数据，并尝试康复send协程。
④
在③的基础上，拿到数据后，直接履行block（此刻并没有切换线程进行调度）。
小结一下select 原理：
能够看出：
select 自身履行并不耗时，若终究没有数据回来则挂起等候，若是有数据回来则不会挂起协程。
咱们从头再捋一下select 配合Channel 的原理：
尽管以Channel为例讲解了select 原理，实际上async等结合select 原理大致差不多，要点都是利用了协程的挂起/康复做文章。
5. Select 注意事项
假如select有多个数据一起抵达，select 默许会挑选第一个数据，若想要随机挑选数据，可做如下处理：
var result = selectUnbiased<String> {
//监听是否有数据发送过来
receiveChannelZxing.onReceive { value ->
"zxing result $value"
}
}
想要知道select 还能够监听哪些数据，可检查该数据是否完成了SelectClauseX(X 表明0、1、2）。
以上即为Select 的原理及其运用，下篇将会进入协程的精华部分：Flow的运用，该部分内容较多，可能会分几篇剖析，敬请期待。
本文基于Kotlin 1.5.3，文中完整Demo请点击
