首页 > 资讯 > 移动开发 >Kotlin挂起函数原理示例剖析

915

分享到

Kotlin挂起函数原理示例剖析

Kotlin挂起函数 Kotlin函数 2022-11-13 14:11:57 915人浏览八月长安

摘要

目录一、序言二、CPS原理CPS参数变化CPS返回值变化三、挂起函数的反编译四、伪挂起函数五、多个挂起函数前后关联六、在Java中调用suspend函数七、总结一、序言 Kotlin

一、序言

Kotlin挂起函数平时在学习和工作中用的比较多，掌握其原理还是很有必要的。本文将一步一步带着大家分析其原理实现。

ps: 文中所用的Kotlin版本是1.7.0。

二、CPS原理

在某个Kotlin函数的前面加个suspend函数，它就成了挂起函数（虽然内部不一定会挂起，内部不挂起的称为伪挂起函数）。

先随便写个挂起函数

suspend fun getUserName(): String {
    delay(1000L)
    return "云天明"
}

然后通过Android Studio的Tools->Kotlin->Show Kotlin Bytecode->Decompile，现在我们拿到了Kotlin字节码反编译之后的Java代码：

public static final Object getUserName(@NotNull Continuation var0) {
    ...
}

可以看到该函数被编译之后，多了一个Continuation参数，其次，返回值变成了Object。下面，我们详细来讨论一下这2种变化：函数参数和函数返回值。

CPS参数变化

上面的suspend fun getUserName(): String函数，如果我在Java中调用的话，会看到Android Studio提示我们

从图中可以看到，新增了一个参数，也就是Continuation，它其实是一个Callback，只是换了个名字而已。

来看下它的定义：


@SinceKotlin("1.3")
public interface Continuation&lt;in T&gt; {
    
    public val context: CoroutineContext
    
    public fun resumeWith(result: Result&lt;T&gt;)
}

这个Callback接口会在resumeWith回调结果给外部。

CPS返回值变化

在上面的Continuation接口的定义中，其实还有个小细节，它带了个泛型T。这个泛型T就是我们suspend函数返回值的类型，上面的getUserName返回值是String，编译之后，这个String就来到了Continuation的泛型中。

而getUserName编译之后的返回值变成了Object。为啥是Object？它有什么用？这个返回值其实是用来标识该函数是否挂起的标志，如果返回值是Intrinsics.COROUTINE_SUSPENDED，那么说明该函数被挂起了（挂起函数的结果不是通过函数返回值来获取的，而是通过Continuation，也就是Callback回调得到的结果）。

如果该函数是伪挂起函数（里面没有其他挂起函数，但还是会进行CPS转换），则是直接返回结果。

举个例子，下面这个就是真正的挂起函数：

suspend fun getUserName(): String {
    delay(1000L)
    return "云天明"
}

当执行到delay的时候，就会返回Intrinsics.COROUTINE_SUSPENDED表示该函数被挂起了。

下面这个则是伪挂起函数：

suspend fun getName():String {
    return "程心"
}

这种伪挂起函数不会返回Intrinsics.COROUTINE_SUSPENDED，而是直接返回结果，它不会被挂起。它看起来就仅仅是一个普通函数，但还是会进行CPS转换，CPS转换只认suspend关键字。你如果像上面这样写，其实Android Studio也会提示你，说这个suspend关键字没用，叫你把它移除掉。

所以，suspend函数编译之后的返回值变成了Object，因为要兼容伪挂起函数的返回值，而伪挂起函数可能返回任何值，而且还可能为空。

下面我们就来详细的探索一下挂起函数的底层原理，看看挂起函数反编译之后是什么样子。

三、挂起函数的反编译

我们先写个很简单的suspend函数，然后将其反编译，然后分析一下。具体的流程是我们用Android Studio写个挂起函数的demo，然后编译成apk，然后将apk用jadx反编译一下，拿到对应class的反编译Java源码，这样弄出来的源码我感觉比直接通过Android Studio的Tools->Kotlin->Show Kotlin拿到的源码稍微好看懂一些。

首先，我创建了一个CpsTest.kt文件，然后在里面写了一个函数：

package com.xfhy.coroutine
import kotlinx.coroutines.delay
suspend fun getUserName(): String {
    delay(1000L)
    return "云天明"
}

就这样，一个很普通的挂起函数，在内部只是简单调用了下delay，延迟1000L，再返回结果“云天明”。虽然这个函数很简单，但反编译出来的代码却有点多，而且不好看懂，我先把原代码贴出来，待会儿再放我重新组织过的代码，作为对比：

public final class CpsTestKt {
   @Nullable
   public static final Object getUserName(@NotNull Continuation var0) {
      Object $continuation;
      label20: {
         if (var0 instanceof <undefinedtype>) {
            $continuation = (<undefinedtype>)var0;
            if ((((<undefinedtype>)$continuation).label & Integer.MIN_VALUE) != 0) {
               ((<undefinedtype>)$continuation).label -= Integer.MIN_VALUE;
               break label20;
            }
         }
         $continuation = new ContinuationImpl(var0) {
            // $FF: synthetic field
            Object result;
            int label;
            @Nullable
            public final Object invokeSuspend(@NotNull Object $result) {
               this.result = $result;
               this.label |= Integer.MIN_VALUE;
               return CpsTestKt.getUserName(this);
            }
         };
      }
      Object $result = ((<undefinedtype>)$continuation).result;
      Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
      switch(((<undefinedtype>)$continuation).label) {
      case 0:
         ResultKt.throwOnFailure($result);
         ((<undefinedtype>)$continuation).label = 1;
         if (DelayKt.delay(1000L, (Continuation)$continuation) == var3) {
            return var3;
         }
         break;
      case 1:
         ResultKt.throwOnFailure($result);
         break;
      default:
         throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }
      return "云天明";
   }
}

这反编译之后的东西不太好看懂，我重新组织了一下：

public final class CpsTestKt {
    public static final Object getUserName(Continuation<? super java.lang.String> continuation) {
        //这个TestContinuation实质上是一个匿名内部类，这里给它取个名字而已
        final class TestContinuation extends ContinuationImpl {
            //协程状态机当前的状态
            int label;
            //保存invokeSuspend回调时吐出来的返回结果
            Object result;
            TestContinuation(Continuation continuation) {
                super(continuation);
            }
            //invokeSuspend比较重要，它是状态机的入口，会将执行流程交给getUserName再次调用
            //协程的本质，就是CPS+状态机
            public final Object invokeSuspend(Object obj) {
                //callback回调时会把结果带出来
                this.result = obj;
                this.label |= Integer.MIN_VALUE;
                //开启协程状态机
                return CpsTestKt.getUserName(this);
            }
        }
        TestContinuation testContinuation;
        label20:
        {
            //不是第一次进入，则走这里，把continuation转成TestContinuation，TestContinuation只会生成一个实例，不会每次都生成。
            if (continuation instanceof TestContinuation) {
                testContinuation = (TestContinuation) continuation;
                if ((testContinuation.label & Integer.MIN_VALUE) != 0) {
                    testContinuation.label -= Integer.MIN_VALUE;
                    break label20;
                }
            }
            //如果是第一次进入getUserName，则TestContinuation还没被创建，会走到这里，此时先去创建一个TestContinuation
            testContinuation = new TestContinuation(continuation);
        }
        //将之前执行的结果取出来
        Object $result = testContinuation.result;
        //挂起的标志,如果需要挂起的话,就返回这个flag
        Object flag = IntrinsicsKt.getCOROUTINE_SUSPENDED();
        //状态机
        switch (testContinuation.label) {
            case 0:
                // 检测异常
                ResultKt.throwOnFailure($result);
                //将label的状态改成1,方便待会儿执行delay后面的代码
                testContinuation.label = 1;
                //0. 调用DelayKt.delay函数
                //1. 将testContinuation传了进去
                //2. DelayKt.delay是一个挂起函数，正常情况下，它会立马返回一个值：IntrinsicsKt.COROUTINE_SUSPENDED（也就是这里的flag），表示该函数已被挂起，这里就直接return了，该函数被挂起
                //3. 恢复执行：在DelayKt.delay内部，到了指定的时间后就会调用testContinuation这个Callback的invokeSuspend
                //4. invokeSuspend中又将执行getUserName函数，同时将之前创建好的testContinuation传入其中，开始执行后面的逻辑(label为1的逻辑)，该函数继续往后面执行(也就是恢复执行)
                if (DelayKt.delay(1000L, testContinuation) == flag) {
                    return flag;
                }
                break;
            case 1:
                // 检测异常
                ResultKt.throwOnFailure($result);
                //label 1这里没有return,而是会走到下面的return "云天明"语句
                break;
            default:
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }
        return "云天明";
    }
}

在getUserName函数中，会多出一个ContinuationImpl的子类，它是一个匿名内部类（为了方便，给它取了个名字TestContinuation），也是整个协程挂起函数的核心。在这个TestContinuation中有2个变量

label: 协程状态机当前的状态
result: 保存invokeSuspend回调时吐出来的返回结果

invokeSuspend是一个抽象方法，当协程从挂起状态想要恢复时，就得调用这个invokeSuspend，然后继续走状态机逻辑，继续执行后面的代码。具体是怎么调用这个invokeSuspend的，后面有机会再细说。暂时我们只要知道，这里是恢复的入口就行。invokeSuspend内部会把结果（这个结果可能是正常的结果，也可能是Exception）取出来，开启协程状态机。

分析完TestContinuation，再来看一下第一次进入getUserName是怎么走的。

首先，第一次进入时，continuation肯定不是TestContinuation，因为此时还没有new过TestContinuation实例，所以会走到创建TestContinuation的逻辑，并且会把continuation包进去。
然后刚创建完的testContinuation的label未赋其他值，那就是初始值0了。那么switch状态机那里，就走case 0，先把label改成1，因为马上就要挂起了，待会儿恢复时需要执行下一个状态的代码。
调用Kotlin的库函数delay，它是一个挂起函数，将testContinuation传入其中，方便它进行invokeSuspend回调。调用挂起函数，那么它可能会返回COROUTINE_SUSPENDED，表示它已经被挂起了，如果是挂起了那么getUserName就走完了，到时会从invokeSuspend恢复。在还没有恢复的时候，这个协程所在的线程可以去做其他事情。

恢复的时候，又开始从头走getUserName，此时的continuation已经是TestContinuation，不会重新创建。它的label之前已经被改成1了的，所以switch状态机那里，会走到case 1，先检测一下有没有异常，没有异常就返回真正的返回值了“云天明”。

分析到这里也就完了，上面就是一个非常简单的挂起函数的反编译分析的整个过程。下面我们简单分析一下伪挂起函数会带来什么效果。

四、伪挂起函数

在之前的CpsTest.kt里面简单改一下

suspend fun fakeSuspendFun() = "维德"
suspend fun getUserName(): String {
    println(fakeSuspendFun())
    return "云天明"
}

像fakeSuspendFun这种就是伪挂起函数，平时不建议像fakeSuspendFun这么写，即使写了，Android Studio也会提示你，这suspend关键字没用，内部没有挂起。它内部没有挂起的逻辑，但是它有suspend关键字，那么Kotlin编译器依然会给它做CPS转换。

public final class CpsTestKt {
   @Nullable
   public static final Object fakeSuspendFun(@NotNull Continuation<? super java.lang.String> $completion) {
      return "维德";
   }
   @Nullable
   public static final Object getUserName(@NotNull Continuation<? super java.lang.String> continuation) {
    final class TestContinuation extends ContinuationImpl {
        int label;
        Object result;
        TestContinuation(Continuation continuation) {
            super(continuation);
        }
        public final Object invokeSuspend(Object obj) {
            this.result = obj;
            this.label |= Integer.MIN_VALUE;
            return CpsTestKt.getUserName(this);
        }
    }
    TestContinuation testContinuation;
    label20:
    {
        if (continuation instanceof TestContinuation) {
            testContinuation = (TestContinuation) continuation;
            if ((testContinuation.label & Integer.MIN_VALUE) != 0) {
                testContinuation.label -= Integer.MIN_VALUE;
                break label20;
            }
        }
        testContinuation = new TestContinuation(continuation);
    }
      Object $result = testContinuation.result;
      Object flag = IntrinsicsKt.getCOROUTINE_SUSPENDED();
      //变化在这里，这个变量用来存储fakeSuspendFun的返回值
      Object var10000;
      switch(testContinuation.label) {
      case 0:
         ResultKt.throwOnFailure($result);
         testContinuation.label = 1;
         var10000 = fakeSuspendFun((Continuation)$continuation);
         if (var10000 == flag) {
            //如果是挂起，那么直接返回COROUTINE_SUSPENDED
            return flag;
         }
         //显然，这里是不会挂起的，会走这里的break
         break;
      case 1:
         ResultKt.throwOnFailure($result);
         var10000 = $result;
         break;
      default:
         throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }
      //走这里
      Object var1 = var10000;
      System.out.println(var1);
      return "云天明";
   }
}

在调用伪挂起函数时，不会挂起，它不会返回COROUTINE_SUSPENDED，而是继续往下走。

五、多个挂起函数前后关联

平时在工作中，可能经常会有多个挂起函数前后是关联的,后面一个挂起函数需要前面一个挂起函数的结果来干点事情，比上面只有一个getUserName挂起函数稍微复杂些，我们来分析一下。

比如我们拿到一个需求，展示我的朋友圈，假设获取流程如下：获取用户id->根据用户id获取该用户的好友列表->获取好友列表每个人的朋友圈。下面是非常简单的实现：

//需求: 获取用户id->根据用户id获取该用户的好友列表->获取好友列表每个人的朋友圈
suspend fun showMoments() {
    println("start")
    val userId = getUserId()
    println(userId)
    val friendList = getFriendList(userId)
    println(friendList)
    val feedList = getFeedList(userId, friendList)
    println(feedList)
}
suspend fun getUserId(): String {
    delay(1000L)
    return "1sa13124daadar2"
}
suspend fun getFriendList(userId: String): String {
    println("正在获取${userId}的朋友列表")
    delay(1000L)
    return "云天明, 维德"
}
suspend fun getFeedList(userId: String, list: String): String {
    println("获取${userId}的朋友圈($list)")
    delay(1000L)
    return "云天明: 酒好喝吗？烟好抽吗？即使是可口可乐，第一次尝也不好喝，让人上瘾的东西都是这样;\n维德: 前进！前进！！不择手段地前进！！！"
}

它的执行结果如下：

start
1sa13124daadar2
正在获取1sa13124daadar2的朋友列表
云天明, 维德
获取1sa13124daadar2的朋友圈(云天明, 维德)
云天明: 酒好喝吗？烟好抽吗？即使是可口可乐，第一次尝也不好喝，让人上瘾的东西都是这样;
维德: 前进！前进！！不择手段地前进！！！
end

这段代码要稍微复杂一些，这些挂起函数前后关联，前面获取到的数据后面的挂起函数需要使用到。相应的，它们反编译之后也要复杂一些。但是没关系，我已经把晦涩难懂的代码重新组装了一下，方便大家阅读。同时，在下面的代码中，每一步在走哪个分支，都有详细的注释分析，帮助大家理解。

public final class TestSuspendKt {
   @Nullable
   public static final Object showMoments(@NotNull Continuation<? super Unit> continuation) {
      ShowMomentsContinuation showMomentsContinuation;
      label37: {
         if (continuation instanceof ShowMomentsContinuation) {
            //非第一次进showMoments，则走这里，continuation已经是ShowMomentsContinuation了
            showMomentsContinuation = (ShowMomentsContinuation)continuation;
            if ((showMomentsContinuation.label & Integer.MIN_VALUE) != 0) {
               showMomentsContinuation.label -= Integer.MIN_VALUE;
               break label37;
            }
         }
         //第一次，走这里，初始化ShowMomentsContinuation，将传入的continuation包起来
         showMomentsContinuation = new ShowMomentsContinuation(continuation);
         final class ShowMomentsContinuation extends ContinuationImpl {
            int label;
            Object result;
            //存放临时数据
            Object tempData;
            ShowMomentsContinuation(Continuation continuation) {
                super(continuation);
            }
            public final Object invokeSuspend(Object obj) {
                this.result = obj;
                this.label |= Integer.MIN_VALUE;
                return CpsTestKt.getUserName(this);
            }
        }
      }
      //存放每个函数的返回结果，临时放一下
      Object computeResult;
      label31: {
         String userId;
         Object flag;
         label30: {
            //从continuation中把result取出来
            Object $result = showMomentsContinuation.result;
            flag = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            switch(showMomentsContinuation.label) {
            case 0:
               //第一次，走这里，检测异常
               ResultKt.throwOnFailure($result);
               System.out.println("start");
               //将label改成1
               showMomentsContinuation.label = 1;
               //执行getUserId函数，computeResult用来接收返回值
               computeResult = getUserId((Continuation)showMomentsContinuation);
               //getUserId是挂起函数，不出意外的话，computeResult的值会是COROUTINE_SUSPENDED，这里就直接return了
               //showMoments函数这一次执行，就算完成了。
               //恢复执行时，会走ShowMomentsContinuation 的invokeSuspend，走下面label等于1的逻辑
               if (computeResult == flag) {
                  return flag;
               }
               break;
            case 1:
               //第二次执行showMoments时，label已经等于1了，走这里. 
               ResultKt.throwOnFailure($result);
               computeResult = $result;
               break;
            case 2:
               //第三次执行showMoments时，label已经等于2了，走这里. 
               //先将之前暂存的userId取出来，马上需要用到
               userId = (String)showMomentsContinuation.tempData;
               ResultKt.throwOnFailure($result);
               computeResult = $result;
               break label30;
            case 3:
               //第四次执行showMoments时，label已经等于3了，走这里. 
               ResultKt.throwOnFailure($result);
               computeResult = $result;
               break label31;
            default:
               throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            //第二次执行showMoments时，label=1，会走到这里来,将getUserId函数回调回来的userId保存起来，并输出
            userId = (String)computeResult;
            System.out.println(userId);
            //将userId放continuation里面暂存起来
            showMomentsContinuation.tempData = userId;
            //又要执行挂起函数了，这里将label改成2
            showMomentsContinuation.label = 2;
            //开始调用getFriendList
            computeResult = getFriendList(userId, (Continuation)showMomentsContinuation);
            //getFriendList是挂起函数，不出意外的话，computeResult的值会是COROUTINE_SUSPENDED，这里就直接return了
            //showMoments函数这一次执行，就算完成了。
            //恢复执行时，会走ShowMomentsContinuation 的invokeSuspend，走上面label等于2的逻辑
            if (computeResult == flag) {
               return flag;
            }
         }
         //第三次执行showMoments时，label=2，会走到这里来,将getFriendList函数回调回来的friendList输出
         String friendList = (String)computeResult;
         System.out.println(friendList);
         showMomentsContinuation.tempData = null;
         //又要执行挂起函数了，这里将label改成3
         showMomentsContinuation.label = 3;
         //开始调用getFeedList
         computeResult = getFeedList(userId, friendList, (Continuation)showMomentsContinuation);
         //getFeedList是挂起函数，不出意外的话，computeResult的值会是COROUTINE_SUSPENDED，这里就直接return了
         //showMoments函数这一次执行，就算完成了。
         //恢复执行时，会走ShowMomentsContinuation 的invokeSuspend，走上面label等于3的逻辑
         if (computeResult == flag) {
            return flag;
         }
      }
      //第四次执行showMoments时，label=3，会走到这里来,将getFeedList函数回调回来的feedList输出
      String feedList = (String)computeResult;
      System.out.println(feedList);
      System.out.println("end");
      //showMoments函数这一次执行，就算完成了。
      //没有剩下的挂起函数需要执行了
      return Unit.INSTANCE;
   }
    //因为getUserId、getFriendList、getFeedList中的匿名内部类逻辑与showMoments中的一模一样，故没有将其重新组织语言
   @Nullable
   public static final Object getUserId(@NotNull Continuation var0) {
      Object $continuation;
      label20: {
        //这里的<undefinedtype>就是在getUserId函数里生成的new ContinuationImpl匿名内部类
         if (var0 instanceof <undefinedtype>) {
            $continuation = (<undefinedtype>)var0;
            if ((((<undefinedtype>)$continuation).label & Integer.MIN_VALUE) != 0) {
               ((<undefinedtype>)$continuation).label -= Integer.MIN_VALUE;
               break label20;
            }
         }
         $continuation = new ContinuationImpl(var0) {
            // $FF: synthetic field
            Object result;
            int label;
            @Nullable
            public final Object invokeSuspend(@NotNull Object $result) {
               this.result = $result;
               this.label |= Integer.MIN_VALUE;
               return TestSuspendKt.getUserId(this);
            }
         };
      }
      Object $result = ((<undefinedtype>)$continuation).result;
      Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
      switch(((<undefinedtype>)$continuation).label) {
      case 0:
         //第一次执行getUserId时，走这里
         ResultKt.throwOnFailure($result);
         //马上要开始执行挂起函数了，label先改一下
         ((<undefinedtype>)$continuation).label = 1;
         //执行delay，正常情况下，会返回COROUTINE_SUSPENDED，于是getUserId这一次就执行完了，return了
         //恢复时会回调上面的匿名内部类$continuation中的invokeSuspend
         if (DelayKt.delay(1000L, (Continuation)$continuation) == var3) {
            return var3;
         }
         break;
      case 1:
         //第二次执行getUserId时，也就是delay执行完回来，走这里
         ResultKt.throwOnFailure($result);
         break;
      default:
         throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }
      //拿到数据，getUserId就算真正的执行完了，接着会去执行showMoments函数中的ShowMomentsContinuation#invokeSuspend，也就是恢复showMoments,继续执行showMoments中getUserId后面的逻辑
      return "1sa13124daadar2";
   }
   @Nullable
   public static final Object getFriendList(@NotNull String userId, @NotNull Continuation var1) {
      Object $continuation;
      label20: {
         if (var1 instanceof <undefinedtype>) {
            $continuation = (<undefinedtype>)var1;
            if ((((<undefinedtype>)$continuation).label & Integer.MIN_VALUE) != 0) {
               ((<undefinedtype>)$continuation).label -= Integer.MIN_VALUE;
               break label20;
            }
         }
         $continuation = new ContinuationImpl(var1) {
            // $FF: synthetic field
            Object result;
            int label;
            @Nullable
            public final Object invokeSuspend(@NotNull Object $result) {
               this.result = $result;
               this.label |= Integer.MIN_VALUE;
               return TestSuspendKt.getFriendList((String)null, this);
            }
         };
      }
      Object $result = ((<undefinedtype>)$continuation).result;
      Object var5 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
      switch(((<undefinedtype>)$continuation).label) {
      case 0:
         ResultKt.throwOnFailure($result);
         String var2 = "正在获取" + userId + "的朋友列表";
         System.out.println(var2);
         ((<undefinedtype>)$continuation).label = 1;
         if (DelayKt.delay(1000L, (Continuation)$continuation) == var5) {
            return var5;
         }
         break;
      case 1:
         ResultKt.throwOnFailure($result);
         break;
      default:
         throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }
      return "云天明, 维德";
   }
   @Nullable
   public static final Object getFeedList(@NotNull String userId, @NotNull String list, @NotNull Continuation var2) {
      Object $continuation;
      label20: {
         if (var2 instanceof <undefinedtype>) {
            $continuation = (<undefinedtype>)var2;
            if ((((<undefinedtype>)$continuation).label & Integer.MIN_VALUE) != 0) {
               ((<undefinedtype>)$continuation).label -= Integer.MIN_VALUE;
               break label20;
            }
         }
         $continuation = new ContinuationImpl(var2) {
            // $FF: synthetic field
            Object result;
            int label;
            @Nullable
            public final Object invokeSuspend(@NotNull Object $result) {
               this.result = $result;
               this.label |= Integer.MIN_VALUE;
               return TestSuspendKt.getFeedList((String)null, (String)null, this);
            }
         };
      }
      Object $result = ((<undefinedtype>)$continuation).result;
      Object var6 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
      switch(((<undefinedtype>)$continuation).label) {
      case 0:
         ResultKt.throwOnFailure($result);
         String var3 = "获取" + userId + "的朋友圈(" + list + ')';
         System.out.println(var3);
         ((<undefinedtype>)$continuation).label = 1;
         if (DelayKt.delay(1000L, (Continuation)$continuation) == var6) {
            return var6;
         }
         break;
      case 1:
         ResultKt.throwOnFailure($result);
         break;
      default:
         throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }
      return "云天明: 酒好喝吗？烟好抽吗？即使是可口可乐，第一次尝也不好喝，让人上瘾的东西都是这样;\n维德: 前进！前进！！不择手段地前进！！！";
   }
}

观察源码，发现一些东西：

每个挂起函数都有一个匿名内部类，继承ContinuationImpl，在invokeSuspend中开启状态机
每个挂起函数都经过了CPS转换
在挂起之后，当前执行协程的这个线程其实是空闲的，没有代码交给它执行。在invokeSuspend恢复之后，才继续执行
每个挂起函数，都有一个状态机
挂起函数中的逻辑被分块执行（也就是状态机那块的逻辑），分块的数量=挂起函数数量+1

基本上来说，挂起函数的实现原理就是上面这些了。

六、在Java中调用suspend函数

既然Kotlin是兼容Java的，那么如果我想在Java里面调用Kotlin的suspend函数按道理也是可以的。那具体如何调用呢？

就拿上面的案例举例，假设我想在Activity中点击某个按钮时调用showMoments这个suspend函数，该怎么搞？大家先思考一下，稍后给出答案。

//将上面的案例加了个返回值
suspend fun showMoments(): String {
    println("start")
    val userId = getUserId()
    println(userId)
    val friendList = getFriendList(userId)
    println(friendList)
    val feedList = getFeedList(userId, friendList)
    println(feedList)
    println("end")
    return feedList
}

因为showMoments函数有suspend关键字，那么最终会经过CPS转换，有一个Continuation参数。在Java中调用showMoments时，肯定需要把Continuation传进去才行。Continuation是一个接口，需要传个实现类过去，把getContext和resumeWith实现起。

TestSuspendKt.showMoments(new Continuation<String>() {
    @NonNull
    @Override
    public CoroutineContext getContext() {
        return (CoroutineContext) Dispatchers.getIO();
    }
    @Override
    public void resumeWith(@NonNull Object result) {
        //这里的result就是showMoments的返回值
        Log.d("xfhy666", "" + result);
    }
});

Java中调用挂起函数，看起来就像是调用了一个方法，这个方法需要传一个callback过去，这个方法的返回值是通过回调给出来的，并且可以自定义该方法运行在哪个线程中。

七、总结

好了，今天的Kotlin挂起函数就分析到这里，基本上谜团已全部解开(除了invokeSuspend是在什么时候回调的，后面有机会再和大家分享)。

Kotlin的挂起函数，本质上就是：CPS+状态机。

CPS：挂起函数比普通函数多了suspend关键字，Kotlin编译器会对其特殊处理。将该函数转换成一个带有Callback的函数，Callback就是Continuation接口，它的泛型就是原来函数的返回值类型。转换之后的返回值类型是Any?，因为加了suspend关键字的不一定会被挂起，挂起的话返回Intrinsics.COROUTINE_SUSPENDED，伪挂起函数（里面没有其他挂起函数，但还是会进行CPS转换）则是直接返回结果，这个结果可以是任何类型，所以返回值只能是Any?。
状态机：当挂起函数经过编译之后，会变成switch和label组成的状态机结构。label代表了当前状态机的具体状态，每改变一次，就代表挂起函数被调用一次。在里面会创建一个Callback接口，当挂起之后，挂起函数的结果返回是通过Callback回调回来的，回调回来之后，因为之前修改过label，根据该label来判断该继续往下走了，执行后面的逻辑。上面的Callback就是Continuation，我觉得它在这里的意思可以翻译成继续执行剩余的代码。

以上就是Kotlin挂起函数原理示例剖析的详细内容，更多关于Kotlin挂起函数的资料请关注编程网其它相关文章！

--结束END--

本文标题: Kotlin挂起函数原理示例剖析

本文链接: https://lsjlt.com/news/171771.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341