4.协程的异常处理(2)

异常的传播
异常传播是指异常在父子协程中的传播，什么是父子协程，在当前协程中又启动一个协程，那么这个新启动的协程就是当前协程的子协程。异常的传播涉及到协程作用域的概念
一协程作用域

1.协程作用域本身是一个接口

public interface CoroutineScope {
    //此作用域的上下文
    //上下文由作用域封装，用于实现协程生成器，这些生成器是作用域上的扩展
    //此属性除了为了高级用途而访问[Job]实例外，不推荐访问
    //通常应该包含一个Job的实例来执行结构化并发
    public val coroutineContext: CoroutineContext
}

子类如下

clipboard.png

看一个例子，来加深理解作用域的父子关系

GlobalScope.launch {
    println("GlobalScope ${this}")
    launch {
        println("A ${this}")
        launch {
            println("A1 ${this}")
        }
    }

    launch {
        println("B ${this}")
    }
}.join()

打印

GlobalScope StandaloneCoroutine{Active}@4957b7c3
A StandaloneCoroutine{Active}@507cdd7a
B StandaloneCoroutine{Active}@64a45f82
A1 StandaloneCoroutine{Active}@544353ad

关系如下图所示

4232467852.png

作用域启动新协程也是一个新的作用域，它们的关系可以并列，也可以包含，组成了一个作用域的树形结构默认情况下，每个协程都要等待它的子协程全部完成后，才能结束自己。这种形式，就被称为结构化的并发

2.我们之前启动协程一直用的是GlobalScope，GlobalScope是一个顶级的协程作用域，此外还有coroutineScope{...}以及 supervisorScope{...}等，这里我们重点讲一下跟异常传播有关系的coroutineScope{...}跟supervisorScope{...}
coroutineScope源码

//创建协程作用域并在此范围调用指定的代码块
//该作用域继承了外部作用域的协程上下文但是重写了里面的Job
//这个函数是为分解并行工作而设计的
//当这个作用域内的任何子协同程序失败时，所有其余的子协程都被取消
public suspend fun <R> coroutineScope(block: suspend CoroutineScope.() -> R): R =
    suspendCoroutineUninterceptedOrReturn { uCont ->
        val coroutine = ScopeCoroutine(uCont.context, uCont)
        coroutine.startUndispatchedOrReturn(coroutine, block)
    }

来看一下异常传播对于coroutineScope{...}中是怎样的

coroutineScope {
    launch {
        log(1)
        launch {
            log(2)
            throw ArithmeticException()
        }
    }
    launch {
        delay(200)
        log(3)
    }
}

打印如下

18:19:32:955 [DefaultDispatcher-worker-1] 1
18:19:32:955 [DefaultDispatcher-worker-2] 2
Exception in thread "main" java.lang.ArithmeticException

coroutineScope 当中协程异常会触发父协程的取消，进而将整个协程作用域取消掉，如果对 coroutineScope 整体进行捕获，也可以捕获到该异常

supervisorScope源码

//创建协程作用域并在此作用域调用指定的代码块
//该作用域继承了外部作用域的协程上下文但是重写了里面的Job
//子协程的失败不会导致此作用域失败，也不会影响其他子协程
public suspend fun <R>  supervisorScope(block: suspend CoroutineScope.() -> R): R =
    suspendCoroutineUninterceptedOrReturn { uCont ->
        val coroutine = SupervisorCoroutine(uCont.context, uCont)
        coroutine.startUndispatchedOrReturn(coroutine, block)
}

来看一下异常传播在supervisorScope中是怎样的

supervisorScope{
    launch {
        log(1)
        throw ArithmeticException()
    }
    launch {
        delay(200)
        log(2)
    }
}

打印如下

18:33:15:486 [DefaultDispatcher-worker-1] 1
18:33:15:523 [DefaultDispatcher-worker-1] 2
Exception in thread "DefaultDispatcher-worker-1" java.lang.ArithmeticException

如何捕获异常如下

val exceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
    log(throwable)
}
supervisorScope{
    launch (exceptionHandler){
        log(1)
        throw ArithmeticException()
    }
    launch {
        delay(200)
        log(2)
    }
}