Kotlin 协程之模式与反模式

目录

• 介绍
• 使用 coroutineScope 包装异步调用或使用 SupervisorJob 以处理异常
• 根协程首选 Main dispatcher
• 避免使用不必要的 async/await
• 避免取消 Scope Job
• 避免使用隐式 Dispatcher 编写 suspend 函数
• 避免使用 GlobalScope

介绍

文中介绍了一些使用 Kotlin 协程时应该和不应该做（或至少试图避免）的事情。

使用 coroutineScope 包装异步调用或使用 SupervisorJob 以处理异常

❌如果异步代码块可能抛出异常，不要依赖 try/catch 语句来捕获它。

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

在上面示例中，doWork 函数启动的新协程(1)，可能会抛出未处理的异常。如果你尝试使用 try/catch 块(2)来包裹 doWork，它仍然会导致崩溃。
发生这种情况是因为任何 Job 的子协程失败都会导致其父 Scope 立即失败。

✅避免这种 Crash 的方式之一是使用 SupervisorJob (1)。
子协程失败或取消不会导致 supervisor job 失败，也不会影响它的其他子协程。

val job = SupervisorJob()                               // (1)
val scope = CoroutineScope(Dispatchers.Default + job)

// may throw Exception
fun doWork(): Deferred<String> = scope.async { ... }

fun loadData() = scope.launch {
    try {
        doWork().await()
    } catch (e: Exception) { ... }
}

注意：只有在使用 SupervisorJob 的协程 scope 上显式运行 async 时这才有效。所以下面的代码仍然会导致程序崩溃，因为 async 是在父协程 scope 内启动的 (1)：

val job = SupervisorJob()                               
val scope = CoroutineScope(Dispatchers.Default + job)

fun loadData() = scope.launch {
    try {
        async {                                         // (1)
            // may throw Exception 
        }.await()
    } catch (e: Exception) { ... }
}

✅另一种避免这种 Crash 的方式，是使用coroutineScope包装async。这样一来当async发生异常时，它将取消在同一 scope 里的所有其它协程，而不会影响外部 scope (2)：

val job = SupervisorJob()                               
val scope = CoroutineScope(Dispatchers.Default + job)

// may throw Exception
suspend fun doWork(): String = coroutineScope {     // (1)
    async { ... }.await()
}

fun loadData() = scope.launch {                       // (2)
    try {
        doWork()
    } catch (e: Exception) { ... }
}

另外，还可以在async块内部处理异常。

根协程首选 Main dispatcher

❌如果你需要在根协程中执行后台工作并更新 UI，请不要使用非 Main Dispatcher 启动它：

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 dispatcher 创建的 scope 启动根协程(1)，这种情况下，每当涉及 UI 操作时都必须切换上下文 (2)。

✅大多数情况下，最好使用 Main dispatcher 创建 scope，这可以让代码更简单，上下文切换更少：

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) { /* code */ }.await()
}

✅如果你想切换协程上下文并立即挂起父协程，withContext 是一种更好的方法。

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

性能方面并不是一个大问题（即使 async 会创建新的协程来完成工作），但从语义上来说，async 意味着您希望在后台启动几个协程，然后再等待它们。

避免取消 Scope Job

❌如果需要取消协程，不要首先取消 scope job。

class WorkManager {
    val job = SupervisorJob()
    val scope = CoroutineScope(Dispatchers.Default + job)
    
    fun doWork1() {
        scope.launch { /* do work */ }
    }
    
    fun doWork2() {
        scope.launch { /* do work */ }
    }
    
    fun cancelAllWork() {
        job.cancel()
    }
}

fun main() {
    val workManager = WorkManager()
    
    workManager.doWork1()
    workManager.doWork2()
    workManager.cancelAllWork()
    workManager.doWork1() // (1)
}

上述代码的问题是，当取消 job 时，它将被置于已完成状态，在一个已完成 job 的 scope 中启动的协程不会被执行 (1)。

✅如果需要取消特定 scope 内的所有协程，可以使用 cancelChildren 函数。此外，提供取消单个 job 的能力是一种不错的做法 (2)。

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

避免使用隐式 Dispatcher 编写 suspend 函数

❌不要编写依赖于特定协程 dispatcher 执行的 suspend 函数。

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

在上面的示例中，如果从非 Main dispatcher 的协程执行 suspend 函数 login 会导致 Crash：

launch(Dispatcher.Main) {     // (1) no crash
    val loginResult = login()
    ...
}

launch(Dispatcher.Default) {  // (2) cause crash
    val loginResult = login()
    ...
}

CalledFromWrongThreadException：只有创建 View 层次结构的原始线程才能操作其 View。

✅以可以从任何协程 dispatcher 执行的方式设计 suspend 函数。

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

现在我们可以从任意 dispatcher 调用 login 函数了：

launch(Dispatcher.Main) {     // (1) no crash
    val loginResult = login()
    ...
}

launch(Dispatcher.Default) {  // (2) no crash ether
    val loginResult = login()
    ...
}

避免使用 GlobalScope

❌尽量不要在 Android 应用程序中到处使用 GlobalScope：

GlobalScope.launch {
    // code
}

GlobalScope 用于启动顶级协程，它们在整个应用程序生命周期内运行，并且不会被提前取消。
应用程序代码通常应该使用程序定义的 CoroutineScope，非常不建议在 GlobalScope 实例上运行 async 或 launch。

✅在 Android 中协程可以很容易地将 Scope 限制为 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 CAD，Bradyn Poulsen，Tolriq，Dave A。

---

原文：https://proandroiddev.com/kotlin-coroutines-patterns-anti-patterns-f9d12984c68e
作者：Dmytro Danylyk
编译：码王爷