Kotlin的协程：flow

最新推荐文章于 2023-11-10 22:31:17 发布
最新推荐文章于 2023-11-10 22:31:17 发布
阅读量1.2k 收藏 4
点赞数 1
分类专栏： Kotlin 基础 Android 开发 文章标签： kotlin java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoshen2014/article/details/127412493
版权

flow 介绍

之前介绍的启动协程方法，比如 launch、async 都是协程的单次启动。如果有复杂场景，比如发送多个数据，就需要使用 flow 数据流。在 flow 中，数据如水流一样经过上游发送，中间站处理，下游接收。

创建 flow

创建 flow 有 3 种方式：

  1. flow{}
  2. flowOf()
  3. asFlow()

flow

flow{} 中使用 emit 发送数据。

fun flowEmit() = runBlocking {
    flow {
        emit(1)
        emit(2)
        emit(3)
        emit(4)
        emit(5)
    }
        .filter {
            it > 2
        }
        .map {
            it * 2
        }
        .take(2)
        .collect {
            // 6 8
            println(it)
        }
}

flowOf

flowOf() 可以将指定的一串数据转换为 flow，接收可变参数。

fun flowOfFun() = runBlocking {
    flowOf(1, 2, 3, 4, 5)
        .filter { it > 2 }
        .map { it * 2 }
        .take(2)
        .collect {
            // 6 8
            println(it)
        }

    listOf(1, 2, 3, 4, 5)
        .filter { it > 2 }
        .map { it * 2 }
        .take(2)
        .forEach {
            // 6 8
            println(it)
        }
}

asFlow

asFlow() 可以将 List 集合转换为 flow。toList() 可以将 flow 转换为 List 集合。

fun flow2list() = runBlocking {
    flowOf(1, 2, 3, 4, 5)
        // flow to list
        .toList()
        .filter { it > 2 }
        .map { it * 2 }
        .take(2)
        .forEach {
            println(it)
        }

    listOf(1, 2, 3, 4, 5)
        // list as flow
        .asFlow()
        .filter { it > 2 }
        .map { it * 2 }
        .take(2)
        .collect {
            println(it)
        }
}

中间操作符

创建 flow 之后使用中间操作符处理 flow 的每一个数据。flow 的中间操作符和 list 集合的操作符非常类似。
常用中间操作符：

  1. filter
  2. map
  3. take

filter

filter 传入判断条件，条件满足时过滤数据，否则不将数据流向下游。

map

map 传入映射函数，将每个数据传入映射函数，得到结果继续传入下游。

take

take 传入非负整数 n，取前 n 个数据传入下游。

fun flowEmit() = runBlocking {
    flow {
        emit(1)
        emit(2)
        emit(3)
        emit(4)
        emit(5)
    }
        .filter {
            it > 2
        }
        .map {
            it * 2
        }
        .take(2)
        .collect {
            // 6 8
            println(it)
        }
}

终止操作符

collect 是 flow 的终止操作符，收集每一个数据经过中间操作符后的最终结果，表示 flow 流的终止，后面不能再调用中间操作符。

除了 collect，还有一些其他的终止操作符，first、single、fold、reduce。

collect

返回所有元素，结束 flow。

fun flowEmit() = runBlocking {
    flow {
        emit(1)
        emit(2)
        emit(3)
        emit(4)
        emit(5)
    }
        .filter {
            it > 2
        }
        .map {
            it * 2
        }
        .take(2)
        .collect {
            // 6 8
            println(it)
        }
}

first

返回第一个元素，结束 flow。

fun flowFirst() = runBlocking {
    val first = flow {
        emit(1)
        emit(2)
        emit(3)
        emit(4)
        emit(5)
    }
        .filter {
            it > 2
        }
        .map {
            it * 2
        }
        .take(2)
        .first()
    // 6
    println(first)
}

single

返回唯一元素，结束flow。不能多于一个，也不能一个没有。

fun flowSingle() = runBlocking {
    val single = flow {
        emit(3)
    }
        .filter {
            it > 2
        }
        .map {
            it * 2
        }
        .take(2)
        .single()
    // 6
    println(single)
}

fold

折叠所有元素。指定一个函数和初始值，对每一个元素反复执行函数，返回最后的结果。

fun flowFold() = runBlocking {
    val fold = flow {
        emit(1)
        emit(2)
        emit(3)
        emit(4)
        emit(5)
    }.filter {
        it > 2
    }.map {
        it * 2
    }.take(2)
        .fold(0) { acc, value ->
            acc + value
        }

    // 14
    println(fold)
}

reduce

reduce 和 fold 很类似，reduce 没有初始值。

fun flowReduce() = runBlocking {
    val reduce = flow {
        emit(1)
        emit(2)
        emit(3)
        emit(4)
        emit(5)
    }.filter {
        it > 2
    }.map {
        it * 2
    }.take(2)
        .reduce { acc, value ->
            acc + value
        }
    // 14
    println(reduce)
}

first、single、fold、reduce 本质都是封装了 collect ，因此它们都是终止操作符。

生命周期

onStart

onStart 是 flow 的开始生命周期回调。onStart 的执行时机和它在 flow 位置无关。

对比下面两个方法，onStart 都会在第一时间回调。

fun onStartFun() = runBlocking {
    flowOf(1, 2, 3, 4, 5)
        .filter {
            println("filter: $it")
            it > 2
        }
        .map {
            println("map: $it")
            it * 2
        }
        .take(2)
        .onStart {
            println("onStart")
        }
        .collect {
            println("collect: $it")
        }
}

fun onStartFun2() = runBlocking {
    flowOf(1, 2, 3, 4, 5)
        .take(2)
        .filter {
            println("filter: $it")
            it > 2
        }
        .map {
            println("map: $it")
            it * 2
        }
        .onStart {
            println("onStart")
        }
        .collect {
            println("collect: $it")
        }
}

onComplete

flow 执行完后回调 onComplete。onComplete 的执行时机和它在 flow 的位置无关。

flow 正常执行完回调 onComplete。

fun onCompleteFun() = runBlocking {
    flowOf(1, 2, 3, 4, 5)
        .onCompletion {
            println("onCompletion")
        }
        .filter {
            println("filter: $it")
            it > 2
        }
        .take(2)
        .collect {
            println("collect: $it")
        }
}

flow 执行被取消，或者 flow 执行中出现异常。

fun cancelOnCompleteFun() = runBlocking {
    launch {
        flow {
            emit(1)
            emit(2)
            emit(3)
        }
            // collect: 1
            //collect: 2
            //cancel
            //onCompletion first: kotlinx.coroutines.JobCancellationException
            .onCompletion {
                println("onCompletion first: $it")
            }
            .collect {
                println("collect: $it")
                if (it == 2) {
                    // cancel flow
                    cancel()
                    println("cancel")
                }
            }
    }

    delay(1000)

    flowOf(4, 5, 6)
//    collect: 4
//    onCompletion second: java.lang.IllegalStateException
        .onCompletion {
            println("onCompletion second: $it")
        }
        .collect {
            println("collect: $it")
            throw IllegalStateException()
        }

}

异常处理

flow 的异常处理可以分为上游异常和下游异常。上游异常指创建 flow 或者中间操作符发生的异常。下游异常指终止操作符 collect 发生的异常。

上游异常

上游异常可以用 catch 函数捕获异常。catch 函数和它的位置相关，只能捕获 catch 上游的异常。

fun flowCatch() = runBlocking {
    val flow = flow {
        emit(1)
        emit(2)
        throw IllegalStateException()
        emit(3)
    }
    flow.map {
        it * 2
    }.catch {
        println("catch: $it")
    }.collect {
        println(it)
    }
    //    2
    //    4
    //    catch: java.lang.IllegalStateException
}

下游异常

下游异常不能用 catch 函数，需要在 collect 的作用域用 try-catch 捕获。

catch 函数无法捕获下游的 filter 除 0 异常。

fun flowCatchDownStream() = runBlocking {
    val flow = flow {
        emit(1)
        emit(2)
        emit(3)
    }

    flow.map {
        it * 2
    }.catch {
        println("catch: $it")
    }.filter {
        it / 0 > 1
    }.collect {
        println(it)
    }
    // Exception in thread "main" java.lang.ArithmeticException: / by zero
}

使用 try-catch 捕获 collect 的异常。

fun flowTryCatch() = runBlocking {
    flowOf(4, 5, 6)
        .onCompletion {
            println("onCompletion second: $it")
        }
        .collect {
            try {
                println("collect: $it")
                throw IllegalStateException()
            } catch (e: Exception) {
                println("catch $e")
            }
        }
//    collect: 4
//    catch java.lang.IllegalStateException
//            collect: 5
//    catch java.lang.IllegalStateException
//            collect: 6
//    catch java.lang.IllegalStateException
//            onCompletion second: null
}

线程切换

flowOn

flowOn 可以指定上游所有操作符运行的线程，和它的位置相关。

collect 运行在 main 线程，上游运行在 IO 线程，指定 DefaultDispatcher。

fun flowOn() = runBlocking {
    val flow = flow {
        logX("Start")
        emit(1)
        logX("Emit: 1")
        emit(2)
        logX("Emit: 2")
        emit(3)
        logX("Emit: 3")
    }

    flow.filter {
        logX("Filter: $it")
        it > 2
    }
        .flowOn(Dispatchers.IO)
        .collect {
            logX("Collect: $it")
        }
//    ================================
//    Start
//    Thread:DefaultDispatcher-worker-1, time:1666096501866
//    ================================
//    ================================
//    Filter: 1
//    Thread:DefaultDispatcher-worker-1, time:1666096501917
//    ================================
//    ================================
//    Emit: 1
//    Thread:DefaultDispatcher-worker-1, time:1666096501917
//    ================================
//    ================================
//    Filter: 2
//    Thread:DefaultDispatcher-worker-1, time:1666096501917
//    ================================
//    ================================
//    Emit: 2
//    Thread:DefaultDispatcher-worker-1, time:1666096501917
//    ================================
//    ================================
//    Filter: 3
//    Thread:DefaultDispatcher-worker-1, time:1666096501917
//    ================================
//    ================================
//    Emit: 3
//    Thread:DefaultDispatcher-worker-1, time:1666096501917
//    ================================
//    ================================
//    Collect: 3
//    Thread:main, time:1666096501917
//    ================================
}

flowOn 在 filter 之前，emit 执行在 IO 线程，filter 和 collect 执行在 main 线程。

fun flowOnIO() = runBlocking {
    val flow = flow {
        logX("Start")
        emit(1)
        logX("Emit: 1")
    }

    flow.flowOn(Dispatchers.IO)
        .filter {
            logX("Filter: $it")
            it > 0
        }
        .collect {
            logX("Collect: $it")
        }

//    ================================
//    Start
//    Thread:DefaultDispatcher-worker-1, time:1666165816908
//    ================================
//    ================================
//    Emit: 1
//    Thread:DefaultDispatcher-worker-1, time:1666165816942
//    ================================
//    ================================
//    Filter: 1
//    Thread:main, time:1666165816944
//    ================================
//    ================================
//    Collect: 1
//    Thread:main, time:1666165816944
//    ================================
}

因为 flowOn 只能用于上游，在 collect 可以用 withContext 切换线程，但不建议这么用。

collect 运行在 DefaultDispatcher，其他运行在 main 线程。

fun flowWithContext() = runBlocking {
    val flow = flow {
        logX("Start")
        emit(1)
        logX("Emit: 1")
    }

    flow.filter {
        logX("Filter: $it")
        it > 0
    }
        .collect {
            // 不建议
            withContext(Dispatchers.IO) {
                logX("Collect: $it")
            }
        }

//    ================================
//    Start
//    Thread:main, time:1666167319244
//    ================================
//    ================================
//    Filter: 1
//    Thread:main, time:1666167319297
//    ================================
//    ================================
//    Collect: 1
//    Thread:DefaultDispatcher-worker-2, time:1666167319311
//    ================================
//    ================================
//    Emit: 1
//    Thread:main, time:1666167319312
//    ================================
}

flow 的 emit、filter、collect 都运行在 DefaultDispatcher。

fun flowWithContextAll() = runBlocking {
    val flow = flow {
        logX("Start")
        emit(1)
        logX("Emit: 1")
    }

    // 不建议
    withContext(Dispatchers.IO) {
        flow.filter {
            logX("Filter: $it")
            it > 0
        }.collect {
            logX("Collect: $it")
        }
    }
//    ================================
//    Start
//    Thread:DefaultDispatcher-worker-1, time:1666167769589
//    ================================
//    ================================
//    Filter: 1
//    Thread:DefaultDispatcher-worker-1, time:1666167769645
//    ================================
//    ================================
//    Collect: 1
//    Thread:DefaultDispatcher-worker-1, time:1666167769645
//    ================================
//    ================================
//    Emit: 1
//    Thread:DefaultDispatcher-worker-1, time:1666167769645
//    ================================
}

launchIn

flow 提供了 launchIn 函数指定在哪个线程执行。launchIn 运行在指定的 CoroutineScope。

flowOn 之前的运行在 Dispatchers.IO，下游运行在 launchIn 指定的 scope。

fun flowLaunchIn() = runBlocking {
    val flow = flow {
        logX("Start")
        emit(1)
        logX("Emit: 1")
    }

    val scope = CoroutineScope(mySingleDispatcher)

    flow.flowOn(Dispatchers.IO)
        .filter {
            logX("Filter: $it")
            it > 0
        }.onEach {
            logX("Collect: $it")
        }.launchIn(scope)

    delay(100L)

//    ================================
//    Start
//    Thread:DefaultDispatcher-worker-1, time:1666168824669
//    ================================
//    ================================
//    Emit: 1
//    Thread:DefaultDispatcher-worker-1, time:1666168824704
//    ================================
//    ================================
//    Filter: 1
//    Thread:mySingleThread, time:1666168824706
//    ================================
//    ================================
//    Collect: 1
//    Thread:mySingleThread, time:1666168824706
//    ================================

}

launchIn 调用了 scope 的 launch，然后执行 collect。相当于终止操作符。

public fun <T> Flow<T>.launchIn(scope: CoroutineScope): Job = scope.launch {
    collect() // tail-call
}

flow 是冷的

flow 是冷的，只有接收者存在的情况下才会发送数据。如果不调用 collect，emit 不会执行。相反 channel 是热的，不管有没有接收者都会发送。

flow 的 emit 未执行。

fun flowCold() = runBlocking {
    val flow = flow {
        (1..3).forEach {
            println("Before send $it")
            emit(it)
            println("Send $it")
        }
    }

    val channel = produce<Int>(capacity = 0) {
        (1..3).forEach {
            println("Before send $it")
            send(it)
            println("Send $it")
        }
    }

    println("end")
//    end
//    Before send 1

}

总结

flow 是 kotlin 提供的解决复杂异步场景的方案。

  1. flow 由创建、中间操作符、终止操作符三个部分组成。
  2. flow 的生命周期可以分为 onStart 和 onComplete，与它们在 flow 的位置无关。
  3. flow 的异常处理使用 catch。catch 与位置相关。
  4. flow 的线程切换使用 flowOn 和 launchIn。flowOn 控制上游，launchIn 控制全局。
  5. flow 是冷的，只有存在接收者它才会开始执行。
okclouderx
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
KLuban:Lifecycle + Kotlin 协程 + flow + LiveData + Glide 识别和内存优化 + Luban采样算法 = KLuban图片压缩
04-30
本项目是基于Luban算法，重构后实现的图片压缩框架 KLuban 使用Kotlin + 协程 + Flow(并行任务) + LiveData(监听回调) + Glide图片识别和内存优化 + 邻近(鲁班)、双线性采样图片算法压缩框架，欢迎改进 fork 和 star 集成和使用 Step 1.Add it in your root build.gradle at the end of repositories: allprojects { repositories { ... maven { url 'https://jitpack.io' } } } Step 2.Add the dependency dependencies { implementation 'com.github.forJrking:KLuban:1.0.7' } Step 3.Ap
Kotlin 协程三 —— 数据流 Flow
金戈鐡馬
03-13 1113
Kotlin 协程中使用挂起函数可以实现非阻塞地执行任务并将结果返回回来，但是只能返回单个计算结果。但是如果希望有多个计算结果返回回来，则可以使用 Flow。Flow 可以非阻塞地执行多个任务，并返回多个结果, 在 Flow 中可以调用其它挂起函数。取出 Flow 中的值，则需要调用 collect 方法
Kotlin协程：Flow 异步流
七夜聖君的博客
01-06 1414
Kotlin协程异步流 Flow
Kotlin协程：Flow基础原理
LeeDuoZuiShuai的博客
08-30 949
AbstractFlow类是一个抽象类，实现了Flow接口和CancellableFlow接口。// 核心方法 @InternalCoroutinesApi public final override suspend fun collect(collector : FlowCollector < T >) {
【Kotlin学习】协程的基本概念(3)——Flow
PanicLin的博客
04-16 1535
学习于《Kotlin进阶实战》，本文讲解了Kotlin中Flow的基本知识，介绍了Flow的基本使用方法
Kotlin 协程与 Flow
WriteBug001的博客
08-02 835
简介Kotlin的Flow是Kotlin在异步编程方面的一个重要组件，它提供了一种声明式的、可组合的、基于协程的异步编程模型。Flow 的设计灵感来自于RxJavaFlux和其他异步编程库，但它与Kotlin协程无缝集成，并提供了一种更具Kotlin特性的 API。Flow是用于异步数据流的概念，它可以看作是一系列异步的、可并发的值或事件的流。可以通过操作符链更改、过滤、转换这些流，并且可以对这些流进行组合、合并、扁平化等操作。
Kotlin 中的协程 flow
u010498248的博客
09-14 575
Flow 具有异步挂起响应式编程，可以使用挂起函数来异步生产和消费事件，Flow 的设计灵感也来源于响应式流以及其各种实现。
协程三部曲之③：Flow 的使用！
承香墨影的博客
07-02 2330
Hi，大家好，这里是承香墨影！今天继续给大家分享来自作者「九心」 Kotlin 的协程系列的第三篇。Google 一直在推 Kotlin，在 Android Jetpack 中也是使用 K...
一文快速实战Kotlin协程与Flow
最新发布
Androiddddd的博客
11-10 151
不知道大家有没有跟我一样的感受：即使自己用心在网上学过协程和Flow了，但过了一段时间就又忘掉了。这大部分的原因其实是因为我们缺少实战。我平时工作里根本就接触不到协程和Flow，自己又不敢硬往上写，万一出问题了咋整？所以一直就处于理论学习阶段，导致我学了就跟没学一样。
mvvmcoroutinesandflow:该应用程序演示了如何将Kotlin协程和Flow与Android的MVVM架构一起使用
04-15
阅读有关此项目的更多信息描述该项目演示了Kotlin协程和Flow在Android应用程序的MVVM架构中的用法。使用的图书馆-用于将长时间运行的任务卸载到后台-与协程很好地配合使用，为我们提供了冷流，可以使用众所周知的...
一个封装协程和flow的demo
03-04
实现kotlin+协程和flow的封装,
Baking-App-Kotlin:具有动态功能模块化的Android体系结构示例，具有MVI（单向数据流）的干净体系结构，匕首，DFM导航，具有StateFlow和Exo播放器的kotlin协程
04-13
这是Udacity Android Nanodegree程序对Baking App项目的重写特征Kotlin协同流程（状态流程） 带有MVI的干净架构（单向数据流） 用于DFM的Jetpack导航动态功能模块使用Exoplayer进行视频流匕首击剑Kotlin Gradle DSL...
uniflow-kt：Uniflow:unicorn:-适用于Android和Kotlin的简单Unidirectionnel数据流，使用Kotlin协程并向函数式编程开放
02-03
uniflow-kt：Uniflow:unicorn:-适用于Android和Kotlin的简单Unidirectionnel数据流，使用Kotlin协程并向函数式编程开放
Kotlin协程Flow使用
duncan891101的专栏
12-01 3153
一、冷流Flow 1、基本概念 Flow 能够返回多个异步计算的值 Flow 就是 Kotlin 协程与响应式编程模型结合的产物，与Rxjava非常像，Flow 提供了很多丰富的操作符，例如 map、fliter、count 等等，相比 Rxjava ，Flow 的使用和线程切换更为简单 冷数据流Flow与热数据流Channel更好相反，Flow是不消费则不生产 2、创建 // 方式一 flow<String> { emit("Hello") delay(5000)
Kotlin - 协程 - Flow
a18615971648的博客
11-18 2318
在Kotlin普及之前，RxJava无疑是Android开发领域中最受欢迎的响应式编程的三方库，而RxJava在我们日常的Android开发应用的最多的场景就是配合Retrofit进行网络请求和类似EventBus的事件订阅（RxBus）。但是到了2017年，随着LiveData刚一面世，就受到了很大的关注，LiveData是一个以观察者模式为核心，让界面对变量进行订阅，从而实现自动通知刷新的组件。跟一般的订阅比起来，LiveData有两大特点：一是他的目标非常直接，直指界面刷新，所以它的数据更新只发生在主
Kotlin协程之flow工作原理
bugmiao的博客
05-25 2372
概述 最近想学习一下 Kotlin 中 flow 的用法, Google 上搜了搜发现很多比较 RxJava 和 flow 的文章，其实我在实际业务中从来没有用过 RxJava, 倒不是因为它不好，而是…我一直傻傻不太会用 RxJava 的操作符，看不太懂，又一直没花时间(懒惰)去研究它那些操作符的原理，就一直不怎么敢用。这次看到了 flow, 想着还是先去了解了解它内部几个操作符的原理吧，不然用起来总是不太踏实。 需要注意的是 Flow 需要在协程中使用, 因此配合协程，可以方便地切线程。分析 flow
深潜Kotlin协程（二十一）：Flow 生命周期函数
RikkaTheWorld
07-04 829
系列电子书：传送门Flow 可以想象成一个管道，请求的值在一个方向上流动，而相应产生的值在另一个方向上流动。当 flow 完成或出现异常时，这些信息也会被传递，并关闭途中的中间步骤。因此，当这些值开始流动时，我们可以监听值、异常或其它特征事件（如开始或完成）。为此，我们使用了 、 、、 和 等方法。下面让我逐一解释这些生命周期方法。为了响应每个流动的值，我们使用 函数。 的 lambda 表达式是挂起的，元素依次按顺序（顺序）被处理。因此，如果我们在 添加 函数，我们将延迟每个值的流动。 onSt
Kotlin协程（5）Flow
十一月Siy
09-22 8202
0，引子 看下面的例子： fun fooAsync(p: Params): CompletableFuture<Value> = CompletableFuture.supplyAsync { bar(p) } 可以使用Future来获取需要长时间运行的异步返回的值。 当调用fooAsync(p)时，它会承诺将来会提供一个值，并且后台会运行一个操作栏来计算该值。现...
kotlin StateFlow
08-24
Kotlin StateFlow是Kotlin协程库中的一种流（Flow）实现，用于在异步场景下处理状态的变化。StateFlow可用于代替LiveData或RxJava的Observable，提供了一种简洁且类型安全的方式来观察和响应状态的变化。 StateFlow...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值