Kotlin 异常传播如何在 CoroutineScope.async 上工作

In some sense, the mess you experience is a consequence of Kotlin coroutines having been an early success, before they became stable. In their experimental days, one thing they lacked was structured concurrency, and a ton of web material got written about them in that state (such as your link 1 from 2017). Some of the then-valid preconceptions remained with people even after their maturation, and got perpetuated in even more recent posts.

实际情况非常清楚-您所要理解的就是协程层次 struct ，它是通过Job个对象进行中介的.不管它是launch还是async，或者任何其他的协程构建器-它们的行为都是一致的.

With this in mind, let's go through your examples:

runBlocking {
  async { throw Exception("Oops") }
}

通过只写async，你隐式地使用了this.async，其中this是runBlocking建立的CoroutineScope.它包含与runBlocking协同路由关联的Job实例.由于这个原因，async协同程序成为runBlocking的子程序，因此当async协同程序失败时，后者会抛出一个异常.

runBlocking {
  async(SupervisorJob()) { throw Exception("Oops") }
}

在这里，您提供了一个没有父级的独立作业(job)实例.这打破了协程层次 struct ，runBlocking不会失败.事实上，runBlocking件事甚至不需要等你的协同程序完成--加一个delay(1000)来验证这一点.

runBlocking {
  async(Job()) { throw Exception("Oops") }
}

这里没有新的理由——Job或SupervisorJob，这无关紧要.你打破了协同程序的层次 struct ，失败不会传播.

Now let's explore a few more variations:

runBlocking {
    async(Job(coroutineContext[Job])) {
        delay(1000)
        throw Exception("Oops")
    }
}

现在，我们创建了一个新的Job实例，但我们将其设为runBlocking的子级.这会抛出一个异常.

runBlocking {
    async(Job(coroutineContext[Job])) {
        delay(1000)
        println("Coroutine done")
    }
}

Same as above, but now we don't throw an exception and the async coroutine completes normally. It prints Coroutine done, but then something unexpected happens: runBlocking does not complete, and the program hangs forever. Why?

这可能是这个机制中最棘手的部分，但一旦你仔细考虑，它仍然是非常有意义的.当您创建一个协同程序时，它会在内部创建自己的Job个实例——无论您是否明确地将作业(job)作为参数提供给async，这种情况都会发生.如果你提供了一个明确的工作，它将成为内部创建的工作的parent.

Now, in the first case, where you didn't provide an explicit job, the parent job is the one internally created by runBlocking. It automatically completes when the runBlocking coroutine completes. But completion doesn't propagate to the parent the way cancellation does — you wouldn't want everything stopping just because one child coroutine completed normally.

因此，当您创建自己的Job实例并将其作为async协程的父实例提供时，您的工作不会因任何事情而完成.如果协程失败，则失败会传播到您的作业(job)，但是如果它正常完成，您的作业(job)将永远保持"正在进行"的原始状态.

最后，让我们再带来SupervisorJob个:

runBlocking {
    async(SupervisorJob(coroutineContext[Job])) {
        delay(1000)
        throw Exception("Oops")
    }
}

This just runs forever without any output, because SupervisorJob swallows the exception.