一、组合上下文中的元素

CoroutineContext 是一组用于定义协程行为的元素。它由如下几项组成：

1、Job：控制协程的生命周期
2、CoroutineDispatcher：向合适的线程分发任务
3、CoroutineName：协程的名称
4、CoroutineExceptionHandler：处理被捕获的异常

可以使用 + 运算符组合上下文：

   launch(Dispatchers.Default + CoroutineName("test")) {
    }

二、协程上下文的继承

对于新建的协程，它的 CoroutineContext 会包含一个全新的Job实例，它会帮助我们控制协程生命周期。而剩下的元素会从CoroutineContext的父类继承，该父类可能是另外一个协程或者创建该协程的CoroutineSocpe。

    val coroutineExceptionHandler = CoroutineExceptionHandler { _, exception ->
        println("exception:$exception")
    }
    val scope = CoroutineScope(Job() + Dispatchers.Default + CoroutineName("test") + coroutineExceptionHandler)
    val job = scope.launch(Dispatchers.IO) {
        // 协程的调度器是：Dispatchers.IO
        // 每次创建协程都会有一个新的Job实例
        // 协程的名字来自于父协程或者CoroutineScope：test（默认值为coroutine）
        // 协程的异常处理器来自于父协程或者CoroutineScope：coroutineExceptionHandler
    }

三、异常处理的必要性

当应用出现一些意外情况时，给用户提供合适的体验非常重要，一方面，目睹应用崩溃是个很糟糕的体验，另一方面，在用户操作失败时，也必须给出正确的提示信息。

四、异常的传播特性

协程构建器有两种形式：
【1】自动传播异常（launch与actor）
【2】向用户暴露异常（async与produce）
当这些构建器用于创建一个 根协程 时，前者构建器，异常会在第一时间被抛出，后者构建器，依赖用户最终消费异常，例如通过await或receive。

    val job1 = launch(Dispatchers.IO) {
        try {
            throw RuntimeException("launch exception")
        } catch (e: Exception) {
            println("launch exception")
        }
    }
    job1.join()

    val deferred = async(Dispatchers.IO) {
        throw RuntimeException("async exception")
    }
    try {
        deferred.await()
    } catch (e: Exception) {
        println("async exception")
    }

以上代码，launch 在协程体中抛出异常，async 只有当用户消费的时候（执行await函数时）才会抛出异常。

非根协程产生的异常总会被传播：

异常的传播特性：

当一个协程由于一个异常而运行失败时，它会传播这个异常并传递给它的父级。
接下来，父级会进行下面几个操作：

1、取消它自己的子集
2、取消它自己
3、将异常传播给它的父级

SupervisorJob 可以打破传统的异常传播特性，使用 SupervisorJob 时，一个子协程的运行失败不会影响其他子协程。
SupervisorJob不会传播异常给它的父级，它会让子协程自己处理异常。

    val scope = CoroutineScope(SupervisorJob())
    val job1 = scope.launch(Dispatchers.Default) {
        throw RuntimeException("job1 exception")
    }
    val job2 = scope.launch(Dispatchers.Default) {
        try {
            delay(1000)
        } catch (e: Exception) {
            e.printStackTrace()
        } finally {
            println("job2 finally")
        }
    }
    joinAll(job1, job2)

以上代码，job1 抛出异常，job2 正常执行，job2 的执行不受其他兄弟协程异常的影响。

这种需求常见于在作用域内定义作业的UI组件，如果任何一个UI的子作业执行失败了，它并不总是有必要取消整个UI组件，但是如果UI组件被销毁了，由于它的结果不再被需要了，它就有必要使所有的子作业执行失败。

使用 协程构建器 coroutineScope，可以达到一样的效果，但是，如果 coroutineScope 的自身的协程体发生了异常，其所有子协程全部取消：

    supervisorScope{

        launch(Dispatchers.Default) {
            delay(1000)
            println("job1 excute")
            throw RuntimeException("job1 exception")
        }

        launch(Dispatchers.Default) {
            try {
                delay(1000)
            } catch (e: Exception) {
                e.printStackTrace()
            } finally {
                println("job2 finally")
            }
        }

        delay(100)
        throw RuntimeException("supervisorScope thread exception")
    }

以上最后一句代码抛出了异常，导致其他两个子协程全部取消。

五、异常的捕获

使用 CoroutineExceptionHandler 对协程的异常进行捕获。
当然，并不是所有的异常都会被 CoroutineExceptionHandler 捕获，需要满足以下条件：

1、时机：异常是被自动抛出异常的协程所抛出，使用 launch，而不是 async 时；
2、位置：在CoroutineScope的CoroutineContext中或在一个根协程
    （CoroutineScope 或者 SupervisorScope 的直接子协程）中。

看下演示代码：

    val coroutineExceptionHandler = CoroutineExceptionHandler { _, exception ->
        println("exception:$exception")
    }
    val scope = CoroutineScope(Dispatchers.Default + coroutineExceptionHandler)
    val job = scope.launch {
        throw RuntimeException("launch exception")
    }
    val deferred = scope.async {
        throw RuntimeException("async exception")
    }
    job.join()
    deferred.await()

launch 中的异常被 CoroutineExceptionHandler 捕获了，async 中的异常没有被 CoroutineExceptionHandler 捕获。

另外，CoroutineExceptionHandler 不能安装在内部协程，只能安装在最外层协程中，比如：

    val coroutineExceptionHandler = CoroutineExceptionHandler { _, exception ->
        println("exception:$exception")
    }
    val scope = CoroutineScope(Dispatchers.Default)
    val job = scope.launch {
        launch(coroutineExceptionHandler) {
            throw RuntimeException("launch exception")
        }
    }
    job.join()

像这样的代码，异常是无法被 CoroutineExceptionHandler 捕获的。

六、Android全局异常处理

全局异常处理器可以获取到所有协程未处理的未捕获异常，不过它并不能对异常进行捕获，虽然不能阻止程序崩溃，全局异常处理器在程序调试和异常上报等场景中仍然有非常大的用处。

我们需要在classpath下面创建META-INF/services目录，并在其中创建一个名为kotlinx.coroutines.CoroutineExceptionHandler 的文件，文件内容就是我们的全局异常处理器的全类名。

编写 com.xxx.xxx.GlobalCoroutineExceptionHandler 类：

/**
 * 全局异常处理器
 */
class GlobalCoroutineExceptionHandler : CoroutineExceptionHandler {

    override val key: CoroutineContext.Key<*> = CoroutineExceptionHandler

    override fun handleException(context: CoroutineContext, exception: Throwable) {
        LuxLog.e("yunchong", "global exception:$exception")
    }
}

在模块下的main目录下新建 resources/META-INF/services 目录，在该目录下新建 kotlinx.coroutines.CoroutineExceptionHandler 文件，文件中的内容是 com.xxx.xxx.GlobalCoroutineExceptionHandler。

handleException 方法不能捕获异常，不能防止APP崩溃，但可以记录下未被捕获的异常。

七、取消与异常

取消与异常常紧密相关，协程内部使用 CancellationException 来进行取消，这个异常会被忽略。

当子协程被取消时，不会取消它的父协程。

如果一个协程遇到了 CancellationException 以外的异常，它将使用该异常取消它的父协程。当父协程的所有子协程都结束后，异常才会被父协程处理。

八、异常聚合

当协程的多个子协程因为异常而失败时，一般情况下取第一个异常进行处理。在第一个异常之后发生的所有其他异常，都将绑定到第一个异常之上。

    val coroutineExceptionHandler = CoroutineExceptionHandler { _, exception ->
        println("exception:${exception.message} == ${exception.suppressed.contentToString()}")
    }
    val scope = CoroutineScope(Dispatchers.Default + coroutineExceptionHandler)
    val job = scope.launch {
        launch {
            try {
                delay(Long.MAX_VALUE)
            } finally {
                throw RuntimeException("job1 exception")
            }
        }

        launch {
            try {
                delay(Long.MAX_VALUE)
            } finally {
                throw RuntimeException("job2 exception")
            }
        }

        launch {
            delay(100)
            throw RuntimeException("job3 exception")
        }
    }
    job.join()

打印 结果：exception:job3 exception == [java.lang.RuntimeException: job1 exception, java.lang.RuntimeException: job2 exception]

[本章完...]