乐趣区

关于android:即学即用Kotlin-协程

jiezi

目录

一、根底

1. 概念

置信大家或多或少的都理解过，协程是什么，官网上这么说：

Essentially, coroutines are light-weight threads.

协程是轻量级的线程，为什么是轻量的？能够先通知大家论断，因为它基于线程池 API，所以在解决并发工作这件事上它真的熟能生巧。
有可能有的同学问了，既然它基于线程池，那我间接应用线程池或者应用 Android 中其余的异步工作解决形式，比方 Handler、RxJava等，不更好吗？
协程能够应用阻塞的形式写出非阻塞式的代码，解决并发中常见的回调天堂，这是其最大的长处，前面介绍。

2. 应用

<pre data-tool="mdnice 编辑器" class="custom" >\`GlobalScope.launch(Dispatchers.Main) {val res = getResult(2)
 mNumTv.text = res.toString()}

启动协程的代码就是如此的简略。下面的代码中能够分为三局部，别离是 GlobalScope、Dispatcher 和 launch，他们别离对应着协程的作用域、调度器和协程构建器，咱们挨个儿介绍。

协程作用域

协程的作用域有三种，他们别离是：

  • runBlocking：顶层函数，它和 coroutineScope 不一样，它会阻塞以后线程来期待，所以这个办法在业务中并不实用。
  • GlobalScope：全局协程作用域，能够在整个利用的申明周期中操作，且不能取消，所以仍不适用于业务开发。
  • 自定义作用域：自定义协程的作用域，不会造成内存透露。

显然，咱们不能在 Activity 中调用 GlobalScope，这样可能会造成内存透露，看一下如何自定义作用域，具体的步骤我在正文中已给出：

<pre data-tool="mdnice 编辑器" class="custom" >\`class MainActivity : AppCompatActivity() {
 // 1\\. 创立一个 MainScope
 val scope = MainScope()
 override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)
 setContentView(R.layout.activity\_main)
 // 2\\. 启动协程
 scope.launch(Dispatchers.Unconfined) {val one = getResult(20)
 val two = getResult(40)
 mNumTv.text = (one + two).toString()}
 }
 // 3\\. 销毁的时候开释
 override fun onDestroy() {super.onDestroy()
 scope.cancel()}
 private suspend fun getResult(num: Int): Int {delay(5000)
 return num \* num
 }
} </pre>

调度器

调度器的作用是将协程限度在特定的线程执行。次要的调度器类型有：

  • Dispatchers.Main：指定执行的线程是主线程，如下面的代码。
  • Dispatchers.IO：指定执行的线程是 IO 线程。
  • Dispatchers.Default：默认的调度器，适宜执行 CPU 密集性的工作。
  • Dispatchers.Unconfined：非限度的调度器，指定的线程可能会随着 挂起 的函数的发生变化。

什么是挂起？咱们就以九心吃饭为例，如果到公司对面的广场吃饭，九心得通过：

  • 走到广场 10min > 点餐 5min > 期待上餐 10min > 就餐 30min > 回来 10 min

如果九心点广场的外卖呢？

  • 九心：下单 5min > 期待(期待的时候能够工作) 30min > 就餐 30min
  • 外卖骑手：到店 > 取餐 > 送外卖

从九心吃饭的例子能够看出，如果点了外卖，九心破费的工夫较少了，能够闲暇出更多的工夫做本人的事。再仔细分析一下，其实从公司到广场和期待取餐这个过程并没有省去，只是九心把这个过程交给了外卖员。
协程的原理跟九心点外卖的原理是统一的，耗时阻塞的操作并没有缩小，只是交给了其余线程

launch

launch 的作用从它的名称就可以看的进去，启动一个新的协程，它返回的是一个 Job对象，咱们能够调用 Job#cancel() 勾销这个协程。
除了 launch，还有一个办法跟它很像，就是 async，它的作用是创立一个协程，之后返回一个 Deferred<T>对象，咱们能够调用 Deferred#await()去获取返回的值，有点相似于 Java 中的 Future，略微改一下下面的代码：

<pre data-tool="mdnice 编辑器" class="custom" >\`class MainActivity : AppCompatActivity() {
 // 1\\. 创立一个 MainScope
 val scope = MainScope()
 override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)
 setContentView(R.layout.activity\_main)
 // 2\\. 启动协程
 scope.launch(Dispatchers.Unconfined) {val one = async { getResult(20) }
 val two = async {getResult(40) }
 mNumTv.text = (one.await() + two.await()).toString()}
 }
 // 3\\. 销毁的时候开释
 override fun onDestroy() {super.onDestroy()
 scope.cancel()}
 private suspend fun getResult(num: Int): Int {delay(5000)
 return num \* num
 }
}

与批改前的代码相比，async 可能并发执行工作，执行工作的工夫也因而缩短了一半。
除了上述的并发执行工作，async 还能够对它的 start 入参设置成懒加载

<pre data-tool="mdnice 编辑器" class="custom" >\`val one = async(start = CoroutineStart.LAZY) {getResult(20) }

这样零碎就能够在调用它的时候再为它分配资源了。

suspend

suspend 是润饰函数的关键字，意思是以后的函数是能够挂起的，然而它仅仅起着揭示的作用，比方，当咱们的函数中没有须要挂起的操作的时候，编译器回给咱们揭示 Redudant suspend modifier，意思是以后的 suspend 是没有必要的，能够把它删除。
那咱们什么时候须要应用挂起函数呢？常见的场景有：

  • 耗时操作：应用 withContext 切换到指定的 IO 线程去进行网络或者数据库申请。
  • 期待操作：应用 delay 办法 去期待某个事件。

withContext 的代码：

`<pre data-tool="mdnice 编辑器" class="custom" >\private suspend fun getResult(num: Int): Int {return withContext(Dispatchers.IO) {num \* num}
} 

delay 的代码：<pre data-tool="mdnice 编辑器" class="custom" >\private suspend fun getResult(num: Int): Int {delay(5000)
 return num \* num
} `

联合 Android Jetpack

在介绍自定义协程作用域的时候，咱们须要被动在 Activity 或者 Fragment 中的 onDestroy 办法中调用 job.cancel()，遗记解决可能是程序员常常会犯的谬误，如何防止呢？
Google 总是可能解决程序员的痛点，在 Android Jetpack 中的 lifecycle、LiveData 和 ViewModel 曾经集成了疾速应用协程的办法，如果咱们曾经引入了 Android Jetpack，能够引入依赖：

<pre data-tool="mdnice 编辑器" class="custom" > \`dependencies {
 def lifecycle\_version = "2.2.0"
 // ViewModel
 implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle\_version"
 // LiveData
 implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle\_version"
 // Lifecycles only (without ViewModel or LiveData)
 implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle\_version"
 }

应用能够联合具体的场景，比方联合 Lifecycle，须要应用 lifecycleScope 协程作用域：

<pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {// 代表以后生命周期处于 Resumed 的时候才会执行(选择性应用)
 whenResumed {// ... 具体的协程代码}
}

即便你不应用 Android Jetpack 组件，因为 Lifecycles 在很早之前就内置在 Android 零碎的代码中，所以你依然能够仅仅引入 Lifecycle 的协程扩大库，因为它会帮忙你很好的解决 Activity 或者 Fragment 的生命周期。
引入 Android Jetpack 协程扩大库官网文档：点我关上

二、流

长期以来，在 Android 中响应式编程的首选计划是 RxJava，咱们明天就来理解一下 Kotlin 中的响应式编程 Flow。如果你能纯熟应用 RxJava，那你必定能疾速上手 Flow。
LiveData 更加简略和纯正，它建设繁多的生产生产模型，Flow 才是相似于 RxJava 的存在。

1. 根底

先上一段代码：

<pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {
 // 创立一个协程 Flow<T>
 createFlow()
 .collect {num->
 // 具体的生产解决
 // ...
 }
 }
}

我在 createFlow 这个办法中，返回了 Flow<Int> 的对象，所以咱们能够这样比照。

创立 Flow 对象

咱们暂不思考 RxJava中的背压和非背压，间接先将 Flow 对标 RxJava 中的 Observable。
和 RxJava 一样，在创立 Flow 对象的时候咱们也须要调用 emit 办法发射数据：

<pre data-tool="mdnice 编辑器" class="custom" >\`fun createFlow(): Flow<Int> = flow {for (i in 1..10)
 emit(i)
}

始终调用 emit 可能不便捷，因为 RxJava 提供了 Observable.just() 这类的操作符，显然，Flow 也为咱们提供了疾速创立操作：

  • flowof(vararg elements: T)：帮忙可变数组生成 Flow 实例
  • 扩大函数 .asFlow()：面向数组、列表等汇合

比方能够应用 (1..10).asFlow() 代替上述的 Flow 对象的创立。

生产数据

collect 办法和 RxJava 中的 subscribe 办法一样，都是用来生产数据的。
除了简略的用法外，这里有两个问题得留神一下：

  • collect 函数是一个 suspend 办法，所以它必须产生在协程或者带有 suspend 的办法外面，这也是我为什么在一开始的时候启动了 lifecycleScope.launch。
  • lifecycleScope 是我应用的 Lifecycle 的协程扩大库当中的，你能够替换成自定义的协程作用域。

2. 线程切换

咱们学习 RxJava 的时候，大佬们都会说，RxJava 牛逼，牛逼在哪儿呢？
切换线程，同样的，Flow 的协程切换也很牛逼。Flow 是这么切换协程的：

pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {
 // 创立一个协程 Flow<T>
 createFlow()
 // 将数据发射的操作放到 IO 线程中的协程
 .flowOn(Dispatchers.IO)
 .collect { num ->
 // 具体的生产解决
 // ...
 }
 }
}

和 RxJava 比照：

扭转数据发射的线程

flowOn 应用的参数是协程对应的调度器，它本质扭转的是协程对应的线程。

扭转生产数据的线程

我在下面的表格中并没有写到在 Flow 中如何扭转生产线程，并不意味着 Flow 不能够指定生产线程？
Flow 的生产线程在咱们启动协程指定调度器的时候就确认好了，对应着启动协程的调度器。比方在下面的代码中 lifecycleScope 启动的调度器是 Dispatchers.Main，那么 collect 办法就生产在主线程。

3. 异样和实现

异样捕捉


Flow 中的 catch 对应着 RxJava 中的 onError，catch 操作：

<pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {
 flow {//...}.catch {e->}.collect()}

除此以外，你能够应用申明式捕捉 try {} catch (e: Throwable) {} 去捕捉异样，不过 catch 实质上是一个扩大办法，它是对申明式捕捉的封装。

实现


Flow 中的 onCompletion 对应这 RxJava 中的 onComplete 回调，onCompletion操作：

<pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {createFlow()
 .onCompletion {// 解决实现操作}
 .collect {}}

除此以外，咱们还能够通过捕捉式 try {} finally {} 去获取实现状况。

4. Flow 的特点

咱们在对 Flow 曾经有了一些根底的认知了，再来聊一聊 Flow 的特点，Flow 具备以下特点：

  • 冷流
  • 有序
  • 合作勾销

如果你对 Kotlin 中的 Sequence 有一些意识，那么你应该能够轻松的 Get 到前两个点。

冷流

有点相似于懒加载，当咱们触发 collect 办法的时候，数据才开始发射。

<pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {val flow = (1..10).asFlow().flowOn(Dispatchers.Main)
 flow.collect { num ->
 // 具体的生产解决
 // ...
 }
 }
}

也就是说，在第 2 行的时候，尽管流创立好了，然而数据始终到第四行产生 collect 才开始发射。

有序

看代码比拟容易了解：

<pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {
 flow {for(i in 1..3) {Log.e("Flow","$i emit")
 emit(i)
 }
 }.filter {Log.e("Flow","$it filter")
 it % 2 != 0
 }.map {Log.e("Flow","$it map")
 "${it \* it} money"
 }.collect {Log.e("Flow","i get $it")
 }
}

失去的日志：

<pre data-tool="mdnice 编辑器" class="custom" >\`E/Flow: 1 emit
E/Flow: 1 filter
E/Flow: 1 map
E/Flow: i get 1 money
E/Flow: 2 emit
E/Flow: 2 filter
E/Flow: 3 emit
E/Flow: 3 filter
E/Flow: 3 map
E/Flow: i get 9 money

从日志中，咱们很容易得出这样的论断，每个数据都是通过 emit、filter、map和 collect 这一套残缺的解决流程后，下个数据才会开始解决，而不是所有的数据都先对立 emit，完了再对立 filter，接着 map，最初再 collect。

合作勾销

Flow 采纳和协程一样的合作勾销，也就是说，Flow 的 collect 只能在可勾销的挂起函数中挂起的时候勾销，否则不能取消。
如果咱们想勾销 Flow 得借助 withTimeoutOrNull 之类的顶层函数，无妨猜一下，上面的代码最终会打印出什么？

<pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {
 val f = flow {for (i in 1..3) {delay(500)
 Log.e(TAG, "emit $i")
 emit(i)
 }
 }
 withTimeoutOrNull(1600) {
 f.collect {delay(500)
 Log.e(TAG, "consume $it")
 }
 }
 Log.e(TAG, "cancel")
}

5. 操作符比照

限于篇幅，我仅介绍一下 Flow 中操作符的作用，就不一一介绍每个操作符具体怎么应用了。

一般操作符：

非凡的操作符

总会有一些非凡的状况，比方我只须要取前几个，我只有最新的数据等，不过在这些状况下，数据的发射就是并发执行的。

组合操作符

展平流操作符

展平流有点相似于 RxJava 中的 flatmap，将你发射进来的数据源转变为另一种数据源。

末端操作符

顾名思义，就是帮你做 collect 解决，collect 是最根底的末端操作符。

其余还有一些操作符，我这里就不一一介绍了，感兴趣能够查看 API。

三、通道

Channel是一个面向多协程之间数据传输的 BlockQueue。它的应用形式超级简略：

<pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {
 // 1\\. 生成一个 Channel
 val channel = Channel<Int>()
 // 2\\. Channel 发送数据
 launch {for(i in 1..5){delay(200)
 channel.send(i \* i)
 }
 channel.close()}
 // 3\\. Channel 接收数据
 launch {for( y in channel)
 Log.e(TAG, "get $y")
 }
}

实现协程之间的数据传输须要三步：

1. 创立 Channel

创立的 Channel的形式能够分为两种：

  • 间接创建对象：形式跟上述代码统一。
  • 扩大函数 produce

如果应用了扩大函数，代码就变成了：

<pre data-tool="mdnice 编辑器" class="custom" >\`lifecycleScope.launch {
 // 1\\. 生成一个 Channel
 val channel = produce<Int> {for(i in 1..5){delay(200)
 send(i \* i)
 }
 close()}
 // 2\\. 接收数据
 // ... 省略 跟之前代码统一
}

间接将第一步和第二步合并了。

2. 发送数据

发送数据应用的 Channel#send() 办法，当咱们数据发送结束的时候，能够应用 Channel#close() 来表明通道曾经完结数据的发送。

3. 接收数据

失常状况下，咱们仅须要调用 Channel#receive() 获取数据，然而该办法只能获取一次传递的数据，如果咱们仅需获取指定次数的数据，能够这么操作：

<pre data-tool="mdnice 编辑器" class="custom" >\`repeat(4){Log.e(TAG, "get ${channel.receive()}")
}

但如果发送的数据不能够预估呢？这个时候咱们就须要迭代 Channel 了

<pre data-tool="mdnice 编辑器" class="custom" >\`for(y in channel)
 Log.e(TAG, "get $y")

四、多协程数据处理

多协程解决并发数据的时候，原子性同样也得不到保障，协程中出了一种叫 Mutex 的锁，区别是它的 lock 操作是挂起的，非阻塞的，感兴趣的同学能够自行查看。
https://shimo.im/docs/TG8PDh9…

退出移动版