Kotlin_协程Kotlin-Coroutines

Android开发中使用协程(上手指南)

2020-11-19  本文已影响0人  大虾啊啊啊

一.保持对协程的追踪

我们知道协程可以处理耗时任务,但是假如我们的项目中开启了一千个协程处理任务,我们都是通过手动去追踪它们,那代码很容易出错。也很容易失去对协程的实时跟踪。就会引起work leak,任务泄漏,类似内存泄漏一样,任务泄漏会导致CPU,内存,磁盘资源被占用。甚至会发起一些无用的网络请求。为了避免任务的泄漏,Kotlin引入了结构化并发机制。
在Android平台使用结构化并发可以做到以下三件事:
(1)取消任务——当任务不需要继续执行的时候,取消他
(2)追踪任务——当任务正在执行的时候追踪他
(3)发出错误的信号——当协程执行失败时,发出错误信号表明有错误发生

二.借助scope 来取消任务

scope在协程中称为作用域,协程的运行必须指定作用域,CoroutineScope(作用域)可以对协程进行追踪,即使协程被挂起也是如此。CoroutineScope并不运行协程,他只是确保实时跟着协程的运行。因此在Kotlin中不允许在没有作用域的情况下启动新的协程。作用域可以跟踪所有的协程,有可以取消由它启动的协程。在Android开发中经常用到。比如在一个Activity中启动一个协程,当Activity关闭的时候,取消协程的执行。这个时候我们可以联想到让我们Activity的生命周期保持和作用域的生命周期一样。以上总结就是:作用域(CoroutineScope )会跟踪所有的协程,并可以取消由它启动的协程。

三.协程的启动方式

启动协程,必须要在作用域内,而启动协程的方式有两种:
(1)launch构建器——启动新的协程而不将结果返回给调用方
(2)async构建器——启动新的协程,通过await的挂起函数返回result
如:以下launch启动的协程,我们只是在挂起函数doSomthingOne中拿到了返回值。

package com.example.kotlin01

import kotlinx.coroutines.*
suspend fun main() {
    runBlocking {
        var job = launch {
            var result1 = doSomthingOne()
            println(result1)
        }

    }

}
suspend fun doSomthingOne(): Int {
    delay(2000)
    return 13
}

13

如:以下async启动的协程,我们通过返回调用await拿到返回值。

package com.example.kotlin01

import kotlinx.coroutines.*
suspend fun main() {
    runBlocking {
        var job = async {
           doSomthingOne()
        }
        println(job.await())

    }

}

suspend fun doSomthingOne(): Int {
    delay(2000)
    return 13
}
13

四.在 ViewModel 中启动协程

项目中经常我们通过使用jetpack中的ViewModel组件来作为View的控制器和Activity绑定起来,这样以来我们知道即使当我们的手机屏幕旋转Activity异常销毁重建的时候我们的Viewmodel也不会销毁。如果我们在ViewModel中启动协程,我们的协程也不会因此而被终止。我们知道协程都是运行在作用域中的,所以就产生了我们的ViewModel.viewModelScope。当viewModelScope被清除,调用onCleared的时候,我们的协程也就取消执行了。比如当一个接口正在请求数据的时候,此时用户关闭了应用,那么我们的请求就应该被取消掉。当一个协程中又启动了一个新的协程,那他们都公用父协程的作用域。viewModelScope的使用实例

package com.example.kotlin01

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class MyViewModel : ViewModel() {

    fun runForever() {
        // 在 ViewModel 中启动新的协程
        viewModelScope.launch {
            // 当 ViewModel 被清除后,下列代码也会被取消
            while (true){
                println("你好")
            }
        }
    }
}

我们看到我们在协程体中写了一个死循环,但是假如我们的Viewmodel被清除的时候,协程也会被取消。死循环中的代码也会取消执行。

五.任务追踪

有时候我们会遇到一些更复杂的问题,比如在一个协程中处理多个网络请求,我们可以作在一个协程中又启动多个协程去执行任务,但是如果随意启动协程,就会容易引起任务泄漏,调用方可能感知不到启动了新的协程,也就无法追踪。为了解决这个问题,结构化并发保证了supend函数返回时,处理任务也都完成。我们使用coroutineScope或者supervisorScope构造器在supend函数中启动新的协程,确保了supend函数返回的时候,他们所做的任务也都能结束。

suspend fun fetchTwoDocs() {
    coroutineScope {
        launch { fetchDoc(1) }
        async { fetchDoc(2) }
    }
}

以上suspend函数fetchTwoDocs中使用了coroutineScope构造器启动了两个协程,当fetchTwoDocs函数返回的时候,确保了launch和async启动的协程也都已经完成执行。

六.任务追踪(处理一堆任务)

在以上的例子中,假如我们在supend函数中启动了一千个协程,那么是否还能正常追踪呢,结果也是一样的。coroutineScope构造器启动的协程会等待协程中的任务执行完成,supend函数才会返回。并且coroutineScope还会创建一个子scope(作用域),我们知道supend函数肯定是由某个协程内部调用的,运行在某个作用域内,那么suspend函数中通过coroutineScope启动的协程会创建一个子作用域scope ,这个子作用域继承了suspend函数所在协程的作用域(父作用域)。假如这个父作用域是一个viewScope,当用户离开界面,关闭Activity的时候,viewScope被清除,那么所有的子作用域也会被清楚。子作用域内的协程也会被取消执行。这样就不会造成了任务泄漏。

七.协程失败时发出报错信号

val unrelatedScope = MainScope()
// 丢失错误的例子
suspend fun lostError() {
   // 未使用结构化并发的 async
    unrelatedScope.async {
        throw InAsyncNoOneCanHearYou("except")
    }
}

以上我们在supend函数中声明了一个无关联的作用域,它不会按照结构化并发的方式启动新的协程,这段代码的错误将丢失,因为异常通过去获取,而我们并没有调用await 。所以这个错误将永远不会得到处理。
使用结构化并发

suspend fun foundError() {
    coroutineScope {
        async { 
            throw StructuredConcurrencyWill("throw")
        }
    }
}

使用结构化并发就是在supend函数中使用coroutineScope构造器启动协程,coroutineScope将会创建子作用域继承了supend函数所在协程的作用域。如果coroutineScope创建的协程抛出了异常,coroutineScope将会抛给调用方,因为我们使用的是coroutineScope而不是supervisorScope,当抛出异常的时候,所有的子任务就会被取消。

八.理解结构化并发

package com.example.kotlin01

import kotlinx.coroutines.*

suspend fun main() {
    println("${doSum()}")
}

suspend fun doSum(): Int = coroutineScope {
    var result1 = async { doSomthingOne() }
    var result2 = async { doSomthingTwo() }
    result1.await() + result2.await()
}

suspend fun doSomthingOne(): Int {

    delay(2000)
    println("doSomthingOne")
    return 13
}

suspend fun doSomthingTwo(): Int {
    delay(1000)
    println("doSomthingTwo")
    return 15
}

在supend 函数中我们通过coroutineScope 构造器启动了两个协程调用doSomthingOne,doSomthingTwo,因为coroutineScope 启动的协程的作用域都继承了supend函数所在协程的作用域,当doSomthingOne函数出现异常的时候,会抛给父作用域,父作用域下协程的的子协程都会被取消。也就是doSomthingOne和doSomthingTwo都会被取消。

上一篇下一篇

猜你喜欢

热点阅读