Kotlin协程异常机制

• 协程的3种作用域以及异常的传播方式
• 协程异常的两种捕获方式及对比
• 协程异常的优雅封装

作用域以及异常的传播方式

协程作用域分为顶级作用域，协同作用域与主从作用域，分别对应GlobalScope，coroutineScope，supervisorScope。

协程作用域分类.png
协程作用域范围.png

说明:

C2-1发生异常的时候，C2-1->C2->C2-2->C2->C1->C3（包括里面的子协程）->C4

C3-1-1发生异常的时候,C3-1-1->C3-1-1-1，其他不受影响

C3-1-1-1发生异常的时候，C3-1-1-1->C3-1-1，其他不受影响

// C1和C2没有关系
GlobalScope.launch { //协程C1
    GlobalScope.launch {//协程C2
        //...
    }
}
// C2和C3是C1的子协程，C2和C3异常会取消C1
GlobalScope.launch { //协程C1
    coroutineScoope {
         launch{}//协程C2
         launch{}//协程C3
    }
}
// C2和C3是C1的子协程，C2和C3异常不会取消C1
GlobalScope.launch { //协程C1
    supervisorScope {
         launch{}//协程C2
         launch{}//协程C3
    }
}

如何捕获异常

传播的异常可以通过CoroutineExceptionHandler来捕获
如果协程本身不使用try-catch子句自行处理异常，则不会重新抛出该异常，因此无法通过外部try-catch子句进行处理。

异常会在“Job层次结构中传播”，可以由已设置的CoroutineExceptionHandler处理。如果未设置，则调用该线程的未捕获异常处理程序。

CoroutineExceptionHandler

Try Catch与CoroutineExceptionHandler对比
协程支持两种异常处理机制，那么我们应该选择哪种呢？

CoroutineExceptionHandler的官方文档提供了一些很好的答案：

“ CoroutineExceptionHandler是用于全局“全部捕获”行为的最后手段。您无法从CoroutineExceptionHandler中的异常中恢复。当调用处理程序时，协程已经完成，并带有相应的异常。通常，处理程序用于记录异常，显示某种错误消息，终止和/或重新启动应用程序。

如果需要在代码的特定部分处理异常，建议在协程内部的相应代码周围使用try / catch。这样，您可以防止协程异常完成（现在已捕获异常），重试该操作和/或采取其他任意操作：”

launch{} vs async{}

fun main() {

    val topLevelScope = CoroutineScope(SupervisorJob())

    topLevelScope.async {
        throw RuntimeException("RuntimeException in async coroutine")
    }

    Thread.sleep(100)
}

// 没有输出
fun main() {

    val coroutineExceptionHandler = CoroutineExceptionHandler { coroutineContext, exception ->
        println("Handle $exception in CoroutineExceptionHandler")
    }

    val topLevelScope = CoroutineScope(SupervisorJob() + coroutineExceptionHandler)
    topLevelScope.launch {
        async {
            throw RuntimeException("RuntimeException in async coroutine")
        }
    }
    Thread.sleep(100)
}

// 输出
// Handle java.lang.RuntimeException: RuntimeException in async coroutine in CoroutineExceptionHandler

launch和async协程中未捕获的异常会立即在作业层次结构中传播。
但是，如果顶层Coroutine是从launch启动的，则异常将由CoroutineExceptionHandler处理或传递给线程的未捕获异常处理程序。

如果顶级协程以async方式启动，则异常封装在Deferred返回类型中，并在调用.await()时重新抛出。

coroutineScope异常处理特性

范围函数coroutineScope {}重新抛出其失败的子协程的异常，而不是将其传播到Job层次结构中，这使我们能够使用try-catch处理失败的协程的异常。

supervisorScope异常处理特性

范围函数supervisorScope {}在Job层次结构中添加了一个新的独立子范围，并将SupervisorJob作为这个scope的'job'。

这个新作用域不会在“Job层次结构”中传播其异常，因此它必须自行处理其异常。直接从supervisorScope启动的协程是顶级协程。

顶级协程与子协程在使用launch()或async()启动时的行为有所不同，此外，还可以在它们中安装CoroutineExceptionHandlers。

协程异常的优雅封装

我们可以对CoroutineExceptionHandler进行封装，利用kotlin扩展函数，实现类似RxJava的调用效果。最后调用效果如下：

fun fetch() {
        viewModelScope.rxLaunch<String> {
            onRequest = {
                //网络请求
                resposity.getData()
            }
            onSuccess = {
                //成功回调
            }
            onError = {
                //失败回调
            }
        }
    }

主要利用kotlin扩展函数及DSL语法，封装协程异常处理，达到类似RxJava调用的效果

fun <T> CoroutineScope.rxLaunch(init: CoroutineBuilder<T>.() -> Unit) {
    val result = CoroutineBuilder<T>().apply(init)
    val coroutineExceptionHandler = CoroutineExceptionHandler { _, exception ->
        result.onError?.invoke(exception)
    }
    launch(coroutineExceptionHandler) {
        val res: T? = result.onRequest?.invoke()
        res?.let {
            result.onSuccess?.invoke(it)
        }
    }
}

class CoroutineBuilder<T> {
    var onRequest: (suspend () -> T)? = null
    var onSuccess: ((T) -> Unit)? = null
    var onError: ((Throwable) -> Unit)? = null
}