Android 面试题之 Kotlin 协程一文搞定

作者：AntDream

2024-06-17
浙江
本文字数：4171 字
阅读完需：约 14 分钟

本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点

定义

协程基于线程，是轻量级的线程

作用

处理耗时任务，这种任务常常会阻塞主线程
保证主线程安全，即确保安全地从主线程调用任何 suspend 函数

特点

让异步逻辑同步化
最核心的点就是，函数或者一段程序能够被挂起，稍后再在挂起得位置恢复

挂起函数

使用 suspend 关键字修饰的函数
挂起函数只能在协程体内或其他挂起函数内调用

挂起和阻塞的区别

挂起不会阻塞主线程，主线程可以正常刷新 UI，但阻塞就会导致主线程 ANR

协程调度器

Dispatchers.Main：主线程上处理 UI 交互相关，更新 LiveData
Dispatchers.IO：非主线程，磁盘读写和网络 IO
Dispatchers.Default：非主线程，CPU 密集型任务，排序，JSON 数据解析等

任务泄漏

当某个协程任务丢失，无法追踪，会导致内存、CPU、磁盘等资源浪费，甚至发送一个无用的网络请求，这种称为任务泄漏
为了避免，引入了结构化并发机制

结构化并发

可以取消任务、追踪任务、协程失败时发出错误信号

协程作用域 CoroutineScope

可以追踪所有协程，也可以取消协程
GlobalScope:生命周期是 Process 级别，即使 Activity 或 Fragment 已经被销毁，协程仍然运行
MainScope：在 activity 中使用，可以在 onDestroy 中取消协程
ViewModelScope：只能在 ViewModel 中使用，绑定 ViewModel 生命周期
lifecycleScope：只能在 Activity、Fragment 中使用，会绑定 Activity、Fragment 的生命周期

协程构建器

launch 和 async 构建器都用来启动新协程

launch，返回一个 Job 并且不附带任何结果
async，返回一个 Deferred，Deferred 也是一个 Job，可以使用.await()在一个延期的值上得到最终的结果
launch 是非阻塞的而 runBlocking 是阻塞的。多个 withContext 任务是串行的，且 withContext 可直接返回耗时任务的结果。多个 async 任务是并行的，async 返回的是一个 Deferred<T>，需要调用其 await()方法获取结果
runBlocking 一般用在测试中，会阻塞当前线程，会等到包裹的子协程都执行完毕才退出
事实上 await()也不一定导致协程会被挂起，await() 只有在 async 未执行完成返回结果时，才会挂起协程。若 async 已经有结果了，await() 则直接获取其结果并赋值给变量，此时不会挂起协程

doAsync 和 async

doAsync 的源码它的实现都是基于 Java 的 Future 类进行异步处理和通过 Handler 进行线程切换，从而封装的一个扩展函数方便线程切换。
与 async 关系不大，因为 doAsync 并没有用到协程库中的东西
可以通过 uiThread { } 来切换会主线程

btn.setOnClickListener {    doAsync {        Log.e("TAG", " doAsync...   [当前线程为：${Thread.currentThread().name}]")        uiThread {            Log.e("TAG", " uiThread....   [当前线程为：${Thread.currentThread().name}]")        }    }}

复制代码

Job 对象的生命周期

每一个通过 launch 或者 async 创建的协程，都会返回一个 Job 实例，该实例时协程的唯一标识，负责管理协程的生命周期
一个任务包含一系列状态：新创建（New）、活跃（Active）、完成中（Completing）、已完成（Completed）、取消中（Canceling）和已取消（Cancelled）。我们无法直接访问这些状态，可以通过访问 Job 的属性：isActive、isCancelled 和 isCompleted
如果协程处于活跃状态，协程运行出错或是调用 job.cancel()，都会将当前任务置为取消中（Cancelling）状态（isActive=false，isCancelled=true）。当所有子协程都完成后，协程会进入已取消（Cancelled）状态，此时 isCompleted=true
协程完成，可能是正常完成，也可能是被取消了

等待一个作业

由 launch 启动的协程用 join()方法；用 async 启动的协程用 await()

@Testfun `test coroutine join`() = runBlocking {    val job1 = launch {        delay(200)        println("job1 finished")    }    //这样可以确保job1执行完再执行后面的job2和job3    job1.join()    val job2 = launch {        delay(200)        println("job2 finished")        //返回结果        "job2 result"    }        val job3 = launch {        delay(200)        println("job3 finished")        //返回结果        "job2 result"    }    }

复制代码

组合并发

@Testfun `test async`() = runBlocking {    val time = measureTimeMillis {        val one = doOne()        val two = doTwo()        //输出是30        println("result: ${one + two}")    }    //输出是2秒多，也就是是串行的    println(time)}
//并发@Testfun `test combine async`() = runBlocking {    val time = measureTimeMillis {        val one = async { doOne() }        val two = async { doTwo() }        //输出是30        println("result: ${one.await() + two.await()}")    }    //输出是1秒多，也就是是并行的    println(time)}
private suspend fun doOne(): Int{    delay(1000)    return 10}private suspend fun doTwo(): Int{    delay(1000)    return 20}

复制代码

注意 async 的写法不能是：

val one = async { doOne() }.await()val two = async { doTwo() }.await()

复制代码

这样起不到并发效果，而是等到 one 执行完，再执行 two

协程的启动模式

DEFAULT：协程创建后，立即开始调度，在调度前如果协程被取消，其将直接进去取消响应状态
ATOMIC：协程创建后，立即开始调度，协程执行到第一个挂起点之前不响应取消

需要注意的是，立即调度不等于立即执行

LAZY：只有协程被需要时，包括主动调用协程的 start、join 或者 await 等函数时才会开始调度，如果调度前就被取消，那么该协程将直接进入异常结束状态

@Testfun `test start mode`() = runBlocking {    val job = async(start = CoroutineStart.LAZY) {        //    }    //...其他代码    //启动协程    job.await()}

复制代码

UNDISPATCHED：协程创建后立即在当前函数调用栈中执行，直到遇到第一个真正的挂起点

@Testfun `test start mode`() = runBlocking {    val job = async(context = Dispatchers.IO, start = CoroutineStart.UNDISPATCHED) {        println("thread:"+ Thread.currentThread().name)    }}//上面输出的线程名字是主线程，因为UNDISPATCHED会立即在当前线程中执行，而runBlocking是在主线程中

复制代码

协程作用域构建器 coroutineScope、runBlocking、supervisorScope

runBlocking 是常规函数，会阻塞当前线程；coroutineScope 是挂起函数，不会阻塞当前线程
它们都会等待协程体以及所有子协程结束，一个是阻塞线程等待，一个是挂起等待

协程作用域构建器 coroutineScope、supervisorScope

coroutineScope，一个协程失败了，所有其他兄弟协程也会被取消
supervisorScope，一个子协程失败了，不会影响其他兄弟协程，但如果是作用域有异常失败了，则所有的子协程都会失败退出

coroutineScope 和 CoroutineScope

coroutineScope 是一个挂起函数，是协程作用域构建器，CoroutineScope()是一个普通函数
coroutineScope 后面的协程作用域的协程上下文是继承父协程作用域的上下文
CoroutineScope()有自己的作用域上下文
都能够进行解构化并发，可以很好的管理多个子协程

协程的取消

取消作用域会取消它的子协程
被取消的子协程不会影响其余兄弟协程
协程通过抛出一个特殊的异常 CancellationException 来处理取消操作
所有 kotlinx.coroutines 中的挂起函数（withContext、delay 等）都是可取消的
CPU 密集型任务无法直接用 cancel 来取消

CPU 密集型任务的取消

通过 isActive 来判断取消，因为取消的任务 isActive 为 false
通过 ensureActive()来取消，如果被取消，任务 isActive 为 false，会抛一个异常
yield 函数会检查所在协程的状态，如果已经取消，则抛出 CancellationException 予以响应。此外，它还会尝试出让线程的执行权，给其他协程提供执行的机会

协程取消的副作用

在 finally 中释放资源

@Testfun `test release resources`() = runBlocking {    var br = BufferedReader(FileReader("xxx"))    with(br){        var line:String?        try {            while (true){                line = readLine() ?: break                println(line)            }        }finally {            //关闭资源            close()        }    }}

复制代码

用 use 函数：该函数只能被实现了 Closeable 的对象使用，程序结束的时候会自动调用 close 方法，适合文件对象

//use函数在文件使用完毕后会自动调用close函数BufferedReader(FileReader("xxx")).use {    var line:String?    while (true){        line = readLine() ?: break        println(line)    }}

复制代码

不能取消的任务

协程被取消后，finally 里面还有挂起函数，可以用 withContext(NonCancellable)

@Testfun `test cancel with noncancellable`() = runBlocking {    val job = launch {        try {            repeat(1000){                println("job: i'm sleeping $it")                delay(500L)            }        }finally {            //不用withContext(NonCancellable)，delay后面的打印不会执行            withContext(NonCancellable){                println("running finally")                delay(1000L)                println("job: noncancellable")            }        }    }    delay(1300)    println("main: waiting")    job.cancelAndJoin()    println("main: i can quit")}

复制代码

超时任务

withTimeout()方法可以开启超时任务，默认超时会抛出异常

/** 超时任务* */@Testfun `test deal with timeout`() = runBlocking {    withTimeout(1300){        repeat(1000){            println("job: sleeping $it")            delay(500L)        }    }
}

复制代码

如果不想抛出异常，可以用 withTimeoutOrNull

 /** 超时任务，超时会返回null，不超时返回最后的done* */@Testfun `test deal with timeout ornull`() = runBlocking {    val result = withTimeoutOrNull(1300){        repeat(1000){            println("job: sleeping $it")            delay(500L)        }        "done"    }
    println("result: $result")}

复制代码

欢迎关注我的微信公众号AntDream，和我一起学习一起成长！

发布于: 刚刚阅读数: 4

原文链接:【http://xie.infoq.cn/article/fff76e9e6783ba6af8605b955】。文章转载请联系作者。

AntDream

关注

AntDream，欢迎一起交流学习 2024-06-07 加入

专注移动端，偶尔搞点别的，哈哈

发布

暂无评论

创作场景

Android 面试题之 Kotlin 协程一文搞定

定义

作用

特点

挂起函数

挂起和阻塞的区别

协程调度器

任务泄漏

结构化并发

协程作用域 CoroutineScope

协程构建器

Job 对象的生命周期

等待一个作业

组合并发

协程的启动模式

协程作用域构建器 coroutineScope、runBlocking、supervisorScope

协程作用域构建器 coroutineScope、supervisorScope

coroutineScope 和 CoroutineScope

协程的取消

CPU 密集型任务的取消

协程取消的副作用

不能取消的任务

超时任务

AntDream

评论