协程的异常处理

什么情况下 try-catch 会失效？

在 try-catch 块中创建了一个子协程，调用了一个百分百会失败的接口，这个时候我们期望的是能将异常捕获至 catch 中，但是真正运行后却发现 App 崩溃退出了。这也验证了 try-catch 作用无效。

interface ProjectApi {

    @GET("project/tree/jsonError")
    suspend fun loadProjectTreeError(): BaseResp<List<ProjectTree>>
}

fun loadProjectTree() {
    viewModelScope.launch() {
        try {
            launch {
                service.loadProjectTreeError()
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}

这就不得不提到一个新的知识点，协程的结构化并发。

什么是协程的结构化并发？

在 Kotlin 的协程中，全局的 GlobalScope 是一个作用域，每个协程自身也是一个作用域，新建的协程与它的父协程 作用域 存在一个 级联 的关系，也就是一个父子关系层次结构。他们有以下特点：

• 父作用域的生命周期持续到所有子作用域执行完；

• 结束了父作用域，同时也结束它的各个子作用域；

• 子作用域未捕获到的异常将不会被重新抛出，而是一级一级向父作用域传递，这种异常传播将导致父 Job 失败，进而导致其子作用域的所有请求被取消。

上面的三点也就是协程结构化并发的特性。在这种情况下，我们就应该使用一个新的处理异常的方法：CoroutineExceptionHandler。

什么是 CoroutineExceptionHandler？

CoroutineExceptionHandler 是用于全局 捕获所有 行为的最后一种机制。通常，该处理程序用于记录异常、显示某种错误消息、终止和/或重新启动应用程序。CoroutineExceptionHandler 作为一个全局捕获异常的方式，是由于协程结构化并发的特性的存在，子作用域的异常经过一级一级的传递，最后由 CoroutineExceptionHandler 进行处理。因为传递到 CoroutineExceptionHandler 时已经到达顶层作用域，这种情况下，子协程已经结束。也就是说在 CoroutineExceptionHandler 被调用时，所有子协程已经完成了相应的异常。

CoroutineExceptionHandler 怎么用呢？

根协程通过 launch{} 启动时，异常将被传递给已附加的 CoroutineExceptionHandler。

private val exceptionHandler = CoroutineExceptionHandler { _, exception ->
    Log.d(TAG, "CoroutineExceptionHandler exception : ${exception.message}")
}

fun loadProjectTree() {
    viewModelScope.launch(exceptionHandler) {
        service.loadProjectTreeError()
    }
}

CoroutineExceptionHandler 的不足在哪里？

直接说结论吧：CoroutineExceptionHandler 的缺陷就是当子协程出现异常，父协程 和其 兄弟协程 也都会跟着执行失败。

协程中不使用 try-catch，利用 CoroutineExceptionHandler 作为全局捕获异常的机制，最后异常会在 CoroutineExceptionHandler 中处理。但是有两点需要注意：

• 由于没有 try-catch 来捕获住异常，异常会向上传播，直到它到达 RootScope 或 SupervisorJob，根据协程的结构化并发的特性，异常向上传播时，父协程会失败，同时父协程所 级联 的子协程和 兄弟协程 也都会失败；

• CoroutineExceptionHandler 的作用在于全局捕获异常，CoroutineExceptionHandler 无法在代码的特定部分处理异常，例如针对某一个失败接口，无法在异常后进行重试或者其他特定操作。

如果你想并行请求多个接口，并且需要他们彼此不影响任务的执行，也就是任何一个接口异常，其他任务将继续执行，那么 CoroutineExceptionHandler 不是一个很好的选择。而接下来说的 supervisorScope 更适合这种情况。

了解一下 SupervisorScope + async 吧？

SupervisorScope (作用域)与 async 结合开启协程时，子协程出现了异常，并不会影响其父协程以及其兄弟协程。所以更适合多个并行任务的执行。

// 除数为0时，catch 住了异常，同时另外一个兄弟协程也能够正常运行
viewModelScope.launch() {
    supervisorScope {
        try {
            val deferredFail = async { 2 / 0 }
            val deferred = async {
                2 / 1
                Log.d(TAG, "loadProjectTree:  2/1 ")
            }
            deferredFail.await()
            deferred.await()
        } catch (e: Exception) {
            Log.d(TAG, "loadProjectTree:Exception ${e.message} ")
        }
    }
}

总结一下吧：

• 在代码的特定部分处理异常，可使用 try-catch;

• 全局捕获异常，并且其中一个任务异常，其他任务不执行，可使用CoroutineExceptionHandler，节省资源消耗；

• 并行任务间互不干扰，任何一个任务失败，其他任务照常运行，可使用 SupervisorScope + async 模式。