Kotlin：Flow 全面详细指南，附带源码解析。

如何取消一个Flow呢？

Kotlin官方并没有提供flow取消的函数。啊 这？？？😕听到这个是不是还满疑惑。且听我细细道来。

Flow需要在协程里面使用，因为collect是挂起函数，另外基于冷流的特性，不调用collect构建器的代码压根不会走。所以只能是协程。那 我取消协程不就行了吗？😮。好像之前有看到过有开发者提出过，是否要给flow单独加一个取消的函数，被Jetbrains无情的拒绝了，哈哈哈哈很搞笑。下面引用Kotlin官方的一段话。

Flow adheres to the general cooperative cancellation of coroutines. As usual, flow collection can be cancelled when the flow is suspended in a cancellable suspending function (like delay).

adheres 坚持

Flow 坚持协程的一般协作取消。 像往常一样，当流在可取消的挂起函数（如延迟）中被挂起时，可以取消流收集。

这个adheres好像就像是在回复广大的开发者，你取消协程就行了😂😂😂。

好了，下面看取消的🌰

fun simple(): Flow = flow {

for (i in 1…3) {

delay(100)

println(“emit $i”)

emit(i)

}

}

fun main() = runBlocking {

val job = launch {

simple().collect { println(it) }

}

delay(250)

job.cancel(CancellationException(“timeout 250”))

println(“done”)

}

结果：看我们只需要取消对应的协程即可，对应的flow也会被取消收集。

emit 1

1

emit 2

2

done

这里引申一点，对于timeout，官方有提供专用的操作函数,withTimeout系列。不需要我们手动delay然后继续调用取消，毕竟不是很优雅。

上述代码也可以写成如下的形式

fun simple(): Flow = flow {

for (i in 1…3) {

delay(100)

println(“emit $i”)

emit(i)

}

}

fun main() = runBlocking {

withTimeoutOrNull(250) {

simple().collect { value -> println(value) }

}

println(“done”)

}

看到了吗？直接将launch替换为withTimeoutOrNull就可以做到延时取消效果了，这里简单做一下源码分析。

源码

public suspend fun withTimeoutOrNull(timeMillis: Long, block: suspend CoroutineScope.() -> T): T? {

…

try {

return suspendCoroutineUninterceptedOrReturn { uCont ->

val timeoutCoroutine = TimeoutCoroutine(timeMillis, uCont)

coroutine = timeoutCoroutine

setupTimeout<T?, T?>(timeoutCoroutine, block)

}

} catch (e: TimeoutCancellationException) {

…

}

}

private class TimeoutCoroutine<U, in T: U>(

@JvmField val time: Long,

uCont: Continuation // unintercepted continuation

) : ScopeCoroutine(uCont.context, uCont), Runnable {

override fun run() {

cancelCoroutine(TimeoutCancellationException(time, this))

}

…

}

private fun <U, T: U> setupTimeout(

coroutine: TimeoutCoroutine<U, T>,

block: suspend CoroutineScope.() -> T

): Any? {

// schedule cancellation of this coroutine on time

coroutine.disposeOnCompletion(context.delay.invokeOnTimeout(coroutine.time, coroutine, coroutine.context))

…

}

public fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle =

DefaultDelay.invokeOnTimeout(timeMillis, block, context)

省略了一大堆非核心的代码，我们直接看延时取消的操作，这里简单分析一下：

• 创建TimeoutCoroutine对象，它同时实现了Runnable，在run里面调用了取消函数，抛出TimeoutCancellationException。

• 调用当前context的invokeOnTimeout函数，该函数需要一个Runnable，传入了timeoutCoroutine。此实现使用内置的单线程调度执行器服务。会在延时对应的事件后调用Runnable的run函数，然后就会取消当前的协程。

• 在取消协程之后，会取消掉当前上下文的所有将在完成时调用的回调，disposeOnCompletion函数被调用。

Flow 相关操作符

这一块的操作符，其实是比较多的。但是如果您熟悉RxJava的话，其实都是差不多的。这一块这里就不做源码分析了，只是看一下怎么使用即可。内部其实是创建了新的流返回出来了，有兴趣的话可以自行查看一下源码。

中间流操作符

map

映射。看🌰(传入请求流可以使用 map 操作符映射到结果，即使执行请求是由挂起函数实现的长时间运行的操作)

suspend fun performRequest(request: Int): String {

delay(1000) // 模拟长时间的异步工作

return “response $request”

}

fun main() = runBlocking {

(1…3).asFlow() // 转换为flow

.map { request -> performRequest(request) }

.collect { response -> println(response) }

}

结果

response 1

response 2

response 3

filter

过滤操作,看🌰

suspend fun performRequest(request: Int): String {

delay(1000) // 模拟长时间的异步工作

return “response $request”

}

fun main() = runBlocking {

(1…3).asFlow() // 转换为flow

.map { request -> performRequest(request) }

.filter { it == “response 1” }

.collect { response -> println(response) }

}

结果：仅返回匹配到的值

response 1

变换操作符

在流变换算子中，最通用的一种叫做变换。 它可以用来模仿简单的转换，比如 map 和 filter，也可以实现更复杂的转换。 使用transform，我们可以发出任意次数的任意值。

例如🌰，使用transform，我们可以在执行长时间运行的异步请求之前发出一个字符串，并在其后响应：

(1…3).asFlow() // a flow of