2024年鸿蒙最全launch原理解析_createcoroutinefromsuspendfunction，2024年最新HarmonyOS鸿蒙 400道面试题通关宝典助你进大厂

2401_84853434

于 2024-05-15 06:47:53 发布

阅读量1k

点赞数 23

分类专栏：程序员文章标签：鸿蒙面试学习

本文链接：https://blog.csdn.net/2401_84853434/article/details/138886913

版权

程序员专栏收录该内容

106 篇文章 0 订阅

订阅专栏

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

本章就从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是我们的main()函数，反编译后逻辑不会变化。
注释2是block变量，注意这里block在Kotlin代码中的类型是 suspend () -> String，然后根据CPS转换(这里也可以看成是一个挂起函数，毕竟和挂起函数类型是一样的，都是高阶函数类型)类型是(Continuation< String>) -> Any?，所以这里block的类型是Function1。
注释3就是testCoroutine()方法了，根据Kotlin的顶层函数语法，原来的block.startCoroutine(continuation)就变成了ContinuationKt.startCoroutine(block,continuaiton)，这个函数调用原理后面细说。
注释4就是block具体实现类实例，首先我们可以看一下其中的方法：首先是注释5的invokeSuspend()函数，这个在之前说挂起函数原理时说过，这个是ContinuationImpl中定义的方法，而ContinuationImpl是Continuation的子类，所以其实现类既是Function1接口的实现类，也是Continuation子类。而这里的注释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())


**深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

![](https://img-blog.csdnimg.cn/direct/743b668910224b259a5ffe804fa6d0db.png)
![img](https://img-blog.csdnimg.cn/img_convert/a0a1f2f2d0dbbc63e8e4c1da53e74ef9.png)
![img](https://img-blog.csdnimg.cn/img_convert/f9258fe51e5e6b44fd92fecd7dac6342.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618636735)**

极易碰到天花板技术停滞不前！**

![](https://img-blog.csdnimg.cn/direct/743b668910224b259a5ffe804fa6d0db.png)
[外链图片转存中...(img-nl7zffOp-1715726851196)]
[外链图片转存中...(img-INLEZyDz-1715726851196)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618636735)**

2401_84853434

关注

23
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
2024年鸿蒙最全launch原理解析_createcoroutinefromsuspendfunction，2024年最新HarmonyOS鸿蒙 400道面试题通关宝典助你进大厂

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

扫一扫