Android面试题之Kotlin异步流、冷流Flow

本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点

返回多个值

//返回了多个值，是同步
fun simpleSequence():Sequence<Int> = sequence {
    for (i in 1..3){
        Thread.sleep(1000)//阻塞
        //因为有RestrictsSuspension注解，无法调用挂起函数，所以delay会报错
        //delay(1000)
        yield(i)
    }
}

通过Flow异步返回多个值

fun simpleFlow() = flow<Int>{
    println("flow started")
    for (i in 1..3){
        delay(1000)
        emit(i)
    }
}

@Test
fun `test flow`() = runBlocking {
    val flow = simpleFlow()
    println("calling collect...")
    flow.collect {value -> println(value)}
    println("calling collect again...")
    flow.collect {value -> println(value)}
}

Flow与其他方式的区别

• 名为flow的是Flow类型构建器函数
• flow{…}构建块中的代码可以挂起
• 函数simpleFlow不再有suspend修饰符
• 流使用emit函数发射值，使用collect函数收集值

冷流

• Flow是一种类似于序列的冷流，flow构建器中的代码直到流被收集的时候才运行（调用collect的时候）
• 调用Collect以后，发射出来的值才会实实在在的存在于内存之中，和懒加载有点像

流的连续性

• 流的每次单独收集都是按照顺序执行的，除非使用特殊的操作符
• 从上游到下游每个过渡操作符都会处理每个发射出的值，然后再交给末端操作符

//会输出string 2；string 4
@Test
fun `test flow2`() = runBlocking {
    (1..5).asFlow().filter { 
        it % 2 == 0
    }.map { 
        "string %it"
    }.collect { 
        println("collect $it")
    }
}

流构建器

• flowOf构建器定义了一个发射固定值集的流
• 使用.asFlow扩展函数可以将各种集合 与序列转换为流

流上下文

• 流的收集总是在调用协程的上下文中发生，这个属性称为上下文保存
• flow{…}构建器中的代码必须遵循上下文保存属性，并且不允许从其他上下文中发射（emit）
• flowOn操作符，该函数用于更改流发射的上下文

 fun simpleFlow() = flow<Int>{
        println("flow started")
        for (i in 1..3){
            delay(1000)
            emit(i)
        }
    }.flowOn(Dispatchers.IO)

启动流

使用launchIn替换collect，我们可以在单独的协程中启动流的收集

fun events() = (1..3)
    .asFlow()
    .onEach { delay(100) }
    .flowOn(Dispatchers.Default)

@Test
fun `test flow launch`() = runBlocking {
    val job = events()
        .onEach { event -> println("event:$event") }
        .launchIn(CoroutineScope(Dispatchers.IO))
    delay(200)
    job.cancelAndJoin()
}

launchIn需要传入协程作用域，返回的是Job，这样可以方便的取消停止流

流的取消

流采用与协程同样的协作取消。流的收集可以是当流在一个可取消的挂起函数（例如delay）中挂起的时候取消

fun simpleFlow3() = flow<Int> { 
    for (i in 1..3) {
        delay(1000)
        println(1000)
        emit(i)
    }
}
@Test
fun `test cancel flow`() = runBlocking {
   withTimeoutOrNull(2500){
       simpleFlow3().collect { value -> println(value) }
   }
    println("done")
}

流的取消检测

• 为方便起见，流构建器对每个发射值执行附加的ensureActive检测以进行取消，这意味着从flow{}发出的繁忙循环是可以取消的
• ensureActive检测的是协程job的状态，取消的话也是取消协程
• 出于性能原因，大多数其他流操作不会自行执行其他取消检测，在协程出于繁忙循环的情况下，必须明确检测是否取消
• 通过cancellable操作符来执行此操作

 fun simpleFlow3() = flow<Int> {
        for (i in 1..5) {
            delay(1000)
            println(1000)
            emit(i)
        }
    }
    //只会输出到3
    @Test
    fun `test cancel flow3`() = runBlocking {
        simpleFlow3().collect { value ->
            println(value)
            if (value == 3){
                cancel()
            }
        }
        //如果不加cancellable()就不能取消
        (1..5).asFlow().cancellable().collect { value ->
            println(value)
            if (value == 3){
                cancel()
            }
        }
    }

背压与处理

背压：生产者效率大于消费者效率

• buffer()，并发运行流中发射元素的代码。（也可以用flowOn切换上下文来实现）
• conflate()，合并发射项，不对每个值进行处理，比如1-3，只处理1和3，中间的值不处理
• collectLatest()，取消并重新发射最后一个值
• 当必须更改CoroutineDispatcher时，flowOn操作符使用了相同的缓冲机制，但是buffer函数显示地请求缓冲而不改变执行上下文

@Test
fun `test flow back pressure`() = runBlocking {
    val time = measureTimeMillis {
        simpleFlow3()
            .buffer(50)
            //.conflate()
            //.flowOn(Dispatchers.Default)
            .collect { value ->
                delay(300)
                println("collected $value")
            }
    }
}

操作符

过渡流操作符

• 转换操作符：map、transform
• 限长操作符：take

末端流操作符

末端操作符是在流上用于启动流收集的挂起函数，collect是最基本的末端操作符

• 转化为各种集合，例如toList与toSet
• 获取第一个（first）值与确保流发射单个（single）值的操作符
• 使用reduce和fold将流规约到单个值

 @Test
    fun `test flow operator`() = runBlocking<Unit> {
        val sum = (1..5).asFlow()
            .map { it * it }
            .reduce{a,b -> a+b}
        //输出55
        println(sum)
    }

组合操作符

• 就像kotlin标准库中的sequence.zip扩展函数一样，流拥有一个zip操作符用于组合两个流中的相关值
• 2个流是异步的

 @Test
    fun `test flow zip`() = runBlocking<Unit> {
        val nums = (1..3).asFlow()
        val strs = flowOf("one", "two", "three")
        nums.zip(strs){ a,b -> "$a -> $b"}.collect { print(it) }
        //会输出1->one,2->two，3->three
    }

展平流

• flatMapConcat连接模式
• flatMapMerge合并模式
• flatMapLatest最新展平模式

流的异常处理

当运算符中的发射器或代码抛出异常时，处理方法：

• try/catch块，捕获下游collect异常
• catch函数（上游emit异常，可以在catch中恢复，比如补充数据）

 @Test
    fun `test flow exception`() = runBlocking<Unit> {
        flow { 
            emit(1)
            throw ArithmeticException("Div 0")
        }.catch { e:Throwable ->
            println("catch $e")
            //补充元素
            emit(10)
        }.flowOn(Dispatchers.IO).collect{println(it)}
    }

流的完成

当流收集完成时（普通情况或异常情况），它可能需要执行一个动作

• 命令式finally块
• onCompletion声明式处理，onCompletion还能拿到异常信息，但是不能捕获异常，同时能获取上游异常信息和下游异常信息

@Test
fun `test flow exception onCompletion`() = runBlocking<Unit> {
    flow {
        emit(1)
        throw ArithmeticException("Div 0")
    }.onCompletion { exception -> 
        if (exception != null){
            println("flow completed exception: $exception")
        }}
        .catch { e:Throwable ->
        println("catch $e")
    }.collect{println(it)}
}

---

欢迎关注我的公众号查看更多精彩文章！