Kotlin协程 runBlocking 运行原理协程示例 Coroutine.kt 这是协程官方提供的一个示例，单从

协程示例

Coroutine.kt

fun main() = runBlocking { // this: CoroutineScope
    launch { // 启动新协程 
        delay(1000L) // 非阻塞延时 1 秒 
        println("World!") // print after delay
    }
    println("Hello")
}

这是协程官方提供的一个示例，单从 Kotlin 代码无法完全理解协程的运行原理，Kotlin 协程除了协程提供的框架外，还需要 Kotlin 编译器配合,所以我们需要反编译字节码的方式查看协程的运行逻辑。

Coroutine.kt 编译后生成 CoroutineKt.class

public final class CoroutineKt {
    public static final void main() {
        // 调用 runBlocking$default 方法 
        BuildersKt.runBlocking$default((CoroutineContext)null,
        // 创建 CoroutineKt$main$1 对象 
        (Function2)(new CoroutineKt$main$1((Continuation)null)), 1, (Object)null);
    }
    
    // 编译生成的 main 方法 
    // $FF: synthetic method
    public static void main(String[] args) {
        main(); // 调用 mian()函数
    }
}

public final class BuildersKt {
    // 调用 runBlocking$default 方法 var0 为 null ,var1 为 CoroutineKt$main$1 对象 ，var2 为 1 ，var3 为 null 
    // $FF: synthetic method
    public static Object runBlocking$default(CoroutineContext var0, Function2 var1, int var2, Object var3) throws InterruptedException {
        return BuildersKt__BuildersKt.runBlocking$default(var0, var1, var2, var3);
    }
    // context 为 EmptyCoroutineContext 对象 ， block 为 CoroutineKt$main$1 对象 
    public static final Object runBlocking(@NotNull CoroutineContext context, @NotNull Function2 block) throws InterruptedException {
        // 调用 runBlocking 方法 
        return BuildersKt__BuildersKt.runBlocking(context, block);
    }
}

final class BuildersKt__BuildersKt {
    // 调用 runBlocking$default 方法 var0 为 null ,var1 为 CoroutineKt$main$1 对象 ，var2 为 1 ，var3 为 null 
    // $FF: synthetic method
    public static Object runBlocking$default(CoroutineContext var0, Function2 var1, int var2, Object var3) throws InterruptedException {
        // var2 为 1 ,var0 为 EmptyCoroutineContext 对象 
        if ((var2 & 1) != 0) {
            var0 = (CoroutineContext) EmptyCoroutineContext.INSTANCE;
        }
        // 调用 BuildersKt.runBlocking()方法 
        return BuildersKt.runBlocking(var0, var1);
    }
}

// 继承 SuspendLambda 实现了 Function2 函数 
final class CoroutineKt$main$1 extends SuspendLambda implements Function2 {
    int label;
    // $FF: synthetic field
    private Object L$0;
    // 构造函数 $completion 为 null 
    CoroutineKt$main$1(Continuation $completion) {
        super(2, $completion);
    }
    // 实现 BaseContinuationImpl invokeSuspend 方法
    @Nullable
    public final Object invokeSuspend(@NotNull Object var1) {
        IntrinsicsKt.getCOROUTINE_SUSPENDED();
        switch (this.label) {
            case 0:
                ResultKt.throwOnFailure(var1);
                CoroutineScope $this$runBlocking = (CoroutineScope)this.L$0;
                BuildersKt.launch$default($this$runBlocking, (CoroutineContext)null, (CoroutineStart)null, (Function2)(new CoroutineKt$main$1$1((Continuation)null)), 3, (Object)null);
                System.out.println("Hello");
                return Unit.INSTANCE;
            default:
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }
    }
    // 覆写 BaseContinuationImpl create 方法
    @NotNull
    public final Continuation create(@Nullable Object value, @NotNull Continuation $completion) {
        CoroutineKt$main$1 var3 = new CoroutineKt$main$1($completion);
        var3.L$0 = value;
        return (Continuation)var3;
    }
    // 实现 Function2 invoke方法
    @Nullable
    public final Object invoke(@NotNull CoroutineScope p1, @Nullable Continuation p2) {
        return ((CoroutineKt$main$1)this.create(p1, p2)).invokeSuspend(Unit.INSTANCE);
    }
}
// 继承 SuspendLambda 实现了 Function2 函数 
final class CoroutineKt$main$1$1 extends SuspendLambda implements Function2 {
    int label;

    CoroutineKt$main$1$1(Continuation $completion) {
        super(2, $completion);
    }
    // 实现 BaseContinuationImpl invokeSuspend 方法
    @Nullable
    public final Object invokeSuspend(@NotNull Object $result) {
        Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
        switch (this.label) {
            case 0:
                ResultKt.throwOnFailure($result);
                Continuation var10001 = (Continuation)this;
                this.label = 1;
                if (DelayKt.delay(1000L, var10001) == var2) {
                    return var2;
                }
                break;
            case 1:
                ResultKt.throwOnFailure($result);
                break;
            default:
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }

        System.out.println("World!");
        return Unit.INSTANCE;
    }
    // 覆写 BaseContinuationImpl create 方法
    @NotNull
    public final Continuation create(@Nullable Object value, @NotNull Continuation $completion) {
        return (Continuation)(new CoroutineKt$main$1$1($completion));
    }

    // 实现 Function2 invoke方法
    @Nullable
    public final Object invoke(@NotNull CoroutineScope p1, @Nullable Continuation p2) {
        return ((CoroutineKt$main$1$1)this.create(p1, p2)).invokeSuspend(Unit.INSTANCE);
    }
}

SuspendLambda 和 Continuation


 // SuspendLambda 继承 ContinuationImpl
internal abstract class SuspendLambda(
    public override val arity: Int,
    completion: Continuation<Any?>?
) : ContinuationImpl(completion), FunctionBase<Any?>, SuspendFunction {
    constructor(arity: Int) : this(arity, null)
}

// suspend 函数标记接口 
internal interface SuspendFunction
// FunctionBase 函数，只有一个成员变量 arity
public interface FunctionBase<out R> : Function<R> {
    public val arity: Int
}

// ContinuationImpl 继承 BaseContinuationImpl
internal abstract class ContinuationImpl(
    completion: Continuation<Any?>?,
    private val _context: CoroutineContext?
) : BaseContinuationImpl(completion) {
    // 从 Continuation 获取协程上下文
    constructor(completion: Continuation<Any?>?) : this(completion, completion?.context) 

    public override val context: CoroutineContext
        get() = _context!!

    @Transient
    private var intercepted: Continuation<Any?>? = null
    
    public fun intercepted(): Continuation<Any?> =
        intercepted
            ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
                .also { intercepted = it }

    protected override fun releaseIntercepted() {
        val intercepted = intercepted
        if (intercepted != null && intercepted !== this) {
            context[ContinuationInterceptor]!!.releaseInterceptedContinuation(intercepted)
        }
        this.intercepted = CompletedContinuation // just in case
    }
}

// BaseContinuationImpl 继承 Continuation
internal abstract class BaseContinuationImpl(
    public val completion: Continuation<Any?>?
) : Continuation<Any?>, CoroutineStackFrame, Serializable {

    protected abstract fun invokeSuspend(result: Result<Any?>): Any?

    protected open fun releaseIntercepted() {
    }

    public open fun create(completion: Continuation<*>): Continuation<Unit> {
        throw UnsupportedOperationException("create(Continuation) has not been overridden")
    }

    public open fun create(value: Any?, completion: Continuation<*>): Continuation<Unit> {
        throw UnsupportedOperationException("create(Any?;Continuation) has not been overridden")
    }

    public override fun toString(): String =
        "Continuation at ${getStackTraceElement() ?: this::class.java.name}"

    // --- CoroutineStackFrame implementation

    public override val callerFrame: CoroutineStackFrame?
        get() = completion as? CoroutineStackFrame

    public override fun getStackTraceElement(): StackTraceElement? =
        getStackTraceElementImpl()
}


public interface Continuation<in T> {

    public val context: CoroutineContext
    // 一个 resumeWith 方法 
    public fun resumeWith(result: Result<T>)
}

runBlocking 函数

// context 为 EmptyCoroutineContext 对象 ， block 为 CoroutineKt$main$1 对象 
public actual fun <T> runBlocking(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    // 获取当前线程对象
    val currentThread = Thread.currentThread()
    // 从 context 获取 ContinuationInterceptor 对象 ，
    // 由于 context 为 EmptyCoroutineContext 对象，所以 contextInterceptor 为 空 
    val contextInterceptor = context[ContinuationInterceptor]
    val eventLoop: EventLoop?
    val newContext: CoroutineContext
    if (contextInterceptor == null) {
        // 创建获取 EventLoop 对象 
        eventLoop = ThreadLocalEventLoop.eventLoop
        // 生成新的协程上下文 ，EmptyCoroutineContext 空上下文 + EventLoop 为 EventLoop 
        newContext = GlobalScope.newCoroutineContext(context + eventLoop)
    } else {
        eventLoop = (contextInterceptor as? EventLoop)?.takeIf { it.shouldBeProcessedFromContext() }
            ?: ThreadLocalEventLoop.currentOrNull()
        newContext = GlobalScope.newCoroutineContext(context)
    }
    // 创建 BlockingCoroutine 对象 
    val coroutine = BlockingCoroutine<T>(newContext, currentThread, eventLoop)
    // 调用 BlockingCoroutine start 方法
    coroutine.start(CoroutineStart.DEFAULT, coroutine, block)
    // 调用 joinBlocking 方法 
    return coroutine.joinBlocking()
}

BlockingEventLoop

internal object ThreadLocalEventLoop {
    private val ref = commonThreadLocal<EventLoop?>(Symbol("ThreadLocalEventLoop"))
     // ref.get() 默认为 null ,调用 createEventLoop() 方法 
    internal val eventLoop: EventLoop
        get() = ref.get() ?: createEventLoop().also { ref.set(it) }

    internal fun currentOrNull(): EventLoop? =
        ref.get()

    internal fun resetEventLoop() {
        ref.set(null)
    }

    internal fun setEventLoop(eventLoop: EventLoop) {
        ref.set(eventLoop)
    }
}

// 创建 BlockingEventLoop()对象 
internal actual fun createEventLoop(): EventLoop = BlockingEventLoop(Thread.currentThread())

// BlockingEventLoop 继承 EventLoopImplBase
internal class BlockingEventLoop(
    override val thread: Thread
) : EventLoopImplBase()

// EventLoopImplBase 继承 EventLoopImplPlatform 实现 Delay
internal abstract class EventLoopImplBase: EventLoopImplPlatform(), Delay {
}

// EventLoopImplPlatform 继承 EventLoop
internal expect abstract class EventLoopImplPlatform() : EventLoop {
    protected fun unpark()

    protected fun reschedule(now: Long, delayedTask: EventLoopImplBase.DelayedTask)
}

// EventLoop 继承 CoroutineDispatcher
internal abstract class EventLoop : CoroutineDispatcher() {}

// CoroutineDispatcher 继承 AbstractCoroutineContextElement，ContinuationInterceptor
public abstract class CoroutineDispatcher :
    AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor {}
    
public abstract class AbstractCoroutineContextElement(public override val key: Key<*>) : Element

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

BlockingCoroutine


// parentContext 是 BlockingEventLoop 元素的协程上下文 
// blockedThread 是运行 runBlocking 方法的线程 
// eventLoop 就是 BlockingEventLoop 对象 
private class BlockingCoroutine<T>(
    parentContext: CoroutineContext,
    private val blockedThread: Thread,
    private val eventLoop: EventLoop?
) : AbstractCoroutine<T>(parentContext, true, true) {
    
}
// 协程对象，协程对象本身是实现了 Continuation 接口的 
public abstract class AbstractCoroutine<in T>(
    parentContext: CoroutineContext,
    initParentJob: Boolean, // initParentJob 为 true
    active: Boolean // active 为 true
) : JobSupport(active), Job, Continuation<T>, CoroutineScope {

    init {
        if (initParentJob) initParentJob(parentContext[Job])
    }
}

public open class JobSupport constructor(active: Boolean) : Job, ChildJob, ParentJob {
    
}

public interface Job : CoroutineContext.Element {
}

public interface ChildJob : Job {
    public fun parentCancelled(parentJob: ParentJob)
}

public interface ParentJob : Job {
    public fun getChildJobCancellationCause(): CancellationException
}

调用 start 方法

// start 为 CoroutineStart.DEFAULT 
// receiver 是 BlockingCoroutine 对象 
// block 为 CoroutineKt$main$1 对象 
 public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
     start(block, receiver, this)
 }

public enum class CoroutineStart {
    // CoroutineStart.DEFAULT	
 	public operator fun <R, T> invoke(block: suspend R.() -> T, receiver: R, completion: Continuation<T>): Unit =
        when (this) {
            // receiver 是 BlockingCoroutine 对象 ，completion 也是 BlockingCoroutine 对象
            DEFAULT -> block.startCoroutineCancellable(receiver, completion)
            ATOMIC -> block.startCoroutine(receiver, completion)
            UNDISPATCHED -> block.startCoroutineUndispatched(receiver, completion)
            LAZY -> Unit // will start lazily
        }

}

// receiver 是 BlockingCoroutine 对象 ，completion 也是 BlockingCoroutine 对象
internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(
    receiver: R, completion: Continuation<T>,
) = runSafely(completion) {
    createCoroutineUnintercepted(receiver, completion).intercepted().resumeCancellableWith(Result.success(Unit))
}

// completion 是 BlockingCoroutine 对象 
// block 为 函数对象 
private inline fun runSafely(completion: Continuation<*>, block: () -> Unit) {
    try {
        block() // 调用函数 
    } catch (e: Throwable) {
        dispatcherFailure(completion, e)
    }
}
// 抛出异常
private fun dispatcherFailure(completion: Continuation<*>, e: Throwable) {
    completion.resumeWith(Result.failure(e))
    throw e
}

// receiver 是 BlockingCoroutine 对象 ，completion 也是 BlockingCoroutine 对象
public actual fun <R, T> (suspend R.() -> T).createCoroutineUnintercepted(
    receiver: R,
    completion: Continuation<T>
): Continuation<Unit> {
    val probeCompletion = probeCoroutineCreated(completion)
    //  this 为 CoroutineKt$main$1 对象 属于 BaseContinuationImpl 子类 
    return if (this is BaseContinuationImpl)
       // 调用 CoroutineKt$main$1 create 方法 
        create(receiver, probeCompletion)
    else {
        createCoroutineFromSuspendFunction(probeCompletion) {
            (this as Function2<R, Continuation<T>, Any?>).invoke(receiver, it)
        }
    }
}

创建 CoroutineKt$main$1 对象

    // value 是 BlockingCoroutine 对象 ，$completion 也是 BlockingCoroutine 对象
    public final Continuation create(@Nullable Object value, @NotNull Continuation $completion) {
       // 创建 CoroutineKt$main$1 对象 
        CoroutineKt$main$1 var3 = new CoroutineKt$main$1($completion);
        var3.L$0 = value; // BlockingCoroutine 对象
        return (Continuation)var3;
    }

CoroutineKt$main$1 对象调用 intercepted() 方法

public actual fun <T> Continuation<T>.intercepted(): Continuation<T> =
    (this as? ContinuationImpl)?.intercepted() ?: this
    

// 调用 ContinuationImpl ，intercepted() 方法 
public fun intercepted(): Continuation<Any?> =
    intercepted
        // 由于构造函数里面传递了 BlockingCoroutine 对象 
        // 获取协程上下 ContinuationInterceptor 会得到 BlockingEventLoop 对象 ，
        // 调用 interceptContinuation 方法
        ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
            .also { intercepted = it }

// BlockingEventLoop 对象 interceptContinuation 方法 ，返回 DispatchedContinuation 对象 
public final override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> = DispatchedContinuation(this, continuation)
        
 // DispatchedContinuation 构造函数        
// dispatcher 为 BlockingEventLoop 对象 ，continuation 为 CoroutineKt$main$1 对象 
internal class DispatchedContinuation<in T>(
    @JvmField internal val dispatcher: CoroutineDispatcher,
    @JvmField val continuation: Continuation<T>
) : DispatchedTask<T>(MODE_UNINITIALIZED), CoroutineStackFrame, Continuation<T> by continuation {

// resumeMode 为 MODE_UNINITIALIZED
internal abstract class DispatchedTask<in T> internal constructor(
    @JvmField var resumeMode: Int
) : SchedulerTask()

internal expect abstract class SchedulerTask internal constructor() : Runnable


internal actual typealias SchedulerTask = Task

DispatchedContinuation 调用 resumeCancellableWith 方法

     // result为 Result.success(Unit)
    public fun <T> Continuation<T>.resumeCancellableWith(
        result: Result<T>,
    ): Unit = when (this) {
        // 调用 DispatchedContinuation 的 resumeCancellableWith 方法 
        is DispatchedContinuation -> resumeCancellableWith(result)
        else -> resumeWith(result)
    }
    
     // result为 Result.success(Unit)
     internal inline fun resumeCancellableWith(result: Result<T>) {
        val state = result.toState() // state 为 Unit 对象 
        // 默认为 true
        if (dispatcher.isDispatchNeeded(context)) {
            _state = state
            resumeMode = MODE_CANCELLABLE 
            // 调用  BlockingEventLoop 对象 dispatch 方法 
            dispatcher.dispatch(context, this)
        } else {
            executeUnconfined(state, MODE_CANCELLABLE) {
                if (!resumeCancelled(state)) {
                    resumeUndispatchedWith(result)
                }
            }
        }
    }
    // context BlockingCoroutine 对象的 协程上下文 ，block 为 DispatchedContinuation 本身是 Runnable 对象 
    final override fun dispatch(context: CoroutineContext, block: Runnable 对象 ) = enqueue(block)

     // Runnable 添加到队列 
    open fun enqueue(task: Runnable) {
        enqueueDelayedTasks()
        if (enqueueImpl(task)) {
            unpark()
        } else {
            DefaultExecutor.enqueue(task)
        }
    }
    

private fun enqueueDelayedTasks() {
    // _delayed 默认为 null 
    val delayed = _delayed.value
    if (delayed != null && !delayed.isEmpty) {
        val now = nanoTime()
        while (true) {
            delayed.removeFirstIf {
                if (it.timeToExecute(now)) {
                    enqueueImpl(it)
                } else
                    false
            } ?: break
        }
    }
}

  private fun enqueueImpl(task: Runnable): Boolean {
        // _queue 默认为空 
        _queue.loop { queue ->
            // _isCompleted 默认为 false 
            if (isCompleted) return false 
            when (queue) {
                // _queue 设置为 DispatchedContinuation 对象 ,返回 ture 
                null -> if (_queue.compareAndSet(null, task)) return true
                is Queue<*> -> {
                    when ((queue as Queue<Runnable>).addLast(task)) {
                        Queue.ADD_SUCCESS -> return true
                        Queue.ADD_CLOSED -> return false
                        Queue.ADD_FROZEN -> _queue.compareAndSet(queue, queue.next())
                    }
                }
                else -> when {
                    queue === CLOSED_EMPTY -> return false
                    else -> {
                        val newQueue = Queue<Runnable>(Queue.INITIAL_CAPACITY, singleConsumer = true)
                        newQueue.addLast(queue as Runnable)
                        newQueue.addLast(task)
                        if (_queue.compareAndSet(queue, newQueue)) return true
                    }
                }
            }
        }
    }


    protected actual fun unpark() {
        val thread = thread // atomic read
        // 都是主线程，表达式为 false 
        if (Thread.currentThread() !== thread)
            unpark(thread)
    }

BlockingCoroutine.joinBlocking()

fun joinBlocking(): T {
    registerTimeLoopThread()
    try {
        eventLoop?.incrementUseCount()
        try {
            while (true) {
                // 如何线程中断了， 抛出异常 ，取消协程 
                if (Thread.interrupted()) throw InterruptedException().also { cancelCoroutine(it) }
                // 调用 BlockingEventLoop 对象 processNextEvent 方法 
                val parkNanos = eventLoop?.processNextEvent() ?: Long.MAX_VALUE
                if (isCompleted) break
                // parkNanos 第一次返回 0 ，0不会阻塞，再次进行 while 循环 
                parkNanos(this, parkNanos)
            }
        } finally { // paranoia
            eventLoop?.decrementUseCount()
        }
    } finally { // paranoia
        unregisterTimeLoopThread()
    }
    // now return result
    val state = this.state.unboxState()
    (state as? CompletedExceptionally)?.let { throw it.cause }
    return state as T
}


override fun processNextEvent(): Long {
    // processUnconfinedEvent 返回 false 
    if (processUnconfinedEvent()) return 0
    // queue all delayed tasks that are due to be executed
    enqueueDelayedTasks()
    //  取之前添加的 Runnable 对象 ,为 DispatchedContinuation 对象 
    val task = dequeue()
    // task 不为 null 
    if (task != null) {
        // 调用 DispatchedContinuation 对象  run 方法 
        platformAutoreleasePool { task.run() }
        return 0
    }
    return nextTime
}

fun processUnconfinedEvent(): Boolean {
    // unconfinedQueue 默认为 null ,返回 false
    val queue = unconfinedQueue ?: return false
    val task = queue.removeFirstOrNull() ?: return false
    task.run()
    return true
}

// 取出 Runnable 对象  
private fun dequeue(): Runnable? {
    _queue.loop { queue ->
        when (queue) {
            null -> return null
            is Queue<*> -> {
                val result = (queue as Queue<Runnable>).removeFirstOrNull()
                if (result !== Queue.REMOVE_FROZEN) return result as Runnable?
                _queue.compareAndSet(queue, queue.next())
            }
            // queue 为 为 DispatchedContinuation 对象   
            else -> when {
                queue === CLOSED_EMPTY -> return null
                // _queue 设置为 null ,返回 DispatchedContinuation 对象 
                else -> if (_queue.compareAndSet(queue, null)) return queue as Runnable
            }
        }
    }
}

//  DispatchedContinuation 对象 run 方法 
final override fun run() {
    assert { resumeMode != MODE_UNINITIALIZED }
    var fatalException: Throwable? = null
    try {
        // delegate 为this ，DispatchedContinuation 对象
        val delegate = delegate as DispatchedContinuation<T>
        // continuation 为  CoroutineKt$main$1 对象
        val continuation = delegate.continuation 
        withContinuationContext(continuation, delegate.countOrElement) {
            val context = continuation.context
            val state = takeState() // state 为 Unit 对象
            val exception = getExceptionalResult(state) // exception 为 null 
            // resumeMode 为 MODE_CANCELLABLE
            val job = if (exception == null && resumeMode.isCancellableMode) context[Job] else null
            // job 为 BlockingCoroutine 对象 ，job.isActive 为 true 
            if (job != null && !job.isActive) {
                val cause = job.getCancellationException()
                cancelCompletedResult(state, cause)
                continuation.resumeWithStackTrace(cause)
            } else {
                if (exception != null) {
                    continuation.resumeWithException(exception)
                } else {
                     // getSuccessfulResult(state) 为 Unit
                    continuation.resume(getSuccessfulResult(state))
                }
            }
        }
    } catch (e: Throwable) {
        // This instead of runCatching to have nicer stacktrace and debug experience
        fatalException = e
    } finally {
        fatalException?.let { handleFatalException(it) }
    }
}
// value 为 Unit 
public inline fun <T> Continuation<T>.resume(value: T): Unit =
    resumeWith(Result.success(value))

// result 为 Result<Unit> ,CoroutineKt$main$1 对象
public final override fun resumeWith(result: Result<Any?>) {
    var current = this
    var param = result 
    while (true) {
        probeCoroutineResumed(current)
        // current 为 CoroutineKt$main$1 对象
        with(current) {
            // completion 是 BlockingCoroutine 对象
            val completion = completion!!
            val outcome: Result<Any?> =
                try {
                    // 调用 invokeSuspend 方法 ，返回 Unit 对象 
                    val outcome = invokeSuspend(param) //  param 为 Result<Unit>
                    if (outcome === COROUTINE_SUSPENDED) return
                    Result.success(outcome)
                } catch (exception: Throwable) {
                    Result.failure(exception)
                }
            releaseIntercepted() 
            if (completion is BaseContinuationImpl) {
                current = completion
                param = outcome
            } else {
                // 调用 BlockingCoroutine 对象的 resumeWith 方法 进行判断协程是否完成了 
                completion.resumeWith(outcome)
                return
            }
        }
    }
}

执行 invokeSuspend 函数，打印 Hello

@Nullable
public final Object invokeSuspend(@NotNull Object var1) { // var1 为 Result<Unit>
    IntrinsicsKt.getCOROUTINE_SUSPENDED();
    // this.label 初始化值为 0 
    switch (this.label) {
        case 0:
            ResultKt.throwOnFailure(var1);
            // this.L$0 是 BlockingCoroutine 对象
            CoroutineScope $this$runBlocking = (CoroutineScope)this.L$0;
            // 启动新的协程
            BuildersKt.launch$default($this$runBlocking, (CoroutineContext)null, (CoroutineStart)null, (Function2)(new CoroutineKt$main$1$1((Continuation)null)), 3, (Object)null);
            // 执行真的函数，先打印 Hello
            System.out.println("Hello");
            // 返回 Unit 对象 
            return Unit.INSTANCE;
        default:
            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
    }
}

// var0 为 BlockingCoroutine 对象 ，var1 为 null ,var2 为 null 
// var3 为 CoroutineKt$main$1$1 对象 var4 为 3 ，var5 为 null
public static Job launch$default(CoroutineScope var0, CoroutineContext var1, CoroutineStart var2, Function2 var3, int var4, Object var5) {
    return BuildersKt__Builders_commonKt.launch$default(var0, var1, var2, var3, var4, var5);
}

// var0 为 BlockingCoroutine 对象 ，var1 为 null ,var2 为 null 
// var3 为 CoroutineKt$main$1$1 对象 var4 为 3 ，var5 为 null
public static Job launch$default(CoroutineScope var0, CoroutineContext var1, CoroutineStart var2, Function2 var3, int var4, Object var5) {
    // 表达式为 true 
    if ((var4 & 1) != 0) {
        var1 = (CoroutineContext) EmptyCoroutineContext.INSTANCE;
    }
    // 表达式为 true 
    if ((var4 & 2) != 0) {
        var2 = CoroutineStart.DEFAULT;
    }

    return BuildersKt.launch(var0, var1, var2, var3);
}


// $this$launch 为 BlockingCoroutine 对象 ，context 为 EmptyCoroutineContext 
// start 为 CoroutineStart.DEFAULT , block 为 CoroutineKt$main$1$1 对象 
public static final Job launch(@NotNull CoroutineScope $this$launch, @NotNull CoroutineContext context, @NotNull CoroutineStart start, @NotNull Function2 block) {
    return BuildersKt__Builders_commonKt.launch($this$launch, context, start, block);
}

// context 为 EmptyCoroutineContext ，start 为 CoroutineStart.DEFAULT 
// block 为 CoroutineKt$main$1$1 对象 
public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    // context 为 EmptyCoroutineContext 对象 ，newContext 为 BlockingCoroutine 对象的coroutineContext  
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy) // start.isLazy 为 false 
        LazyStandaloneCoroutine(newContext, block) else
        // 创建 StandaloneCoroutine 对象 
        StandaloneCoroutine(newContext, active = true)
    // 调用 StandaloneCoroutine start 方法     
    coroutine.start(start, coroutine, block)
    return coroutine
}


private open class StandaloneCoroutine(
    parentContext: CoroutineContext,
    active: Boolean
) : AbstractCoroutine<Unit>(parentContext, initParentJob = true, active = active) {
    override fun handleJobException(exception: Throwable): Boolean {
        handleCoroutineException(context, exception)
        return true
    }
}

StandaloneCoroutine 也是 AbstractCoroutine 对象，上面分析过 BlockingCoroutine 对象 start ，流程是一样的最终调到 CoroutineKt$main$1$1 invokeSuspend 方法

public final Object invokeSuspend(@NotNull Object $result) {
    Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
    switch (this.label) { // this.label 默认为 0 
        case 0:
            ResultKt.throwOnFailure($result);
            Continuation var10001 = (Continuation)this;
            this.label = 1; // this.label 设置为 1
            // 调用 delay 函数 ，会返回 COROUTINE_SUSPENDED 
            if (DelayKt.delay(1000L, var10001) == var2) {
                return var2; 
            }
            break;
        case 1:
            ResultKt.throwOnFailure($result);
            break;
        default:
            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
    }

    System.out.println("World!");
    return Unit.INSTANCE;
}

delay 是 suspend 函数

public suspend fun delay(timeMillis: Long) {
    if (timeMillis <= 0) return // don't delay
    return suspendCancellableCoroutine sc@ { cont: CancellableContinuation<Unit> ->
        if (timeMillis < Long.MAX_VALUE) {
            // 会获取到协程上下文中的 ContinuationInterceptor 作为 Delay 对象
            // 也就是 BlockingEventLoop 对象，实现了 Delay 接口 
            cont.context.delay.scheduleResumeAfterDelay(timeMillis, cont)
        }
    }
}

internal val CoroutineContext.delay: Delay get() = get(ContinuationInterceptor) as? Delay ?: DefaultDelay

// 会调到 BlockingEventLoop 的 scheduleResumeAfterDelay 方法 
override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
    val timeNanos = delayToNanos(timeMillis)
    if (timeNanos < MAX_DELAY_NS) {
        val now = nanoTime() // 获取当前时间
        // 创建 DelayedResumeTask 对象 
        DelayedResumeTask(now + timeNanos, continuation).also { task ->
            schedule(now, task) // 调用 schedule 方法 
            continuation.disposeOnCancellation(task)
        }
    }
}


private inner class DelayedResumeTask(
    nanoTime: Long,
    private val cont: CancellableContinuation<Unit>
) : DelayedTask(nanoTime) {
    override fun run() { with(cont) { resumeUndispatched(Unit) } }
    override fun toString(): String = super.toString() + cont.toString()
}

internal abstract class DelayedTask(
    @JvmField var nanoTime: Long
) : Runnable, Comparable<DelayedTask>, DisposableHandle, ThreadSafeHeapNode, SynchronizedObject() 
{}

fun schedule(now: Long, delayedTask: DelayedTask) {
    when (scheduleImpl(now, delayedTask)) { // 调用 scheduleImpl 方法 返回 SCHEDULE_OK
        SCHEDULE_OK -> if (shouldUnpark(delayedTask)) unpark()
        SCHEDULE_COMPLETED -> reschedule(now, delayedTask)
        SCHEDULE_DISPOSED -> {} // do nothing -- task was already disposed
        else -> error("unexpected result")
    }
}

private fun scheduleImpl(now: Long, delayedTask: DelayedTask): Int {
    if (isCompleted) return SCHEDULE_COMPLETED
    // _delayed 默认为空 
    val delayedQueue = _delayed.value ?: run {
        // 初始化延时执行任务队列
        _delayed.compareAndSet(null, DelayedTaskQueue(now))
        _delayed.value!!
    }
    return delayedTask.scheduleTask(now, delayedQueue, this)
}

fun scheduleTask(now: Long, delayed: DelayedTaskQueue, eventLoop: EventLoopImplBase): Int = synchronized<Int>(this) {
    if (_heap === DISPOSED_TASK) return SCHEDULE_DISPOSED 
    // 把 delayedTask 添加到延时队列 DelayedTaskQueue 中  
    delayed.addLastIf(this) { firstTask ->
        if (eventLoop.isCompleted) return SCHEDULE_COMPLETED 
        // firstTask 默认 为空 
        if (firstTask == null) {
                
            delayed.timeNow = now
        } else {
            val firstTime = firstTask.nanoTime
            val minTime = if (firstTime - now >= 0) now else firstTime
            if (minTime - delayed.timeNow > 0) delayed.timeNow = minTime
        }
        if (nanoTime - delayed.timeNow < 0) nanoTime = delayed.timeNow
        true
    }
    // 返回 SCHEDULE_OK
    return SCHEDULE_OK
}

BlockingCoroutine.joinBlocking()

while 循环继续执行 processNextEvent() 会拿到 nextTime 下一个延时队列队头的距离当前时间的值，
然后进行 LockSupport.parkNanos() 进行阻塞，
当阻塞时间到后会唤醒再次调用 processNextEvent()
enqueueDelayedTasks() 因为时间已经到了，会把延时任务加入到 _queue 队列中进行执行
最终会再次调用 CoroutineKt$main$1$1 对象的 invokeSuspend 方法打印 World!
当 task 和延时的 task 都为空时协程结束运行

override val nextTime: Long
    get() {
        if (super.nextTime == 0L) return 0L
        val queue = _queue.value
        when {
            queue === null -> {} // empty queue -- proceed
            queue is Queue<*> -> if (!queue.isEmpty) return 0 // non-empty queue
            queue === CLOSED_EMPTY -> return Long.MAX_VALUE // no more events -- closed
            else -> return 0 // non-empty queue
        }
        // 获取延时队列的时间 ，1000 毫秒 
        val nextDelayedTask = _delayed.value?.peek() ?: return Long.MAX_VALUE
        return (nextDelayedTask.nanoTime - nanoTime()).coerceAtLeast(0)
    }


public final Object invokeSuspend(@NotNull Object $result) {
    Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
    // 由于上次已经调用过一次  this.label 为 1 了 
    switch (this.label) {
        case 0:
            ResultKt.throwOnFailure($result);
            Continuation var10001 = (Continuation)this;
            this.label = 1;
            if (DelayKt.delay(1000L, var10001) == var2) {
                return var2;
            }
            break;
        case 1:
            ResultKt.throwOnFailure($result);
            break;
        default:
            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
    }
    // 阻塞 1000 毫秒后会打印 World!
    System.out.println("World!");
    return Unit.INSTANCE;
}

总结

上面代码比较复杂，总结起来就是以下运行逻辑

runBlocking 函数 block 对象打包为一个 Runnable 对象放入到 BlockingEventLoop 对象的任务队列中

 // 第一个 Runnable 对象
{ 
    launch { 
        delay(1000L) 
        println("World!") 
    }
    println("Hello") 
}

然后开启一个 while 循环，去读取 BlockingEventLoop 任务队列，执行第一个 Runnable 对象
- 碰到 launch 会开启一个协程又包装成第二个 Runnable 对象放入到 BlockingEventLoop 的任务队列里，请注意并没有立即执行，所有并不会阻塞 Hello 的打印
```
     // 第二个 Runnable 对象
    { 
        delay(1000L) 
        println("World!") 
    }
    
```
- 然后打印 Hello
- while 循环再次去读取 BlockingEventLoop 任务队列执行第二个 Runnable 对象，此时第二个 Runnable对象 this.label 为 0
- 当执行到 delay 函数时会创建一个延时 1000 毫秒的任务（还是第二个 Runnable 对象)添加到 BlockingEventLoop 延时任务队列并且会把第二个Runnable 对象成员变量 this.label 更改为 1
- 当阻塞时间到了 1000 毫秒时，会把延时任务列表添加到任务列表中进行执行，再次执行第二个 Runnable 对象
- 当再次执行第二个 Runnable 对象，情况有了变化，this.label = 1 ，只会执行打印 World! ，而不会再次 delay
- 当BlockingEventLoop 任务队列执行完成退出 while 循环程序结束