父Job取消时如何取消子Job

fun main() {
    //创建一个Job，当然你也可以启动一个协程后返回
    val job = GlobalScope.launch {
        //启动一个子协程
        launch {
            Thread.sleep(200)
            println("子协程完成")
        }
        Thread.sleep(100)
        println("父协程完成")
    }

    job.cancel()
    TimeUnit.SECONDS.sleep(1)
    println("结束")

}

父协程完成
结束

我们看下子协程如何被取消的。
首先我们需要知道 子协程启动的时候会放一个监听器到父亲NodeList中. 这是在监听父协程么
也就是如下代码：

    public final override fun attachChild(child: ChildJob): ChildHandle {
        return invokeOnCompletion(onCancelling = true, handler = ChildHandleNode(this, child).asHandler) as ChildHandle
    }

当我们的demo源码调用时:

最终会调用到：

  private fun makeCancelling(cause: Any?): Any? {
        var causeExceptionCache: Throwable? = null // lazily init result of createCauseException(cause)
        loopOnState { state ->
            when (state) {
                is Finishing -> {
                   //...由于协程未完成所以到这
                }
                is Incomplete -> {
                   //当前协程未完成，所判断走到这
                   //创建一个取消异常
                    val causeException = causeExceptionCache ?: createCauseException(cause).also { causeExceptionCache = it }
                    //当前协程是否存活 这里显然返回true
                    if (state.isActive) {
                       
                        if (tryMakeCancelling(state, causeException)) return COMPLETING_ALREADY
                    } else {
                     
                     //....
                        }
                    }
                }
                else -> return TOO_LATE_TO_CANCEL // already complete
            }
        }
    }

跟进tryMakeCancelling(state, causeException))

    private fun tryMakeCancelling(state: Incomplete, rootCause: Throwable): Boolean {
        //如果当前state不是NodeList，那么讲当前状态变为NodeList
        //在我们本案例当中当前state是ChildHandle所以要变为NodeList
        val list = getOrPromoteCancellingList(state) ?: return false
        //变为cancelling状态
        val cancelling = Finishing(list, false, rootCause)
        //切换状态
        if (!_state.compareAndSet(state, cancelling)) return false
        //唤醒NodeList各个节点
        notifyCancelling(list, rootCause)
        return true
    }

继续

private fun notifyCancelling(list: NodeList, cause: Throwable) {
        //空函数用于扩展的一个回调
        onCancelling(cause)
        //回调这个NodeList上的所有监听，所以这类会在这里取消
        notifyHandlers<JobCancellingNode<*>>(list, cause)
        //取消父协程
        cancelParent(cause) 
    }

notifyHandlers<JobCancellingNode<*>>(list, cause)比较简单,这里不在做说明。

 private inline fun <reified T: JobNode<*>> notifyHandlers(list: NodeList, cause: Throwable?) {
        var exception: Throwable? = null
        list.forEach<T> { node ->
            try {
                node.invoke(cause)
            } catch (ex: Throwable) {
                exception?.apply { addSuppressedThrowable(ex) } ?: run {
                    exception =  CompletionHandlerException("Exception in completion handler $node for $this", ex)
                }
            }
        }
        exception?.let { handleOnCompletionException(it) }
    }

以上我们知道了父协程取消的时候是通过NodeList取消子协程的.而子协程收到取消后悔递归的取消子协程和自身代码。具体协程的取消细节后续章节在做说明，这里只需要管如何传递取消的。

我们最后看看父协程收到取消异常的之后的处理方法：
cancelParent(cause)

private fun cancelParent(cause: Throwable): Boolean {
        //忽略 这里先当做false，关于范围协程后面有机会再说
        if (isScopedCoroutine) return true

        
        val isCancellation = cause is CancellationException
        val parent = parentHandle
        if (parent === null || parent === NonDisposableHandle) {
            return isCancellation
        }
        //最终调用了父类的childCancelled函数
        return parent.childCancelled(cause) || isCancellation
    }

这个childCancelled函数的声明:

public interface ChildHandle : DisposableHandle {
  
    @InternalCoroutinesApi
    public fun childCancelled(cause: Throwable): Boolean
}

我们看下大致的两种实现:

 //JobSupport.kt
 public open fun childCancelled(cause: Throwable): Boolean {
        //(CancellationException异常在手动取消子类的时候抛出)
        //如果子类不是由于意外异常取消的那么不取消父协程,
        if (cause is CancellationException) return true
        //如果子类是由于取消异常之外的情况导致的,比如说子协程除零异常的.那么取消父协程
        return cancelImpl(cause) && handlesException
    }

看下另一种子协程不管如何都不会取消父协程

private class SupervisorJobImpl(parent: Job?) : JobImpl(parent) {
    override fun childCancelled(cause: Throwable): Boolean = false
}

也就是说当我们使用如下代码子协程异常不会取消父协程(父协程依然可以取消子协程).

fun main() {

    //创建一个Job
    val job = GlobalScope.launch {

        launch(SupervisorJob()) {
            val d = 1 / 0
        }

        //为了让子协程完成
        delay(100)

        println("协程完成")
    }

    TimeUnit.SECONDS.sleep(1)
    println("结束")
}

输出:

协程完成
结束

可见子协程异常之后父协程依然在运行.否则就不会出现协程完成这个输出.

我们总结下:

子协程创建时会讲自己放入父协程的job链表,所以当父协程取消的时候会回调所有子协程.
子协程取消时候会回调childCancelled函数,父协程根据情况判断是否取消自己