Kotlin挂起函数原理示例剖析

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

一、序言

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,只是换了个名字而已。

来看下它的定义:

/**
 * Interface representing a continuation after a suspension point that returns a value of type `T`.
 */
@SinceKotlin("1.3")
public interface Continuation<in T> {
    /**
     * 当前continuation所在协程的上下文
     */
    public val context: CoroutineContext
    /**
     * 继续执行后面的协程代码,同时把结果回调出去,结果可能是成功或失败
     */
    public fun resumeWith(result: Result<T>)
}

这个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挂起函数的资料请关注我们其它相关文章!

相关文章