image
开发者们通常会在打磨应用的正常功能上花费很多时间，但是当应用出现一些意外情况时，给用户提供合适的体验也同样重要。一方面来讲，对用户来说，目睹应用崩溃是个很糟糕的体验；而另一方面，在用户操作失败时，也必须要能给出正确的提示信息。
正确地处理异常，可以很大程度上改进用户对一个应用的看法。接下来，本文将会解释异常是如何在协程间传播的，以及一些处理它们的方法，从而帮您做到一切尽在掌握。
⚠️ 为了能够更好地理解本文所讲的内容，建议您首先阅读本系列中的第一篇文章: 协程中的取消和异常 | 核心概念介绍。
某个协程突然运行失败怎么办？😱
当一个协程由于一个异常而运行失败时，它会传播这个异常并传递给它的父级。接下来，父级会进行下面几步操作:
- 取消它自己的子级；
- 取消它自己；
- 将异常传播并传递给它的父级。
异常会到达层级的根部，而且当前 CoroutineScope 所启动的所有协程都会被取消。
△ 协程中的异常会通过协程的层级不断传播
虽然在一些情况下这种传播逻辑十分合理，但换一种情况您可能就不这么想了。假设您的应用中有一个与 UI 关联的 CoroutineScope，用于处理与用户的交互 。如果它的子协程抛出了一个异常，就会导致 UI 作用域 (UI scope) 被取消，并且由于被取消的作用域无法开启新的协程，所有的 UI 组件都会变得无法响应。
如果您不希望这种事情发生，可以尝试在创建协程时在 CoroutineScope 的 CoroutineContext 中使用 Job 的另一个扩展: SupervisorJob。
使用 SupervisorJob 来解决问题
使用 SupervisorJob 时，一个子协程的运行失败不会影响到其他子协程。SupervisorJob 不会取消它和它自己的子级，也不会传播异常并传递给它的父级，它会让子协程自己处理异常。
您可以使用这样的代码创建一个 CoroutineScope: val uiScope = CoroutineScope(SupervisorJob())，这样就会像下图中展示的那样，在协程运行失败时也不会传播取消操作。
△ SupervisorJob 不会取消它其他的子级
如果异常没有被处理，而且 CoroutineContext 没有一个 CoroutineExceptionHandler (稍后讲到) 时，异常会到达默认线程的 ExceptionHandler。在 JVM 中，异常会被打印在控制台；而在 Android 中，无论异常在那个 Dispatcher 中发生，都会导致您的应用崩溃。
💥 未被捕获的异常一定会被抛出，无论您使用的是哪种 Job
使用 coroutineScope 和 supervisorScope 也有相同的效果。它们会创建一个子作用域 (使用一个 Job 或 SupervisorJob 作为父级)，可以帮助您根据自己的逻辑组织协程 (例如: 您想要进行一组平行计算，并且希望它们之间互相影响或者相安无事的时候)。
注意 : SupervisorJob 只有作为 supervisorScope 或 CoroutineScope(SupervisorJob()) 的一部分时，才会按照上面的描述工作。
使用 Job 还是 SupervisorJob？🤔
那么应该在什么时候去使用 Job 或 SupervisorJob 呢？如果您想要在出现错误时不会退出父级和其他平级的协程，那就使用 SupervisorJob 或 supervisorScope。
示例如下:
// Scope 控制我的应用中某一层级的协程
val scope = CoroutineScope(SupervisorJob())
scope.launch {
// Child 1
}
scope.launch {
// Child 2
}
在这个示例中如果 Child 1 失败了，无论是 scope 还是 Child 2 都会被取消。
另一个示例如下:
// Scope 控制我的应用中某一层级的协程
val scope = CoroutineScope(Job())
scope.launch {
supervisorScope {
launch {
// Child 1
}
launch {
// Child 2
}
}
}
在这个示例中，由于 supervisorScope 使用 SupervisorJob 创建了一个子作用域，如果 Child 1 失败了，Child 2 不会被取消。而如果您在扩展中使用 coroutineScope 代替 supervisorScope ，错误就会被传播，而作用域最终也会被取消。
小测验: 谁是我的父级？🎯
给您下面一段代码，您能指出 Child 1 是用哪种 Job 作为父级的吗？
val scope = CoroutineScope(Job())
scope.launch(SupervisorJob()) {
// new coroutine -> can suspend
launch {
// Child 1
}
launch {
// Child 2
}
}
Child 1 的父级 Job 就只是 Job 类型！希望您答对了。虽然乍一看确实会让人以为是 SupervisorJob，但是因为新的协程被创建时，会生成新的 Job 实例替代 SupervisorJob，所以这里并不是。本例中的 SupervisorJob 是协程的父级通过 scope.launch 创建的，所以真相是，SupervisorJob 在这段代码中完全没用！
△ Child 1 和 Child 2 的父级是 Job 类型，不是 SupervisorJob
这样一来，无论 Child 1 或 Child 2 运行失败，错误都会到达作用域，所有该作用域开启的协程都会被取消。
记住，只有使用 supervisorScope 或 CoroutineScope(SupervisorJob()) 创建 SupervisorJob 时，它才会像前文描述的一样工作。将 SupervisorJob 作为参数传入一个协程的 Builder 不能带来您想要的效果。
工作原理
如果您对 Job 的底层实现感到疑惑，可以查看 JobSupport.kt 文件中对 childCancelled 和 notifyCancelling 方法的扩展。
在 SupervisorJob 的扩展中，childCancelled 方法只是返回 false，意味着它不会传播取消操作，也不会对理异常做任何处理。
处理异常👩🚒
协程使用一般的 Kotlin 语法处理异常: try/catch 或内建的工具方法，比如 runCatching (其内部还是使用了 try/catch)
前面讲到，所有未捕获的异常一定会被抛出。但是，不同的协程 Builder 对异常有不同的处理方式。
Launch
使用 launch 时，异常会在它发生的第一时间被抛出，这样您就可以将抛出异常的代码包裹到 try/catch 中，就像下面的示例这样:
scope.launch {
try {
codeThatCanThrowExceptions()
} catch(e: Exception) {
// 处理异常
}
}
使用 launch 时，异常会在它发生的第一时间被抛出
Async
当 async 被用作根协程 (CoroutineScope 实例或 supervisorScope 的直接子协程) 时不会自动抛出异常，而是在您调用 .await() 时才会抛出异常。
当 async 作为根协程时，为了捕获其中抛出的异常，您可以用 try/catch 包裹调用 .await() 的代码:
supervisorScope {
val deferred = async {
codeThatCanThrowExceptions()
}
try {
deferred.await()
} catch(e: Exception) {
// 处理 async 中抛出的异常
}
}
注意，在本例中，async 永远都不会抛出异常。这就是为什么没有必要将它也包裹进 try/catch 中，await 将会抛出 async 协程中产生的所有异常。
当 async 被用作根协程时，异常将会在您调用 .await 方法时被抛出
另一个需要注意的地方是，这里使用了 supervisorScope 来调用 async 和 await。正如我们之前提到的，SupervisorJob 会让协程自己处理异常；而相对的，Job 则会在层级间自动传播异常，这样一来 catch 部分的代码块就不会被调用:
coroutineScope {
try {
val deferred = async {
codeThatCanThrowExceptions()
}
deferred.await()
} catch(e: Exception) {
// async 中抛出的异常将不会在这里被捕获
// 但是异常会被传播和传递到 scope
}
}
更进一步的，其他协程所创建的协程中产生的异常总是会被传播，无论协程的 Builder 是什么。例如:
val scope = CoroutineScope(Job())
scope.launch {
async {
// 如果 async 抛出异常，launch 就会立即抛出异常，而不会调用 .await()
}
}
本例中，由于 scope 的直接子协程是 launch，如果 async 中产生了一个异常，这个异常将就会被立即抛出。原因是 async (包含一个 Job 在它的 CoroutineContext 中) 会自动传播异常到它的父级 (launch)，这会让异常被立即抛出。
⚠️ 在 coroutineScope builder 或在其他协程创建的协程中抛出的异常不会被 try/catch 捕获！
在前面 SupervisorJob 那节中，我们提到了 CoroutineExceptionHandler 的存在。现在让我们来深入探索一下。
CoroutineExceptionHandler
CoroutineExceptionHandler 是 CoroutineContext 的一个可选元素，它让您可以处理未捕获的异常。
下面是如何声明一个 CoroutineExceptionHandler 的例子。无论哪里有异常被捕获，您都可以通过 handler 获得异常所在的 CoroutineContext 的有关信息以及异常本身:
val handler = CoroutineExceptionHandler {
context, exception -> println("Caught $exception")
}
以下的条件被满足时，异常就会被捕获:
-
时机 ⏰: 异常是被自动抛出异常的协程所抛出的 (使用 launch，而不是 async 时)；
-
位置 🌍: 在 CoroutineScope 的 CoroutineContext 中或在一个根协程 (CoroutineScope 或者 supervisorScope 的直接子协程) 中。
我们来看一些使用 CoroutineExceptionHandler 的例子。在下面的代码中，异常会被 handler 捕获:
val scope = CoroutineScope(Job())
scope.launch(handler) {
launch {
throw Exception("Failed coroutine")
}
}
在另外一个例子中，handler 被安装给了一个内部协程，那么它将不会捕获异常:
val scope = CoroutineScope(Job())
scope.launch {
launch(handler) {
throw Exception("Failed coroutine")
}
}
异常不会被捕获的原因是因为 handler 没有被安装给正确的 CoroutineContext。内部协程会在异常出现时传播异常并传递给它的父级，由于父级并不知道 handler 的存在，异常就没有被抛出。
优雅地处理程序中的异常是提供良好用户体验的关键，在事情不如预期般发展时尤其如此。
想要避免取消操作在异常发生时被传播，记得使用 SupervisorJob；反之则使用 Job。
没有被捕获的异常会被传播，捕获它们以保证良好的用户体验！
接下来的时间里，我们将继续更新系列文章，感兴趣的读者请继续关注我们的更新。
网友评论