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

本文首发于公众号“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，需要调用其await()方法获取结果
• runBlocking一般用在测试中，会阻塞当前线程，会等到包裹的子协程都执行完毕才退出
• 事实上await()也不一定导致协程会被挂起，await() 只有在 async 未执行完成返回结果时，才会挂起协程。若 async 已经有结果了，await() 则直接获取其结果并赋值给变量，此时不会挂起协程

构建器	是否立即启动？	串行？并行？	是否阻塞当前线程？	返回结果
launch	是	根据包裹的子协程类型而定	否	Job对象
async	是	任务之间是并行	否	Deferred，可以用await()方法获取结果
runBlocking	是	根据包裹的子协程类型而定	阻塞	子协程都执行完毕后才退出
withContext	不是	任务之间是串行	否	可以直接返回耗时任务结果，协程体最后一行内容

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()

@Test
fun `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"
    }
    
}

组合并发

@Test
fun `test async`() = runBlocking {
    val time = measureTimeMillis {
        val one = doOne()
        val two = doTwo()
        //输出是30
        println("result: ${one + two}")
    }
    //输出是2秒多，也就是是串行的
    println(time)
}

//并发
@Test
fun `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等函数时才会开始调度，如果调度前就被取消，那么该协程将直接进入异常结束状态

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

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

@Test
fun `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中释放资源

@Test
fun `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)

@Test
fun `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()方法可以开启超时任务，默认超时会抛出异常

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

}

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

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

    println("result: $result")
}

---

欢迎关注我的公众号，和我一起每天进步一点点！