Kotlin 协程 - 协程异常处理器 CoroutineExceptionHandler

一、异常的传播

• Job的取消和异常传播是双向的（结构化并发），如果抛异常的代码在局部没有捕获处理，协程或将其传播到层次结构中，该协程会先取消所有子协程再取消自己，如果这个异常是 CancellationException 类型便终止向上传播，如果使用了 SupervisorScope() 或 supervisorJob 不管什么类型的异常都终止向上传播，否则会一直传递到根协程导致整个结构中的协程都会被取消。
• CancellationException类型的异常由抛出的协程处理，SupervisorJob类型时由该层的下级子协程处理（可能是抛异常的协程或它的父协程，但是都是SupervisorJob层的子协程），其他情况由根协程处理。

1.1 多个协程作用域之间的关系

//【顶级作用域】1和2没有关系，1和3没有关系，2和3没有关系
GlobalScope.launch {    //协程1
    GlobalScope.launch{}    //协程2
}
CoroutineScopr(Dispatcher.IO).lacunch{}    //协程3
 
//2和3是1的子协程，2或3异常都会取消1，1异常会取消2和3，2异常会取消3
GlobalScope.launch {    //协程1
    coroutineScoope {
         launch{}    //协程2
         launch{}    //协程3
    }
}
 
//4和5是3的子协程，4异常会取消5不会取消3，3异常会取消4和5不会取消2和1
GlobalScope.launch {    //协程1
    launch{}    //协程2
    supervisorScope {    //协程3
         launch{}    //协程4
         launch{}    //协程5
    }
}

二、打断传播

当不希望异常向上传播或兄弟协程相互影响时使用（向下传播依然存在）。SupervisorScope() 使用的 supervisorJob，使用新的 Job 开启协程作用域意味着它是独立的，因此只需要关心自己内部，异常不处理会导致程序崩溃。

2.1 supervisorJob

//避免在只有一个子协程的时候传参使用（孙协程仍会相互取消，作用相当于普通job）
launch(SupervisorJob()) {    //唯一子协程
    launch {
        println("子协程1")
        throw Exception()    //会相互取消
    }   
    launch {
        println("子协程2")    //不会打印
    }
}
 
//正确写法
launch {
    launch(SupervisorJob()) {
        println("子协程1")
        throw Exception()    //不会相互取消
    }
    launch(SupervisorJob()) {
        println("子协程2")    //会打印
    }
}

2.2 SupervisorScope()

supervisorScope{
    launch{
        println("子协程1")
        throw Exception()
    }
    launch{
        println("子协程2")    //会打印
    }
}

三、CancellationException

如果异常是 CancellationException 及其子类，将不会向上传递，只取消当前协程及其子类。

//分别开启1和2两个协程，抛出异常会结束1和它的子协程3，但不会影响2
object MyException : CancellationException()
suspend fun main(): Unit = coroutineScope {
    launch {    //1
        launch {    //3
            delay(2000)
            println("1")    //不会打印
        }
        throw MyException
    }
    launch {    //2
        delay(2000)
        println("2")    //会打印
    }
}

四、异常捕获

4.1 try-catch

//无效
try {
    launch {
        //异常不被捕获不会再抛出，会在层次结构中双向传播实现结构化并发的连锁取消
    }
}
 
//有效
launch {
    try { //具体会抛异常的代码 }
}
 
//有效
try {
    coroutineScope { //具体会抛异常的代码 }
}

​4.2 CoroutineExceptionHandler

不会阻止异常传递，当执行时表示结构化并发已全部取消完成，是最后一次捕获异常。意思是无法从异常中恢复协程，只能用来做最后的处理（不捕获然就是线程的 UncaughtExceptionHandler 处理了），默认情况它会打印异常堆栈。

fun main(): Unit = runBlocking {
    val rootExceptionHandler = CoroutineExceptionHandler { _, throwable -> println("调用【根】协程异常处理器：${throwable.message}") }
    val parentExceptionHandler = CoroutineExceptionHandler { _, throwable -> println("调用【父】协程异常处理器：${throwable.message}") }
    val selfExceptionHandler = CoroutineExceptionHandler { _, throwable -> println("调用【自身】协程异常处理器：${throwable.message}") }
    val childExceptionHandler = CoroutineExceptionHandler { _, throwable -> println("调用【子】协程异常处理器：${throwable.message}") }
 
    //全是 Job 只使用 root，使用 parent 和 self 都无效会报错
    CoroutineScope(Job()).launch(rootExceptionHandler) {
        launch(parentExceptionHandler) {
            launch(selfExceptionHandler) {
                throw Exception("子协程使用的是Job")
            }
        }
    }
 
    //从下往上在遇到 SupervisorJob 或 supervisorScope() 起，使用最近的那个异常处理器
    //即child无效，有self用self，没有self用parent，没有parent用root，同时设置self、parent、root用最近的self
    CoroutineScope(Job()).launch(rootExceptionHandler) {
        launch(parentExceptionHandler) {
            launch(SupervisorJob() + selfExceptionHandler ) {
                launch(childExceptionHandler) {
                    throw Exception("子协程使用的是SupervisorJob")
                }
            }
        }
    }
    delay(1000)
}