瞅一眼Kotlin Flow_kotlin flow 防抖，提交面试材料

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数HarmonyOS鸿蒙开发工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年HarmonyOS鸿蒙开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上HarmonyOS鸿蒙开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新

如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注鸿蒙获取）

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

Kotlin Flow是Kotlin中响应式编程框架的实现，是Kotlin生态中的一个重要组成部分，而提到响应式编程框架，作为Android开发的我们势必会联想RxJava，因其丰富、强大的功能，陡峭的学习曲线，让人又爱又恨。相较于RxJava，Flow的一个最大特点是其基于Kotlin协程，一个Flow必须运行在协程中，因此在Flow中我们能够利用协程提供的特性编写更加简洁、轻量的异步代码。

1、响应式编程

关于响应式编程，在我的理解中，它是一种面向异步 数据流的编程范式。其中数据流的概念很好理解，就是一组按时间顺序排列的数据序列；而异步是指数据的接收是通过注册的callback/observer/collector来完成的，典型的观察者模式。

正因为响应式编程面向的是异步数据流，而不是函数，所以能够在此之上抽象出一组强大的工具函数，让我们使用少量的代码便能实现复杂的业务逻辑，比如搜索框防抖，多个有依赖关系的网络请求等等。

借用文章中的一个例子，假设我们现在想要统计用户在一次“连击”中对应的点击次数，把250ms内大于等于2次以上的点击视为一次“连击”。 在传统的编程模型下，我们势必要定义一些的变量来记录状态以及编写相应的定时逻辑，但是在响应式编程中，我们只需要极少量的代码便能完成上述逻辑。

通过下面的示意图来更直观地理解这一过程：

首先通过buffer(clickStream.throttle(250ms))将250ms内的产生的点击事件聚合成一个list，再使用map('get length of list')将list的数据流转换为list长度的数据流，最后过滤掉长度小于2的数据就得到了最终期望的数据流。

2、基本概念

在进一步之前，先介绍下Flow中的一些基本概念。在官方文档中，将Flow关联的各角色划分为三类：

• 生产者（Producer）：负责数据的生产、发送；
• 中介（Intermediary）：可选的，可以有若干个，负责对Flow中的数据，甚至是Flow本身的进行变换；
• 消费者（Consumer）：负责从Flow中接收数据。

中介其实就是各类中间操作符：map、filter等，根据角色在数据流中的位置，我们将其上面的部分称作上游，下面的部分称作下游。

举一个例子🌰，假设我们有如下的数据流，Intermediary[i] 便是Producer->…->Intermediary[i - 1] 的下游、Intermediary[i + 1] ->…->Consumer的上游：

Producer->...->Intermediary[i- 1 ] ->Intermediary[i] ->Intermediary[i+ 1 ] ->...->Consumer

二、Flow的创建和使用

创建一个Flow非常简单，官方提供了一个顶层函数用于创建Flow，如下所示：

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

这一顶层函数又被称作Flow builder，其中有两个关键的接口：Flow和FlowCollector。

public interface Flow<out T> {
    public suspend fun collect(collector: FlowCollector<T>)
}

public fun interface FlowCollector<in T> {
    /**
     * Collects the value emitted by the upstream.
     * This method is not thread-safe and should not be invoked concurrently.
     */
    public suspend fun emit(value: T)
}

Flow描述一个异步数据流，类似于RxJava中的Observable，而FlowCollector负责数据的接收，类似于RxJava中的Observer。

Flow的定义很简单，只有一个collect方法，接收一个FlowCollector对象作为参数。当调用collect方法时，会将定义好的FlowCollector对象传递至上游，上游会使用传递过来的FlowCollector对象的emit方法来发送数据。

回到Flow builder，其接收一个使用suspend修饰，FlowCollector的扩展函数：block，又被称作Producer block，负责数据的生产，并将生产好的数据通过FlowCollector对象的emit方法发送。

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

来看一个简单的例子：

private val myFlow = flow<Int> producer@{
    var value = 0
    while (true) {
        emit(value++)
        delay(1000)
    }
}

GlobalScope.launch {
    myFlow.collect(object : FlowCollector<Int> {
        override suspend fun emit(value: Int) {
            Log.i(TAG, "receive $value")
        }
    })
}

这里定义了一个每间隔1秒发送一次数据的Flow，因为Flow需要运行在协程中，所以通过GlobalScope.launch启动了一个协程，然后在协程中调用Flow对象的collect方法，并传递一个FlowCollector实例，在其emit方法中接收上游发送过来的数据。

需要注意的是，通过Flow Builder创建的Flow属于冷流，意味着只有当Flow的终端操作函数被调用时，比如collect函数，才会执行生产者代码，也就是示例中的producer代码块，并且每次调用终端操作函数时都会创建一条新的数据流，彼此互不影响，在下面的示例中producer代码块会被执行两次，产生两条数据流：

GlobalScope.launch {
    myFlow.collect consumer1@{ value -> Log.i(TAG, "receive $value") }
}
GlobalScope.launch {
    myFlow.collect consumer2@{ value -> Log.i(TAG, "receive $value") }
}

此外，因为FlowCollector的emit方法并不是线程安全的，所以不允许我们在一个新的协程或者新的Dispatcher中调用，以下代码都是非法的：

private val myFlow1 = flow<Int> {
    GlobalScope.launch { 
        emit(1)
    }
}

private val myFlow2 = flow<Int> {
    withContext(Dispatchers.IO) {
        emit(1)
    }
}

1、操作符

1.1、生命周期

Flow中提供了onStart、onCompletion操作符用于监听数据流的开始、结束，以onStart为例：

public fun <T> Flow<T>.onStart(
    action: suspend FlowCollector<T>.() -> Unit
): Flow<T>

参数action是一个使用suspend修饰，FlowCollector的扩展函数，其Receiver直接/间接地持有从下游传递过来的FlowCollector对象，允许我们调用emit方法向数据流的开头添加额外的数据，如下所示：

GlobalScope.launch {
    flowOf(1, 2)
        .onStart {
            emit(0)
        }
        .onCompletion {
            emit(3)
        }
        .collect {
            Log.i(TAG, "receive $it")
        }
}
// receive 0
// receive 1
// receive 2
// receive 3

1.2、线程切换

前面有提到，不允许在新起的协程/线程中调用FlowCollector的emit方法，如果需要显示地切换生产者代码运行的线程，需要借助flowOn操作符：

public fun <T> Flow<T>.flowOn(context: CoroutineContext): Flow<T>

private val myFlow = flow<Int> producer@{
    var value = 0
    while (true) {
        emit(value++)
        delay(1000)
    }
}

GlobalScope.launch(Dispatchers.Main) {

public fun Flow.flowOn(context: CoroutineContext): Flow

private val myFlow = flow producer@{
var value = 0
while (true) {
emit(value++)
delay(1000)
}
}

GlobalScope.launch(Dispatchers.Main) {