Kotlin 协程 - 冷流 Flow

一、概念

• 场景：List 是同步一次性返回多个值，Sequence 是同步分次返回多个值，Suspend 是异步返回单个值，Flow是异步分次返回多个值。
• 冷流：只能在创建的时候定义生产数据的代码，无法在外部通过实例更新数据。创建和中间操作只是对上一步的包装并不会执行，所以是响应式编程（也叫声明式），因此可以调用挂起函数自身却不是suspend修饰，只有消费的时候才真正生产和操作数据（按需生成），所以消费都是suspend修饰的在协程中调用。
• 一些名词：构建→上游（前面的流）→当前操作→下游（后面的流）→消费。
• 有序：元素遵循先进先出原则，是一个接一个操作完，而不是统一操作再进行下一步。
• 协作取消：消费的取消只能在可取消的挂起函数挂起的时候取消（即跟随协程取消）。
• 切换线程：默认生产和消费在同一协程上下文中，消费所在的协程决定了生产所在的线程。对于生产可以通过 flowOn 改变上流执行线程而不会影响下流。对于消费可通过 launchIn 改变流执行的线程（不会影响生产中的flowOn）。
• 背压：当数据的消费速度赶不上生产速度。默认情况下生产一个消费一个是同步交替进行的不存在背压，除非使用flowOn切换线程。由于消费操作是挂起函数（协程能轻松切换线程），挂起恢复的特性会阻塞数据生产的速度不会对下流产生背压。
• 防抖：新值的内容发生变化才会消费，相同会被忽略。

	Flow	StateFlow	SharedFlow	Channel
类型	冷流：数据只能在创建对象的时候定义生产方式。	热流：数据可以后期发送到流中。
数据的生产	消费时才会生产数据。	不消费也会生产数据。
数据的接收	完整：收到的是全部发送的数据	最新：只持有单个且最新的值，只能拿到订阅之后的数据，适用于状态。	历史：可以缓存多个值，可以拿到订阅之前的历史数据，适用于事件。
关系	独立：多个订阅者彼此之间独立。	共享：多个订阅者同时接收，收到的值相同。		互斥：多个订阅者轮流接收，收到的值不是同一个值。。
关闭	流会自动关闭（停止订阅或者数据数据生产完）。	构造创建的不会自动关闭，转换的启动模式配置为WhileSubscribed会超时关闭。		构造函数创建的不会自动关闭，协程构建器创建的会跟随协程关闭。

二、生产者 producer

用来生产数据，发送值到流中。只能在创建对象的时候定义值的生产方式，无法后期再操作值的生产。

2.1 flow

创建Flow的基本方法，需要手动调用 emit 发射单个值，调用 emitAll 发射另一个Flow中的值。emit 不是线程安全的，不应该并发调用（可考虑channelFlow），不应该在内部调用withContext切换线程（可考虑flowOn操作符）。

public fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit): Flow<T>

val flow = flow {
    emit(5)
    for (i in 1..3) {
        emit(i)
    }
    emitAll(flowOf(1, 2, 3))
}

2.2 flowOf

快速创建固定值集的Flow（类似 listOf() ）。

public fun <T> flowOf(vararg elements: T): Flow<T> = flow {     for (element in elements) { emit(element) } }

val flow = flowOf(1, 2, 3)

2.3 asFlow

遍历其它容器（Array、Range、Sequence、Iterable、Iterator）将元素发送到流中。也可以将普通函数或挂起函数返回的值发送到流中。

public fun Array.asFlow(): Flow<Int> = flow { forEach { value -> emit(value) } } public fun XXArray.asFlow(): Flow<Int> = flow { forEach { value -> emit(value) } } public fun XXRange.asFlow(): Flow<Int> = flow { forEach { value -> emit(value) } } public fun <T> Sequence<T>.asFlow(): Flow<T> = flow { forEach { value -> emit(value) } } public fun <T> Iterable<T>.asFlow(): Flow<T> = flow { forEach { value -> emit(value) } } public fun <T> Iterator<T>.asFlow(): Flow<T> = flow { forEach { value -> emit(value) } } public fun <T> (() -> T).asFlow(): Flow<T> = flow { emit(invoke()) } public fun <T> (suspend () -> T).asFlow(): Flow<T> = flow { emit(invoke()) }

val flow = listOf(1, 2, 3).asFlow()

2.4 callbackFlow

将回调API改造成Flow。底层使用的sendChannel，默认容量64满了会挂起直到消费出空位，为了避免生产被挂起可以配置为CONFLATED或者UNLIMITED。

public fun <T> callbackFlow(@BuilderInference block: suspend ProducerScope<T>.() -> Unit): Flow<T>

send ()	发送数据。
offer ()	允许在协程外提交。
sendBlocking ()	尝试用offer，失败则用runBlocking{ send() }阻塞式提交。
awaitClose ()	Flow关闭时执行，用来释放资源（注销回调函数），未调用报错 IllegalStateException。

fun showWithFlow(): Flow<Int> = callbackFlow {
    //1.创建Flow并发送值（实现Callback接口）
    val callback = object: NetCallback {
        override fun onNextValue(value: Int) {
            try {
                offer(num)
            } catch(t: Throwable) {...}
        }
        override fun onError(ecxeption: Throwable) {
            cancel(CancellationException("API发生错误", exception))
        }
        override fun onCompleted() = close()
    }
    //2.注册回调（传参使用，并对API进行配置操作）
    getData(callback)
    //3.取消协程并注销回调（用来释放API资源）
    awaitClose {...}
}

2.5 emptyFlow

返回一个空的Flow。

public fun <T> emptyFlow(): Flow<T> = EmptyFlow

val flow = emptyFlow<Int>()

2.6 channelFlow

比 Channel 更冷（触发collect才开始生产）比 Flow 更热（生产消费可以异步执行）。

public fun <T> channelFlow(@BuilderInference block: suspend ProducerScope<T>.() -> Unit): Flow<T>

val flow = channelFlow<Int> { }

三、中间操作 Intermediaries

执行一些操作，不会立即执行，返回的还是Flow。

3.1 状态监控

注意：链式调用中出现多个onStart { action }时，后出现的 action 会先执行，因为后续 onStart 构建的下游流包在了上游 onStart 的外面，并且 action 会在收集上游流数据之前执行。而这个结论却不能沿用到onCompletion { action }，虽然 onCompletion 构建的下游流也包裹在上游 onCompletion 外面，但是 action 总是在收集上游流之后执行。

onStart	public fun <T> Flow<T>.onStart(action: suspend FlowCollector<T>.() -> Unit): Flow<T>  在数据生产之前调用。（可以用来做耗时操作之前的操作，例如UI展示进度条）
onCompletion	public fun <T> Flow<T>.onCompletion(action: suspend FlowCollector<T>.(cause: Throwable?) -> Unit): Flow<T> 在数据消费完后（参数case = null）或者出现异常时（case != null）调用。只能判断有没有发生异常，不能捕获异常。（可以用来做耗时操作结束后的操作，例如UI隐藏进度条）
onEmpty	public fun <T> Flow<T>.onEmpty(action: suspend FlowCollector<T>.() -> Unit): Flow<T> 在flow完成却未发送任何值时调用。（可以用来发送默认值）
onEach	public fun <T> Flow<T>.onEach(action: suspend (T) -> Unit): Flow<T> 遍历

3.2 过滤

filter	public inline fun <T> Flow<T>.filter(crossinline predicate: suspend (T) -> Boolean): Flow<T> 保留符合条件的值。
filterNot	public inline fun <T> Flow<T>.filterNot(crossinline predicate: suspend (T) -> Boolean): Flow<T> 保留不符合条件的值。
filterNotNull	public fun <T: Any> Flow<T?>.filterNotNull(): Flow<T> 保留不为null的值。
filterIsInstance	public inline fun <reified R> Flow<*>.filterIsInstance(): Flow<R> = filter { it is R } as Flow<R> 保留对应类型的值（类型填到泛型里面）。

3.3 截取

3.3.1 保留

take	public fun <T> Flow<T>.take(count: Int): Flow<T>  获取几个值，丢弃剩下的。
takeWhile	public fun <T> Flow<T>.takeWhile(predicate: suspend (T) -> Boolean): Flow<T> 满足条件就获取值，只要碰到不满足条件的值就丢弃剩下全部值（即便剩下的里面有满足条件的），第一个值就不满足会全部丢弃。

val flow = (1..5).asFlow()
flow.take(3).collect { print(",$it") }  //打印：1，2，3
flow.takeWhile { it > 3 }.collect { print(",$it") }  //打印：无内容

3.3.2 丢弃

drop	public fun <T> Flow<T>.drop(count: Int): Flow<T> 丢弃几个值，获取剩下的。
dropWhile	public fun <T> Flow<T>.dropWhile(predicate: suspend (T) -> Boolean): Flow<T> 满足条件就丢弃值，只要碰到不满足条件的值就获取剩下全部值（即便剩下的里面有满足条件的），第一个值就不满足会全部获取。

val flow = (1..5).asFlow()
flow.drop(3).collect { print(",$it") }  //打印：4，5
flow.dropWhile { it == 3 }.collect { print(",$it") }  //打印：1，2，3，4，5

3.4 防抖

debounce	public fun <T> Flow<T>.debounce(timeoutMillis: Long): Flow<T> 用来确保前后两次值之间存在指定的时间间隔，大于等于间隔时间会发送前一个值，小于间隔时间只保留最后一个，肯定会发送最后一个值。使用场景：例如搜索框等用户停顿一段时间再去显示搜索建议，而不是每个字都搜索（网络延迟低于输入速度得到的数据也无意义）。
sample	public fun <T> Flow<T>.sample(periodMillis: Long): Flow<T> 周期性在指定时间后采样一个值。使用场景：例如数据量很大只需要取少量的时候，像同一时间存在大量的弹幕，只取其中一条显示不可能全部显示。

flow {
    emit(1)
    emit(2)
    delay(600)
    emit(3)
    delay(100)
    emit(4)
    delay(100)
    emit(5)
}.debounce(500)    //只发送 2、5

flow {
    while(true) {
        emit("弹幕")
    }
}.sample(1000)    //每一秒只取一个值
.flowOn(Dispatches.IO)    //由于是死循环需要放在子线程

3.5 去重

distinctUntilChanged	public fun <T> Flow<T>.distinctUntilChanged(): Flow<T> 过滤用，下面一个的简化版本。连续两个值一样，则跳过发送。
distinctUntilChangedBy	public fun <T> Flow<T>.distinctUntilChanged(): Flow<T> 去重操作符，判断连续的两个值是否重复，可以选择是否丢弃重复值。

3.6 转换

map 和 filter 底层就是使用的 transform。transform 能 emit 任意次数，flow 中每个值都会循环一遍 transform 中的 emit，而 map 只能对值转换。

transform	public inline fun <T, R> Flow<T>.transform(@BuilderInference crossinline transform: suspend FlowCollector<R>.(value: T) -> Unit): Flow<R> 可以 emit 任意次数，flow 中每个值都会循环一遍 transform 中的 emit。
transformLatest	public fun <T, R> Flow<T>.transformLatest(@BuilderInference transform: suspend FlowCollector<R>.(value: T) -> Unit): Flow<R> 只对最后一个值消费。
transformWhile	public fun <T, R> Flow<T>.transformWhile(@BuilderInference transform: suspend FlowCollector<R>.(value: T) -> Boolean): Flow<R> 为true继续消费，为false后续值都丢弃。

map	public inline fun <T, R> Flow<T>.map(crossinline transform: suspend (value: T) -> R): Flow<R> 对值进行转换后再emit。
mapLatest	public fun <T, R> Flow<T>.mapLatest(@BuilderInference transform: suspend (value: T) -> R): Flow<R> 只对最后一个值转换，会丢弃其它值。
mapNotNull	public inline fun <T, R: Any> Flow<T>.mapNotNull(crossinline transform: suspend (value: T) -> R?): Flow<R> 转换会丢弃null值。

val flow = (1..3).asFlow()
//map只能转换元素
flow.map { "[$it-a]" }.collect { print(it) }  //打印：[1-a][2-a][3-a]
//mapNotNull不处理null值
flow{
    emit(1)
    emit(2)
    emit(null)
    emit(3)
}.mapNotNull { it?.plus(1) }.collect { print("$it,") } //打印：2,3,4
//flow中每个值都会循环一遍transform中的emit
flow.transform {
    emit("[$it-a]")
    emit("[$it-b]")
}.collect { print(it) } //打印：[1-a][1-b][2-a][2-b][3-a][3-b]
//transform实现filter和map
flow.transform {
    emit(it + 1)
}.transform {
    if (it % 2 == 0) emit(it)
}.collect { print("$it,") }    //打印：2,4

flow.transformLatest {
    delay(1000) //此处不延迟的话会每个值都处理而不是只处理最后一个
    emit(it*10)
}.collect { print("$it,") } //打印：20

flow.transformWhile {
    emit(it)
    it != 3
}.collect { print("$it,") } //打印：1,2

3.7 线程切换

生产默认执行在消费处所在的协程指定的线程上，生产一个消费一个是同步的。指定线程后，生产和消费是异步进行。

flowOn

public fun <T> Flow<T>.flowOn(context: CoroutineContext): Flow<T>  flowOn使上游执行在指定的线程上，不会影响下游。上游还有 flowOn 的时候，只影响他们之间的那些操作。下游默认还是执行在消费所在的线程。

3.8 背压

数据的消费速度赶不上生产速度。默认情况下生产一个消费一个是同步交替进行的不存在背压，emit和collect都是挂起函数会等待对方准备好，最终耗时是每个值生产和消耗的时间总和。buffer使生产和消费并发运行提高效率，设置缓冲区大小（从0开始算的），消费来不及就先把值缓存起来等待着。

• BufferOverflow.SUSPEND：默认模式，缓冲区满了就和默认情况一样挂起（等待消费），消费一个再生产一个。
• BufferOverflow.DROP_OLDEST：缓冲区满了就丢弃还没消费掉的旧值，存入新值。
• BufferOverflow.DROP_LATEST：缓冲区满了就丢弃后来生产的新值，直到有空位了再往里存又生产的值（不是丢弃掉的那些）。

buffer	public fun <T> Flow<T>.buffer(capacity: Int = BUFFERED, onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND): Flow<T>  参数capacity是缓冲区大小，参数onBufferOverflow是对缓冲区满后新值的处理模式。
conflate	public fun <T> Flow<T>.conflate(): Flow<T> 会丢弃中间值，只消费首尾值。相当于 buffer(0 , BufferOverflow.DROP_OLDEST)。

3.9 重试

retry	当上游发生异常时可以重新执行几次。retryWhen 的简化版。
retryWhen	有条件的进行重试 ，lambda 中有两个参数: 一个是 异常原因，一个是当前重试的 index (从0开始)。lambda 的返回值 为 Boolean ，true则继续重试 ,false 则结束重试。

(1..3).asFlow().onEach{
    if(it == 3) throw Exception("发生异常")
    delay(100)
    println("生产：$it")
}.retry(2){
    it.message = "有异常"
}.catch{ ex ->
    println("捕获异常：${ex.massage}")    //用it试试
}.collect{
    println("消费：$it")
}

3.10 规约（发送每步计算的结果）

scan	public fun <T, R> Flow<T>.scan(initial: R, @BuilderInference operation: suspend (accumulator: R, value: T) -> R): Flow<R> 会把初始值和每一步的操作结果发送出去。

(1..3).asFlow()
    .onEach { delay(200) }
    .scan(1) { acc, v -> acc + v }
    .collect { print("$it,") }    //打印：1，2，4，7

3.11 Android生命周期

flowWithLifecycle

public fun <T> Flow<T>.flowWithLifecycle(     lifecycle: Lifecycle,     minActiveState: Lifecycle.State = Lifecycle.State.STARTED ): Flow<T> = callbackFlow {     lifecycle.repeatOnLifecycle(minActiveState) {         this@flowWithLifecycle.collect {             send(it)         }     }     close() } 生命周期低于目标状态会取消上游，不影响下游，需要注意调用顺序。

3.12 操作多个流

3.12.1 合并

merge	public fun <T> merge(vararg flows: Flow<T>): Flow<T> 将两个Flow中的值连接起来。
zip	public fun <T1, T2, R> Flow<T1>.zip(other: Flow<T2>, transform: suspend (T1, T2) -> R): Flow<R> 将两个Flow中同索引的值根据条件合并成一个值（两个值是并行各自计算出来后合并的），长度短的Flow执行完就结束，长度长的Folw多的值会被舍弃。使用场景：两件无关的事情同时做再一起显示，例如当前天气和未来7天天气没有先后依赖关系却要同时显示，先后请求效率低一些可以同时做。当然3个请求同时并发处理也是可以的。
combine	public fun <T1, T2, R> Flow<T1>.combine(flow: Flow<T2>, transform: suspend (a: T1, b: T2) -> R): Flow<R> 将两个Flow中同索引的值根据条件合并成一个值，短的Flow最后一个值重复跟长的Flow剩下的值合并。

val flow1 = flowOf(1, 2, 3, 4, 5)
val flow2 = flowOf('a', 'b', 'c')
merge(flow1, flow2).collect { print(",$it") }   //打印：1,2,3,4,5,a,b,c
merge(flow2, flow1).collect { print(",$it") }   //打印：a,b,c,1,2,3,4,5
flow1.zip(flow2) { a, b -> "[$a$b]" }.collect { print(it) } //打印：[1a][2b][3c]
flow2.zip(flow1) { a, b -> "[$a$b]" }.collect { print(it) } //打印：[a1][b2][c3]
flow1.combine(flow2) { a, b -> "[$a$b]" }.collect { print(it) } //打印：[1a][2b][3c][4c][5c]
flow2.combine(flow1) { a, b -> "[$a$b]" }.collect { print(it) } //打印：[a1][b2][c3][c4][c5]

fun one(): Flow<String> = flow { emit(a) }
fun two(): Flow<String> = flow { emit(b) }
fun three(): Flow<String> = flow { emit(c) }

one()
.zip(two()) {a, b ->
    user.name = a
    user.age = b
    user
}.zip(three()) { user, c ->
    user.gender = c
    user
}.collect { user ->
    //...
}

3.12.2 展平多维流

flattenConcat	public fun <T> Flow<Flow<T>>.flattenConcat(): Flow<T> 将Flow中的多维值都展平然后全部连接起来。
flattenMerge	public fun <T> Flow<Flow<T>>.flattenMerge(concurrency: Int = DEFAULT_CONCURRENCY): Flow<T> 将Flow中的多维值都展平然后全部连接起来，可以设置并发数。

val flow1 = flowOf(1, 2, 3, 4, 5)
val flow2 = flowOf('a', 'b', 'c', 'd', 'e', 'f')
val flow3 = flowOf(flow1, flow2)
flow3.flattenMerge(2).collect { print(",$it") }  //打印：1,2,3,4,5,a,b,c,d,e,f
flow3.flattenConcat().collect { print(",$it") }  //打印：1,2,3,4,5,a,b,c,d,e,f

3.12.3 组合操作多维流

flatMapContact	public fun <T, R> Flow<T>.flatMapConcat(transform: suspend (value: T) -> Flow<R>): Flow<R> = map(transform).flattenConcat() 流中流，(同步处理数据?)严格按照顺序执行（外流值执行完内流操作，才轮到下一个外流值）。使用场景：前一个值依赖于另一个值，例如获取用户信息依赖于token授权，先发送一个请求获取token再发送一个请求获取信息。
flatMapMerge	public fun <T, R> Flow<T>.flatMapMerge(concurrency: Int = DEFAULT_CONCURRENCY, transform: suspend (value: T) -> Flow<R>): Flow<R> = map(transform).flattenMerge(concurrency) 流中流，并发处理数据不保证顺序（delay(耗时?)短的会先执行）。
flatMapLatest	public inline fun <T, R> Flow<T>.flatMapLatest(@BuilderInference crossinline transform: suspend (value: T) -> Flow<R>): Flow<R> = transformLatest { emitAll(transform(it)) } 流中流，外流再次发送新值的时候，内流没操作完就会被取消，然后开始处理新的一轮。

fun getToken(): Flow<String> = Flow { emit(token) }    //获取token
fun getUserInfo(): Flow<String> = Flow { emit(info) }    //获取用户信息

getToken()
.flatMapContact { token ->
    getUserInfo(token)
}.flowOn(Dispatches.IO)
.collect { userInfo ->
    println(userInfo)
}

flowOf(300, 200, 100)
.flatMapMerge {
    flow {
        delay(it.toLong())
        emit("a$it")
        emit("b$it")
    }
}.collect { println(it) }    //打印：a100,b100,a200,b200,a300,b300

flow {
    emit(1)
    delay(150)
    emit(2)
    delay(50)
    emit(3)
}.flatMapLatest {
    flow {
        delay(100)
        emit("$it")
    }
}.collect { println(it) } //打印：1,3

四、消费者 Consumer

最终操作，会触发流的执行，返回的是结果。

4.1 收集

collect	public suspend fun collect(collector: FlowCollector<T>) 收集Flow中的值。
collectIndexed	public suspend inline fun <T> Flow<T>.collectIndexed(crossinline action: suspend (index: Int, value: T) -> Unit): Unit
collectLatest	public suspend fun <T> Flow<T>.collectLatest(action: suspend (value: T) -> Unit) = mapLatest(action).buffer(0).collect() 当新值到来时，前一个值自己内部没处理完就开始处理新的。

flow {
    var count = 0
    while (true) {
        emit(count)
            delay(1000)
            count++
    }
}.collectLatest {
    println("start $it")
    delay(2000)
    println("end $it")
}    //打印：start 0，start 1，start 2，start 3.....

4.2 线程切换

launchIn

public fun <T> Flow<T>.launchIn(scope: CoroutineScope): Job = scope.launch { collect() } 在指定的其它协程作用域中消费，而不是当前协程中。指定该协程作用域的上下文也就相当于切换了线程，记得接着调用join()。

flowOf(1，2，3)
    .launchIn(CoroutineScope(Dispatchers.IO))    //相当于切换了线程
    .join()

4.3 规约（累计到单个值）

reduce	public suspend fun <S, T : S> Flow<T>.reduce(operation: suspend (accumulator: S, value: T) -> S): S 前一个值和后一个值进行指定运算，再拿结果跟第三个值运算，以此类推得到最终值。（1和2计算后，结果和3运算，结果再和4运算...返回最终结果）。
fold	public suspend inline fun <T, R> Flow<T>.fold( initial: R, crossinline operation: suspend (acc: R, value: T) -> R): R 带初始值，同上（初始值和1计算后，结果和2计算，结果再和3运算...返回最终结果）。
runningFold	区别于 fold ，就是返回一个新流，将每步的结果发射出去。
runningReduce	区别于 reduce ，就是返回一个新流，将每步的结果发射出去。

val flow = (1..5).asFlow()
println(flow.reduce({ a, b -> a + b })) //打印：15
println(flow.fold(2, { a, b -> a + b }))    //打印：17

4.4 转换到其它容器

toCollection toList toSet	将结果转到到集合。
	将结果转换为List。
	将结果转换为Set。
asLiveData	public fun <T> Flow<T>.asLiveData(     context: CoroutineContext = EmptyCoroutineContext,//区块所执行的协程上下文，默认+Main.immediate     timeoutInMs: Long = DEFAULT_TIMEOUT//没有观察者后，多少毫秒后取消区块，默认5s。 ): LiveData<T> 将结果转到LiveData。
asStateFlow	转为StateFlow。
asShareFlow	转为SharedFlow。

4.5 取最值

last lastOrNull first firstOrNull single singleOrNull	获取最后一个值，为null会抛异常 NoSuchElementException。
	获取最后一个值，可以为null。
	获取第一个值，如果为空会抛异常 NoSuchElementException。
	获取第一个元值，可以为null。
	接收流发送的第一个值 ，区别于first，如果为空或者发了不止一个值，则都会报错。
	接收流发送的第一个值 ，可以为努力了，发出多值的话除第一个，后面均被置为null。
count	返回流发送值的个数。类似list.size，注：sharedFlow无效(无意义）

五、流的取消

5.1 协作取消

Flow在协程中消费，因此协程的取消会一并取消Flow。Flow{ }形式的创建对 emit() 操作附加了 ensureActive() 以检测协程的取消，但出于性能原因其它构建形式和操作不会自行检查以响应，因此需要手动调用 cancellable() 检查。

cancellable( )

public fun <T> Flow<T>.cancellable(): Flow<T>

val flow = flow { repeat(5) { emit(it) } }
withTimeout(2500) { flow.collect { println(it) } }

//该构建方式会对发射值附加取消检测
flow {
    repeat(5) { emit(it) }
}.collect {
    if (it == 3) cancel()
}
//其它构建方式需要手动检查
(1..5).asFlow().cancellable().collect {
    println(it)
    if (it == 3) cancel()
}

六、异常处理

在flow构建器或处理值的时候可能发生异常，异常会向下流动关闭每个处理步骤，如果没有调用catch，未捕获的异常会立即取消该flow，在消费时重新抛出。可以在flow内部使用 try-finally 语句，也可以在flow外部使用 try-catch 语句。在Android开发中 catch() 可以用来展示错误信息或者显示默认数据（例如空列表）。

catch

public fun <T> Flow<T>.catch(action: suspend FlowCollector<T>.(Throwable) -> Unit): Flow<T> 只能捕获上游的异常，上游还有catch那就是它俩捕获之间的，捕获后下游不会再捕获得到。可以在代码块中使用 throw 再次抛出、可以使用 emit 转换为值发射、或其他处理。

flow {
    emit(1)
    emit(2)
    throw NullPointerException()
}.map {
    it +1
}.catch {
    println("catch：$it")
}.collect {
    println("collect：$it")
}
//打印：
//collect：2
//collect：3
//catch：java.lang.NullPointerException

七、Flow和Suspend区别

	Flow	Suspend
作用	连续性的异步数据流（多个值）	一次性的异步任务（单个值）
场景	实时数据频繁刷新（点赞数、）	无需更新数据（文章内容）

八、一些Android示例

fun updateNews() = flow{
    apiService.updateNews()
}.onStart { showProgressBar() }
.onCompletion { hideProgressBar() }
.onEach { view.show(it) }
.catch { view.handleError(it) }

viewModelScope.launch {
    updateNews.collect {...}
}

待整理

回调

onSubion

SharedFlow 专属操作符 （StateFlow是SharedFlow 的一种特殊实现）。

变换

receiveAsFlow consumeAsFlow	将Channel 转换为Flow ,可以有多个观察者，但不是多播，可能会轮流收到值。
	将Channel 转换为Flow ,但不能多个观察者（会crash）!
withIndex	将结果包装成IndexedValue类型。
produceIn	转换为ReceiveChannel , 不常用。

组合

conbineTransform

顾名思义 combine+ transform