前言

自从用上Kotlin之后，渐渐地开始路转粉，Kotlin的确是好用…

Coroutines（协程）正式版出来之后，逐渐感觉到这种以“同步”方式写异步代码的感觉还挺有意思。不用再写CallBack，直来直去、从上到下。

不过，在实际开发中，却因为用法的不规范，导致了性能受损，异常不断。因此在便有了这篇文章。

当然这篇文章，并不算我原创。准确的说是我翻译，因为人家总结的太好了。原文地址

正文

1、使用coroutineScope包装async调用或使用SupervisorJob处理异常

PS：这是一个坑，我们组就踩过。

如果异步块可能抛出异常，请不要依赖于使用try / catch块包装它。（没错，try不住的，仍会出现异常）

错误代码：

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，它仍然会崩溃。

正确：避免崩溃的一种方法是使用SupervisorJob

// 区别就在这
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) { ... }
}

！！注意！！

只有当async运行在拥有SupervisorJob的coroutine作用域时，这才有效（try住异常）。因此，下面的代码仍会崩溃，因为异步是在父协同程序（1）的作用域内启动的。

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

fun loadData() = scope.launch {
 // 此情况下，是try不住异常的
 try {
 async { // (1)
 // may throw Exception 
 }.await()
 } catch (e: Exception) { ... }
}

那么针对这种情况的正确做法是什么呢？

正确：另一种避免崩溃的方法是使用coroutineScope（1）包装async，这是最好的方法(PS：我们日常开发就这么使用就ok了)。现在，当异常发生在async内部时，它将取消在这个范围内创建的所有其他协程，而不涉及外部范围。（2）

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

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

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

2、对于根协程来说，首选Dispatcher.Main

如果需要一个后台工作并在根协程中更新UI，那么不要用非主调度器（选Dispatcher.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)
}

这种写法是完全没有必要的，会造成性能上的损耗，因为在更新UI的时候，会带来上下文（CoroutineContext）的切换。所以针对这种业务，我们完全可以通过写法来避免这种损耗。

正确：针对这种业务，我们直接创建Dispatchers.Main的根协程就ok了。

val scope = CoroutineScope(Dispatchers.Main)

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

3、避免使用无意义的async/await

如果我们使用的是async()，然后是立即await()，那么应该立刻马上停止这种“骚”操作。

错误代码：

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

正确：如果仅想切换协程工作上下文并立即挂起父协程工作上下文，那么最好是这样做。

这话咋理解呢？说白了就是，如果我们只是想单纯的切换协程的上下文，直接用withContext就ok了。

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

从性能上讲，这不是一个大问题，但从规范上讲，async()意味着：希望在后台启动几个协程任务，然后await()它们。

4、避免无脑取消Job

这是一个有趣的点。当然这部分内容，官方文档也有提起。

如果需要取消协程，请不要首先取消范围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时，其将被置为已完成状态。方法(1)已经不会再被执行了。

正确：

如果要取消特定范围的所有协程，可以使用cancelChildren函数。此外，提供取消个人工作的可能性是一种很好的做法（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()
}

尾声

为了避免篇幅过长，精简掉了一些有歧义的，或者是我还没有研究明白的内容。总结、整理、翻译了这些内容。希望可以为在Kotlin路上前进的小伙伴们带来帮助~