一.异常处理器

1.CoroutineExceptionHandler接口

    CoroutineExceptionHandler是协程中用于处理未捕获异常的上下文。在协程中，可通过自定义上下文实现CoroutineExceptionHandler接口的方式，来处理协程中未捕获的异常。代码如下：

public interface CoroutineExceptionHandler : CoroutineContext.Element {
    
    public companion object Key : CoroutineContext.Key<CoroutineExceptionHandler>

    // 处理异常
    public fun handleException(context: CoroutineContext, exception: Throwable)
}
1
2
3
4
5
6
7

    CoroutineExceptionHandler是异常处理的最后手段。这意味着当调用CoroutineExceptionHandler处理异常时，协程已经处于完成状态，不可再恢复执行。因此，如果需要在异常发生后继续执行，可以在协程中可能发生异常的位置使用try-catch代码块捕获异常。

    协程中只提供了一个实现了CoroutineExceptionHandler接口的类——AndroidExceptionPreHandler类，该类会通过反射的方式，调用异常处理器所在线程的uncaughtExceptionPreHandler处理异常。同时，由于AndroidExceptionPreHandler类通过ServiceLoader注册加载，因此可以处理JVM中所有未捕获的异常，注册文件路径如下：

META-INF/services/kotlinx.coroutines.android.AndroidExceptionPreHandler
1

    以上为协程上下文中存在异常处理器的情况。而当协程上下文中没有异常处理器时，如果异常为取消异常，则会被忽略。如果异常不是取消异常，则会调用上下文中Job对象的cancel方法。如果上下文中Job对象不存在，则会调用JVM全局的CoroutineExceptionHandler对象来处理，并同时调用当前线程的uncaughtExceptionHandler处理。

二.协程中的异常处理

    当协程在执行过程中，发生异常时会触发协程的取消。根据之前在Kotlin协程：生命周期原理的分析，协程的取消最后通过调用cancelImpl方法实现，而在cancelImpl方法中，最终会调用到finalizeFinishingState方法，代码如下：

private fun finalizeFinishingState(state: Finishing, proposedUpdate: Any?): Any? {
    ...
    
    if (finalException != null) {
        // 优先上报给父协程处理，父协程不处理则回调handleJobException方法处理
        val handled = cancelParent(finalException) || handleJobException(finalException)
        if (handled) (finalState as CompletedExceptionally).makeHandled()
    }
    
    ...
}
1
2
3
4
5
6
7
8
9
10
11

1.launch方法的异常处理

    如果通过launch方法启动协程，方法内部会创建StandaloneCoroutine类型的对象，并调用start方法启动协程。StandaloneCoroutine类的代码如下：

private open class StandaloneCoroutine(
    parentContext: CoroutineContext,
    active: Boolean
) : AbstractCoroutine<Unit>(parentContext, active) {
    override fun handleJobException(exception: Throwable): Boolean {
        // 处理未捕获异常
        handleCoroutineException(context, exception)
        return true
    }
}

1
2
3
4
5
6
7
8
9
10
11

    StandaloneCoroutine类重写了handleJobException方法，并在内部通过handleCoroutineException方法处理异常。handleJobException方法的代码如下：

@InternalCoroutinesApi
public fun handleCoroutineException(context: CoroutineContext, exception: Throwable) {
    // 调用上下文中的异常处理器处理
    try {
        // 获取异常处理器，处理异常
        context[CoroutineExceptionHandler]?.let {
            it.handleException(context, exception)
            return
        }
    } catch (t: Throwable) {
        // 发生异常，通过handleCoroutineExceptionImpl方法处理
        handleCoroutineExceptionImpl(context, handlerException(exception, t))
        return
    }
    
    // 如果上下文中异常处理器不存在，则通过handleCoroutineExceptionImpl方法处理
    handleCoroutineExceptionImpl(context, exception)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

    如果上下文中异常处理器不存在，则通过handleCoroutineExceptionImpl方法处理，代码如下：

internal actual fun handleCoroutineExceptionImpl(context: CoroutineContext, exception: Throwable) {
    // 遍历JVM全局的异常处理器
    for (handler in handlers) {
        try {
            // 处理异常
            handler.handleException(context, exception)
        } catch (t: Throwable) {
            // 发生异常则调用当前线程的uncaughtExceptionHandler处理
            val currentThread = Thread.currentThread()
            currentThread.uncaughtExceptionHandler.uncaughtException(currentThread, handlerException(exception, t))
        }
    }

    // 再调用当前线程的uncaughtExceptionHandler处理
    val currentThread = Thread.currentThread()
    currentThread.uncaughtExceptionHandler.uncaughtException(currentThread, exception)
}

// 从ServiceLoader中注册加载的JVM全局的异常处理器
private val handlers: List<CoroutineExceptionHandler> = ServiceLoader.load(
        CoroutineExceptionHandler::class.java,
        CoroutineExceptionHandler::class.java.classLoader
).iterator().asSequence().toList()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

    handleCoroutineExceptionImpl方法分别调用了JVM全局的异常处理器与当前线程的uncaughtExceptionHandler处理。

2.async方法的异常处理

    如果通过async方法启动协程，方法内部会创建DeferredCoroutine类型的对象，并调用start方法启动协程。但DeferredCoroutine类中并没有重写父类的handleJobException方法，方法仍然为空实现，代码如下：

protected open fun handleJobException(exception: Throwable): Boolean = false
1

    如果协程执行过程中发生异常，则会导致协程取消，协程的最终状态将为CompletedExceptionally类型的对象，根据之前在Kotlin协程：异步执行与同步获取中对await方法的分析，await方法在获取结果和恢复续体时会判断状态是否为CompletedExceptionally类型的对象，如果是，则会抛出异常。

三.总结

    当一个协程执行过程中遇到未捕获的异常时，首先会尝试将异常传递给自己的父协程，最终传递给最顶级的父协程。如果父协程不处理(父协程为SupervisorJob或为async启动的协程)，则由自身上下文中的异常处理器处理，如果自身上下文没有异常处理器，则会同时交给JVM全局的异常处理器和当前线程的uncaughtExceptionHandler处理。

    对于通过launch方法启动的协程，在执行过程中遇到未捕获异常时会直接抛出。而对于async方法启动的协程，在执行过程中遇到未捕获异常时不会抛出，而是直接进入完成状态。但当调用await方法获取结果时会将异常抛出。