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

(0)

相关推荐

  • Kotlin 使用高阶函数实现回调方式

    lambda 和 高阶函数 之前学习了 lambda 和高阶函数,然后在 android 开发中对 onClick 事件进行监听是一个很常用的功能,kotlin 的常规实现如下: rootView.setOnClickListener { view -> println("点击了这个ID=${view.id}的view") } 然后在开发中不可避免的我们也要写一些自定义监听之类的代码.这个时候如果还用 java 的思想去实现的话就有点舍近求远了. java 思想实现 在 java

  • Kotlin中的sam(函数式接口)详解

    用lambda表达式去表示java中的匿名类实例 在使用java去给一个按钮设置监听我们通常会通过创建匿名类实例,如下 Button.setOnClickListener(new OnClickListener()){ @Override public void onClick(View v){ Toast.makeText(this,"Hello World",Toast.LENGTH_LONG).show() } } 在kotlin我们可以通过传递一个lambda表达式去代替这个实

  • Kotlin 扩展函数和扩展属性的使用方法

    Kotlin 能够扩展一个类的新功能而无需继承该类或者使用像装饰者这样的设计模式. 这通过叫做 扩展 的特殊声明完成. 例如,你可以为一个你不能修改的.来自第三方库中的类编写一个新的函数. 这个新增的函数就像那个原始类本来就有的函数一样,可以用普通的方法调用. 这种机制称为 扩展函数 .此外,也有 扩展属性 , 允许你为一个已经存在的类添加新的属性. 前言 作为安卓开发,我们常常碰到这样的场景,需要把以dp为单位的值转化为以px为单位.这时候我们常会写一个Utils类,比如说 public cl

  • 利用 kotlin 的方式自定义回调事件(kotlin函数参数)

    java 中自定义回调事件的写法 创建 interface类,创建 interface 对象,实现 set 方法: 使用: kotlin 中自定义点击事件写法 依照 java 的思想(不推荐) 创建 interface类,创建 interface 可变对象(var) 使用: 利用 kotlin 函数作为参数(强烈推荐) 来看一下系统的点击事件在 kotlin 中是什么样的: 是不是简直简洁到不像话?再看看你自己定义的点击事件回调,感觉跟还在用 java 开发一样- 下面就来看个新的写法: 创建一

  • Kotlin作用域函数之间的区别和使用场景详解

    作用域函数 Kotlin 的作用域函数有五种:let.run.with.apply 以及 also. 这些函数基本上做了同样的事情:在一个对象上执行一个代码块. 下面是作用域函数的典型用法: val adam = Person("Adam").apply { age = 20 city = "London" } println(adam) 如果不使用 apply 来实现,每次给新创建的对象属性赋值时就必须重复其名称. val adam = Person("

  • Kotlin实现在类里面创建main函数

    1.创建在class块外面: class Test{ } /** 我是main入口函数 **/ fun main(args: Array<String>) { var test=Test(); } 这样是一种方式,但是细心的童鞋可能会发现一个问题,目录里面的文件图标是灰色的,而且这种写法看上去怪怪的,有强迫症的可能会接受不了: 2.创建在class里面: class Test{ companion object { /** 我是main入口函数 **/ @JvmStatic fun main(

  • oracle中的一些常用函数及示例

    前言 学习oracle也有一段时间了,发现oracle中的函数好多,对于做后台的程序猿来说,大把大把的时间还要学习很多其他的新东西,再把这些函数也都记住是不太现实的,所以总结了一下oracle中的一些常用函数及示例,一是为了和大家分享,二是可以在以后工作中忘记了随时查阅.废话不多说,下面直接上函数. 一.单行函数 只处理单个行,并且为每行返回一个结果. 1.字符函数 (1)concat(str1,str2)字符串拼接函数 select concat('Hello ','World') from

  • Python 异步协程函数原理及实例详解

    这篇文章主要介绍了Python 异步协程函数原理及实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一. asyncio 1.python3.4开始引入标准库之中,内置对异步io的支持 2.asyncio本身是一个消息循环 3.步骤: (1)创建消息循环 (2)把协程导入 (3)关闭 4.举例: import threading # 引入异步io包 import asyncio # 使用协程 @ asyncio.coroutine def

  • Python partial函数原理及用法解析

    这篇文章主要介绍了Python partial函数原理及用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 介绍 partial其实是Python模块functools中定义的一个函数,当我们需要经常调用某个函数时,但是其中某些参数是已知的固定值,这样可能会让代码显得冗余,这个时候就可以考虑使用partial函数. 使用 假设我们要做二进制转十进制 int('1000000', base=2) # 64 int('1010101', bas

  • python next()和iter()函数原理解析

    这篇文章主要介绍了python next()和iter()函数原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 我们首先要知道什么是可迭代的对象(可以用for循环的对象)Iterable: 一类:list,tuple,dict,set,str 二类:generator,包含生成器和带yield的generatoe function 而生成器不但可以作用于for,还可以被next()函数不断调用并返回下一个值,可以被next()函数不断返回

  • python sorted函数原理解析及练习

    这篇文章主要介绍了python sorted函数原理解析及练习,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 前两天学习了一下socket编程,在向某大神请教问题时被嫌弃了,有一种还没学会走就想跑的感觉.大神说我现在的水平应该去做一些像是操作文件.序列号等的小练习来加深理解.下面是他给我出的小练习: 1.datas = [['sherry',19,'female'],['flora',21,'female'],['june',15,'femal

  • mysql自定义函数原理与用法实例分析

    本文实例讲述了mysql自定义函数原理与用法.分享给大家供大家参考,具体如下: 本文内容: 什么是函数 函数的创建 函数的调用 函数的查看 函数的修改 函数的删除 首发日期:2018-04-18 什么是函数: 函数存储着一系列sql语句,调用函数就是一次性执行这些语句.所以函数可以降低语句重复.[但注意的是函数注重返回值,不注重执行过程,所以一些语句无法执行.所以函数并不是单纯的sql语句集合.] mysql函数有自己的自定义函数(已经定义好了的函数),想了解更多的可以参考我的另一篇博文:mys

  • c++回调之利用函数指针示例

    c++回调之利用函数指针示例 复制代码 代码如下: #include <iostream>using namespace std; /************************************************************************//*                下层实现: CALLBACK                                        *//**********************************

  • Kotlin 内联函数详解及实例

    Kotlin 内联函数详解及实例 概述 在说内联函数之前,先说说函数的调用过程. 调用某个函数实际上将程序执行顺序转移到该函数所存放在内存中某个地址,将函数的程序内容执行完后,再返回到转去执行该函数前的地方.这种转移操作要求在转去前要保护现场并记忆执行的地址,转回后先要恢复现场,并按原来保存地址继续执行.也就是通常说的压栈和出栈.因此,函数调用要有一定的时间和空间方面的开销.那么对于那些函数体代码不是很大,又频繁调用的函数来说,这个时间和空间的消耗会很大. 那怎么解决这个性能消耗问题呢,这个时候

  • JavaScript 基础函数_深入剖析变量和作用域

    函数定义和调用 定义函数,在JavaScript中,定义函数的方式如下: function abs(x){ if(x >=0){ return x; }else{ return -x; } } 上述abs() 函数的定义如下: function 指出这是一个函数定义; abs 是函数的名称: (x) 括号内列出函数的参数,多个参数以,分隔: {...}之间的代码是函数体,可以包含若干语句,甚至可以没有任何语句. 注意:函数体内部的语句在执行时,一旦执行到return 时,函数就执行完毕,并将结果

  • 详解Kotlin 高阶函数 与 Lambda 表达式

    详解Kotlin 高阶函数 与 Lambda 表达式 高阶函数(higher-order function)是一种特殊的函数, 它接受函数作为参数, 或者返回一个函数. 这种函数的一个很好的例子就是 lock() 函数, 它的参数是一个锁对象(lock object), 以及另一个函数, 它首先获取锁, 运行对象函数, 然后再释放锁: fun <T> lock(lock: Lock, body: () -> T): T { lock.lock() try { return body()

随机推荐

其他