前言

本章就从Continuation入手来探究一下launch启动协程的原理。

正文

这里我们又回到了Continuation.kt这个文件，因为这是协程框架的基础元素，上一篇文章我们介绍了创建挂起函数的俩个高阶函数就是这个类中的基础层API。除此之外，在这个类，还有启动协程的基础API。

协程启动的基础API

在前面文章我们说过，协程基础元素就像是砖头，其他中间层元素拿到这个砖头来构建一个房子，所以在Continuation.kt中也有2个启动协程的基础API:

//创建协程
public fun <R, T> (suspend R.() -> T).createCoroutine(
    receiver: R,
    completion: Continuation<T>
): Continuation<Unit> =
    SafeContinuation(createCoroutineUnintercepted(receiver, completion).intercepted(), COROUTINE_SUSPENDED)

//启动协程
public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}

这里可以发现createCoroutine{}和startCoroutine{}都是扩展函数，而且扩展的接收者类型是(suspend () -> T)，或许对Kotlin不熟悉的开发者对这个"给函数类型增加扩展"这种写法有点不适应，但是Kotlin中函数就是一等公民，普通类型可以有扩展，那函数类型自然也有。

那上面这个函数该如何使用呢，我们看一下下面代码：

fun main() {
    testStartCoroutine()
    Thread.sleep(2000L)
}

val block = suspend {
    println("Hello!")
    delay(1000L)
    println("World!")
    "Result"
}

private fun testStartCoroutine() {

    val continuation = object : Continuation<String> {
        override val context: CoroutineContext
            get() = EmptyCoroutineContext

        override fun resumeWith(result: Result<String>) {
            println("Result is: ${result.getOrNull()}")
        }
    }

    block.startCoroutine(continuation)
}

• 这里定义了变量名为block的lambda表达式，它的类型是 suspend () -> String，其中lambda表达式最后一行表示返回类型。

• 由于在block中调用了delay(1000)这个挂起函数，所以block也必须是挂起函数类型，这里也就是必须要添加suspend关键字的原因。

• 定义了一个continuation变量，根据前一篇文章我们知道Continuation有2个作用：一种是在实现挂起函数的时候，用于传递挂起函数的执行结果；另一种是在调用挂起函数的时候，以匿名内部类的方式，接收挂起函数的执行结果。而上面代码的作用就是第二种，用来接收挂起函数或者叫做挂起block的lambda或者叫做协程的执行结果。

上面3点是代码的解读，根据之前实现挂起函数原理中的介绍，这里应该有一个Continuation实例对象，然后调用这个对象的resume方法，把结果返回，我们来看一下另一个底层API：createCoroutine{}或许就有了新的理解：

private fun testStartCoroutine() {

    val continuation = object : Continuation<String> {
        override val context: CoroutineContext
            get() = EmptyCoroutineContext

        override fun resumeWith(result: Result<String>) {
            println("Result is: ${result.getOrNull()}")
        }
    }

    val coroutine = block.createCoroutine(continuation)
    coroutine.resume(Unit)
}

可以发现我们这里返回值变量名就叫做coroutine，顾名思义就是一个协程，而这个协程的类型还是Continuation，但是这里并没有启动，只有调用了resume()方法才真正的启动协程。

所以底层基础创建协程API：createCoroutine{}和startCoroutine{}的差别也就是前者没有调用resume()，后者调用了resume()而已。

这里我们又可以猜测，根据挂起函数CPS和状态机原理**，调用continuation的resume方法会触发invokeSuspend()方法进入状态机**，我们下面就来看看startCoroutine()的原理。

startCoroutine{}原理解析

这里我们直接把上面代码进行反编译，可以得到如下代码：

public final class TestCoroutine1Kt {

 //注释1，main()函数
 public static final void main() {
      testStartCoroutine();
      Thread.sleep(2000L);
   }

   public static void main(String[] var0) {
      main();
   }

   //注释2，block变量
   @NotNull
   private static final Function1 block;
   
    @NotNull
   public static final Function1 getBlock() {
      return block;
   }

   //注释3，testStartCoroutine函数
   private static final void testStartCoroutine() {
      //匿名内部类实例，用于接收挂起函数的结果
      <undefinedtype> continuation = new Continuation() {
         @NotNull
         public CoroutineContext getContext() {
            return (CoroutineContext)EmptyCoroutineContext.INSTANCE;
         }

         public void resumeWith(@NotNull Object result) {
            String var2 = "Result is: " + (String)(Result.isFailure-impl(result) ? null : result);
            System.out.println(var2);
         }
      };
      //调用startCoroutine高阶函数
      ContinuationKt.startCoroutine(block, (Continuation)continuation);
   }

   //注释4，block对应的匿名内部类实例
   static {
      Function1 var0 = (Function1)(new Function1((Continuation)null) {
         int label;

         //注释5，进入状态机
         public final Object invokeSuspend(@NotNull Object $result) {
            Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            String var2;
            switch(this.label) {
            case 0:
               ResultKt.throwOnFailure($result);
               var2 = "Hello!";
               System.out.println(var2);
               this.label = 1;
               if (DelayKt.delay(1000L, this) == var3) {
                  return var3;
               }
               break;
            case 1:
               ResultKt.throwOnFailure($result);
               break;
            default:
               throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }

            var2 = "World!";
            System.out.println(var2);
            return "Result";
         }

         //注释6，创建匿名内部类实例
         public final Continuation create(@NotNull Continuation completion) {
            Intrinsics.checkNotNullParameter(completion, "completion");
            Function1 var2 = new <anonymous constructor>(completion);
            return var2;
         }

         //Function1接口的函数调用
         public final Object invoke(Object var1) {
            return ((<undefinedtype>)this.create((Continuation)var1)).invokeSuspend(Unit.INSTANCE);
         }
      });
      block = var0;
   }
}

上面反编译代码较多，我们来按照注释，仔细分析一下：

1. 注释1是我们的main()函数，反编译后逻辑不会变化。
2. 注释2是block变量，注意这里block在Kotlin代码中的类型是 suspend () -> String，然后根据CPS转换(这里也可以看成是一个挂起函数，毕竟和挂起函数类型是一样的，都是高阶函数类型)类型是(Continuation< String>) -> Any?，所以这里block的类型是Function1。
3. 注释3就是testCoroutine()方法了，根据Kotlin的顶层函数语法，原来的block.startCoroutine(continuation)就变成了ContinuationKt.startCoroutine(block,continuaiton)，这个函数调用原理后面细说。
4. 注释4就是block具体实现类实例，首先我们可以看一下其中的方法：首先是注释5的invokeSuspend()函数，这个在之前说挂起函数原理时说过，这个是ContinuationImpl中定义的方法，而ContinuationImpl是Continuation的子类，所以其实现类既是Function1接口的实现类，也是Continuation子类。而这里的注释5，就是进入状态机，开始协程业务逻辑执行。
5. 其次就是注释6的create方法，这里传入一个Continuation类型的completion实例，而且会调用返回整个匿名内部类实例，即这里会返回var0，即block实例。

上面第5点暂时不细说，我们先来看看testStartCoroutine()函数中的startCoroutine()方法：

public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}

这里调用了createCoroutineUnintercepted()方法：

public expect fun <T> (suspend () -> T).createCoroutineUnintercepted(
    completion: Continuation<T>
): Continuation<Unit>

会发现这里是用expect修饰的，即是一种声明，我们需要到协程源代码的JVM实现部分中找到对应的实现：

public actual fun <T> (suspend () -> T).createCoroutineUnintercepted(
    completion: Continuation<T>
): Continuation<Unit> {
    val probeCompletion = probeCoroutineCreated(completion)
    //注释2
    return if (this is BaseContinuationImpl)
        create(probeCompletion)
    else
        createCoroutineFromSuspendFunction(probeCompletion) {
            (this as Function1<Continuation<T>, Any?>).invoke(it)
        }
}

可以发现这也是(suspend () -> T)的扩展函数，所以this其实就是前面代码中的block，而前面说了反编译中block的实现类类型是继承至ContinuationImpl的，所以注释2的第一个if就能返回ture，而这里就是调用create(probeCompletion)函数。

而这个create()方法就是前面反编译中block实现类的create()方法：

@NotNull
public final Continuation create(@NotNull Continuation completion) {
   Intrinsics.checkNotNullParameter(completion, "completion");
   Function1 var2 = new <anonymous constructor>(completion);
   return var2;
}

注意了，这里返回值是Continuation类型对象，即调用完create()方法，其实就对应着协程被创建了，和挂起函数一样，类型是Continuation类型。

所以这里就好办了，根据前面的知识，这时调用resume，便会触发协程体的状态机入口，所以：

public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}

这里的最后调用就是resume(Unit)，调用完resume就会调用continuation的invokeSuspend方法，从而开启协程的执行。

注意上面在resume()方法调用之前，还调用了intercepted()方法，我们简单看一下：

public expect fun <T> Continuation<T>.intercepted(): Continuation<T>

这个方法在Continuation.kt类中，是基础元素，同时也是用expect修饰的，所以我们要去Kotlin源码中找到JVM平台的实现：

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

这里逻辑非常简单，就是将Continuation强转为ContinuationImpl，然后调用它的intercpeted()方法，而前面我们说过block实现类就是这个类的子类，所以强转一定能成功，而这个方法如下：

internal abstract class ContinuationImpl(
    completion: Continuation<Any?>?,
    private val _context: CoroutineContext?
) : BaseContinuationImpl(completion) {

    @Transient
    private var intercepted: Continuation<Any?>? = null

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

这里的逻辑其实就是通过ContinuationInterceptor类来对Continuation进行拦截和处理，而这里的处理其实就是将协程派发到线程上，这部分知识点等我们说Dispatchers时再细说。

所以到这里我们就大致说明白了底层启动协程API的原理，其中block就是一个协程，它的类型必须是suspend类型的，然后本质就是一个内部类，父类是Function1和Continuation，创建完协程就是返回一个内部类实例，而这个实例类型就是Continuation。

然后调用resume方法来触发Continuation进入其状态机。

launch启动协程

其实有了startCoroutine{}这种基础API，中间层的launch、async、runBlocking这些API就是对基础底层API的封装，所以在理解完前面的原理后，这几个API就很好分析了。

我们还是先来看个例子：

fun main() {
    testLaunch()
    Thread.sleep(2000L)
}

private fun testLaunch() {
    val scope = CoroutineScope(Job())
    scope.launch {
        println("Hello!")
        delay(1000L)
        println("World!")
    }
}

这里我们创建了一个scope，然后使用这个scope开启了一个协程，我们直接反编译上面代码，看一下Java代码：

public final class TestCoroutine1Kt {
 
   //注释1 main()函数
   public static final void main() {
      testLaunch();
      Thread.sleep(2000L);
   }

   public static void main(String[] var0) {
      main();
   }

   private static final void testLaunch() {
      //创建scope
      CoroutineScope scope = CoroutineScopeKt.CoroutineScope((CoroutineContext)JobKt.Job$default((Job)null, 1, (Object)null));
      //注释2 开启协程
      BuildersKt.launch$default(scope, (CoroutineContext)null, (CoroutineStart)null, (Function2)(new Function2((Continuation)null) {
         int label;

         //状态机入口
         @Nullable
         public final Object invokeSuspend(@NotNull Object $result) {
            Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            String var2;
            switch(this.label) {
            case 0:
               ResultKt.throwOnFailure($result);
               var2 = "Hello!";
               System.out.println(var2);
               this.label = 1;
               if (DelayKt.delay(1000L, this) == var3) {
                  return var3;
               }
               break;
            case 1:
               ResultKt.throwOnFailure($result);
               break;
            default:
               throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }

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

        //熟悉的create方法
         @NotNull
         public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
            Intrinsics.checkNotNullParameter(completion, "completion");
            Function2 var3 = new <anonymous constructor>(completion);
            return var3;
         }

         public final Object invoke(Object var1, Object var2) {
            return ((<undefinedtype>)this.create(var1, (Continuation)var2)).invokeSuspend(Unit.INSTANCE);
         }
      }), 3, (Object)null);
   }
}

看了上面代码是不是有种熟悉的感觉，尤其是注释2中launch的第三个参数，这里就是和前面block是一样的，创建了一个匿名内部类，所以把上面代码写成下面这种：

private fun testLaunch() {
    val scope = CoroutineScope(Job())
    val block: suspend CoroutineScope.() -> Unit = {
        println("Hello!")
        delay(1000L)
        println("World!")
    }
    scope.launch(block = block)
}

这里的block就是前面基础API中的block类型，所以block就是协程，而本质上仍然是一个Continuation实例。

其实到这里，我们就可以大概猜出，launch和底层API的区别了，不外乎就是加了一些启动配置，我们来看一下launch{}源码，来验证一下：

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    //注释1 上下文
    val newContext = newCoroutineContext(context)
    //注释2 启动模式
    val coroutine = if (start.isLazy)
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    //注释3 启动协程
    coroutine.start(start, coroutine, block)
    return coroutine
}

• 注释1根据传入的CoroutineContext创建出新的Context，注意这里默认是EmptyCoroutineContext，而不是null；
• 注释2是启动模式，也就是之前说的标准模式和懒加载模式；
• 注释3就是启动协程了，我们来跟进看一下。

public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
    start(block, receiver, this)
}

这个方法是AbstractCoroutine这个类中的方法，而这个类很像Java中有Thread.java对应的代表线程的类，我们来看一下这个AbstractCoroutine类：

public abstract class AbstractCoroutine<in T>(
    parentContext: CoroutineContext,
    initParentJob: Boolean,
    active: Boolean
) : JobSupport(active), Job, Continuation<T>, CoroutineScope {

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

可以发现注释2返回的coroutine就是AbstractCoroutine的子类，我们继续跟进start方法，就会进入CoroutineStart.invoke()方法：

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

在这个invoke()方法中，会根据launch传入的启动模式，以不同的方式启动协程。

当我们启动模式是ATOMIC的时候，就会调用block.startCoroutine(completion)，而这个就是前面所研究过的启动协程基础API，绕了一圈容易对接到了。

而对于其他俩个函数：startCoroutineCancellable(completion)和startCoroutineUndispatched(completion)只是在startCoroutine方法上加了一些额外功能，前者表示启动的协程可以响应取消，后者是不会被分发。

而对于默认情况下，我们不传入启动模式，就会执行默认的模式，也就是调用下面方法：

public fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>): Unit = runSafely(completion) {
    createCoroutineUnintercepted(completion).intercepted().resumeCancellableWith(Result.success(Unit))
}

然后下面这个方法也需要去对应的源码中找到：

public actual fun <T> (suspend () -> T).createCoroutineUnintercepted(
    completion: Continuation<T>
): Continuation<Unit> {
    val probeCompletion = probeCoroutineCreated(completion)

    return if (this is BaseContinuationImpl)
        create(probeCompletion)
    else
        createCoroutineFromSuspendFunction(probeCompletion) {
            (this as Function1<Continuation<T>, Any?>).invoke(it)
        }
}

这里就又回到了前面分析基础API的地方了，这里的create方法会调用block对应的匿名内部类的create方法，从而创建协程。

到这里，launch源码就分析完了，可以发现launch其实就是对底层启动协程的基础元素做了一层封装而已，可以让开发者选择上下文以及启动模式。

总结

本篇内容至关重要，我们从协程库底层的基础元素：startCoroutine{}和createCoroutine{}这2个高阶函数入手，可以发现 suspend () -> Unit 类型的block会被编译为FunctionN和Continuation的子类X(代号)，当创建协程时，就是调用其create()方法创建X对象。

而启动协程则是利用Continuation的resume方法，来让X实例调用其invokeSuspend方法进入其内部状态机逻辑，开启协程逻辑。

最后就是launch只是对基础API的封装，让开发者可以灵活选择上下文以及启动模式。