目录
- 介绍
- 使用
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
编译：码王爷
