Kotlin Coroutines 模式与反模式

文章目录

简介
处理异常时，用coroutineScope或者使用SupervisorJob包装异步调用
主协程最好选择Main调度器
避免使用多余的async/await
避免取消域的job
避免编写用隐式调度器的挂起函数
避免使用全局域

简介

决定写一些东西，在我看来当你使用Kotlin coroutines时，这些东西你应该做和不应该做(或者说，至少试着避免做)。

处理异常时，用coroutineScope或者使用SupervisorJob包装异步调用

❌如果异步代码块可能抛出异常，不要依赖于用try/catch代码块包装

val job: Job = Job()
val scope = CoroutineScope(Dispatchers.Default + job)
// 可能抛出异常
fun doWork(): Deferred<String> = scope.async { ... }   // (1)
fun loadData() = scope.launch {
    try {
        doWork().await()                               // (2)
    } catch (e: Exception) { ... }
}

在上面例子中，doWork函数开启了新的协程(1)，这个协程可能抛出一个未处理的异常。如果你试着用try/catch块包装doWork(2)，它照样会崩溃。

这是因为，任意job的子job的失败，会直接导致它的父job的失败

✅避免崩溃的一种方式是使用SupervisorJob(1)

子job的失败或者取消，不会导致Supervisor job的失败，也不会影响其他子job

val job = SupervisorJob()                               // (1)
val scope = CoroutineScope(Dispatchers.Default + job)
// 可能抛出异常
fun doWork(): Deferred<String> = scope.async { ... }
fun loadData() = scope.launch {
    try {
        doWork().await()
    } catch (e: Exception) { ... }
}

注意：只有显式地用SupervisorJob在协程域上运行async，才能行得通。所以，下面的代码仍然会使得应用崩溃，因为async实在父协程的域上启动的(1)。

val job = SupervisorJob()                               
val scope = CoroutineScope(Dispatchers.Default + job)
fun loadData() = scope.launch {
    try {
        async {                                         // (1)
            // 可能抛出异常
        }.await()
    } catch (e: Exception) { ... }
}

✅ 避免崩溃的另外一种方法，也是更可取的方式，是通过用coroutineScope包裹async(1)。现在，当异常发生在async内部时，它将会取消这个域内创建的所有其他协程，而没有影响外面的域(2)。

val job = SupervisorJob()                               
val scope = CoroutineScope(Dispatchers.Default + job)
//可能抛出异常
fun doWork(): Deferred<String> = coroutineScope {     // (1)
    async { ... }
}
fun loadData() = scope.launch {                       // (2)
    try {
        doWork().await()
    } catch (e: Exception) { ... }
}

或者，你可以在async块内部处理异常。

主协程最好选择Main调度器

❌ 如果你需要做后台的工作而后在主协程中更新UI，不要在非Main调度器中启动它。

val scope = CoroutineScope(Dispatchers.Default)          // (1)
fun login() = scope.launch {
    withContext(Dispatcher.Main) { view.showLoading() }  // (2)  
    networkClient.login(...)
    withContext(Dispatcher.Main) { view.hideLoading() }  // (2)
}

在上面的例子红，我们使用Default调度器的域启动了主协程(1)。使用这个方式，当每次我们接触用户界面，我们不得不切换上下文(2)。

✅ 大多数情况下，使用Main调度器创建域是更可取的，这会使得代码更加简洁和更少的上下文显式切换。

val scope = CoroutineScope(Dispatchers.Main)
fun login() = scope.launch {
    view.showLoading()    
    withContext(Dispatcher.IO) { networkClient.login(...) }
    view.hideLoading()
}

避免使用多余的async/await

❌如果你使用async函数，然后随着直接使用await，那么你应该避免这么做。

launch {
    val data = async(Dispatchers.Default) { /* 代码 */ }.await()
}

✅ 如果你想要切换协程上下文，而且挂起父协程，那么withContext是更好的选择。

launch {
    val data = withContext(Dispatchers.Default) { /* code */ }
}

性能虽然不是一个太大的关注点(虽然async创建了新协程来做这些工作)，但是语义上async暗示着，你想要在后台开启多个协程，然后在它们上await。

避免取消域的job

❌ 如果你需要取消协程，首先不要取消域的job。

class WorkManager {
    val job = SupervisorJob()
    val scope = CoroutineScope(Dispatchers.Default + job)
    fun doWork1() {
        scope.launch { /* 做一些事情 */ }
    }
    fun doWork2() {
        scope.launch { /* 做一些事情 */ }
    }
    fun cancelAllWork() {
        job.cancel()
    }
}
fun main() {
    val workManager = WorkManager()
    workManager.doWork1()
    workManager.doWork2()
    workManager.cancelAllWork()
    workManager.doWork1() // (1)
}

上面代码的问题在于，当我们取消job时，我们把它放入到completed的状态。在completed的job的域中启动的协程，不会被执行(1)。

✅ 当我们想要取消特定域中所有的协程，我们可以使用cancelChildren函数。提供取消单个job的可能，也是一个良好实践(2)。

class WorkManager {
    val job = SupervisorJob()
    val scope = CoroutineScope(Dispatchers.Default + job)
    fun doWork1(): Job = scope.launch { /* 做一些事情 */ } // (2)
    fun doWork2(): Job = scope.launch { /* 做一些事情 */ } // (2)
    fun cancelAllWork() {
        scope.coroutineContext.cancelChildren()         // (1)                             
    }
}
fun main() {
    val workManager = WorkManager()
    workManager.doWork1()
    workManager.doWork2()
    workManager.cancelAllWork()
    workManager.doWork1()
}

避免编写用隐式调度器的挂起函数

❌ 不要编写这样的挂起函数，它依赖于来自特定协程调度器的执行。

suspend fun login(): Result {
    view.showLoading()
    val result = withContext(Dispatcher.IO) {  
        someBlockingCall() 
    }
    view.hideLoading()
    return result
}

上面例子中，login函数是个挂起函数，当你在使用了非Main调度器的协程执行它的时候，这个函数会崩溃。

launch(Dispatcher.Main) {     // (1) 不崩溃
    val loginResult = login()
    ...
}
launch(Dispatcher.Default) {  // (2) 造成崩溃
    val loginResult = login()
    ...
}

CalledFromWrongThreadException: 在创建了视图层级的原来线程，才能接触它的视图

✅ 要以这样一种方式设计你的挂起函数：它可以在任何协程调度器中执行。

suspend fun login(): Result = withContext(Dispatcher.Main) {
    view.showLoading()
    val result = withContext(Dispatcher.IO) {  
        someBlockingCall() 
    }
    view.hideLoading()
	return result
}

现在，你可以在任何调度器中调用login函数。

launch(Dispatcher.Main) {     // (1) 不会崩溃
    val loginResult = login()
    ...
}
launch(Dispatcher.Default) {  // (2) 也不会崩溃
    val loginResult = login()
    ...
}

避免使用全局域

❌ 如果你在你的Android应用中到处使用GlobalScope，你需要停止这么做了。

GlobalScope.launch {
    // 代码
}

全局域使用在最顶层协程中，它在整个应用的生命周期中运行，而且不能够永久地取消。
应用代码通常使用定义应用的CoroutineScope，在GlobalScope的实例上使用async或者launch ，是非常不建议的。

✅Android中的协程，可以很容易使用到Activity、Fragment、View或者ViewModel的生命周期中。

class MainActivity : AppCompatActivity(), CoroutineScope {

    private val job = SupervisorJob()
    
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job
        
    override fun onDestroy() {
        super.onDestroy()
        coroutineContext.cancelChildren()
    }
    
    fun loadData() = launch {
        // code
    }
}

特别感谢：Andrey Mischenko, Louis CA, DBradyn Poulsen, Tolriq, Dave A.