Kotlin协程suspend的理解

suspend修饰符，它可以告诉编译器，该函数需要在协程中执行。作为开发者，您可以把挂起函数看作是普通函数，只不过它可能会在某些时刻挂起和恢复而已。协程的挂起就是退出方法，等到一定条件到来会重新执行这个方法，因为对方有这个协程的引用，当然可以调用你的方法了。

普通函数不可以调用挂起函数。因为挂起函数有有一个隐形的参数Continuation，普通方法没有办法传Continuation参数，Continuation可以简单理解成java中的Callback。

suspend修饰的方法不一定真的可以挂起，只要这个方法接收到COROUTINE_SUSPENDED结果，就表示可以挂起了，即退出方法。

// 一个普通方法
private fun doFun1() {println("doFun1")
}// 一个suspend修饰的方法，但是方法内没有挂起点，方法体可普通方法一样，但是多一个Continuation参数
private suspend fun doSuspendFun1(p1: Int) {println("doSuspendFun1")
}// 方法中用了delay方法，delay方法返回了COROUTINE_SUSPENDED
// 表示doSuspendFun2方法在执行完delay方法后就会退出
private suspend fun doSuspendFun2(p1: Int, p2: Int) {delay(1000)println("doSuspendFun2")
}fun main() {GlobalScope.launch {println("launch")doSuspendFun2(1, 1)}
}

launch方法的参数block就是一个suspend CoroutineScope.() -> Unit类型的方法。

我们看下转换成java后的代码

doFun1方法没有什么变化

private static final void doFun1() {System.out.println("doFun1");
}

doSuspendFun1方法不仅多了一个参数Continuation，还多了一个返回值Object类型，这就是为什么普通函数不能调用挂起函数，因为无法传递Continuation参数。返回值是Object，因为可以返回COROUTINE_SUSPENDED，也可以返回String，返回值就是协程的返回值，所以返回值的类型无法确定。因为内部没有使用挂起函数，内部的逻辑就和普通方法一样，就是多一个参数和一个返回结果。

private static final Object doSuspendFun1(int p1, Continuation $completion) {System.out.println("doSuspendFun1");return Unit.INSTANCE;
}

来看一下比较复杂的doSuspendFun2方法，内部使用了delay方法。就会有挂起点，所谓挂起点就是label，很多文章叫这个为状态机。执行到一个挂起点，label的值就会加1，等下次恢复的时候，switch就会知道从哪开始执行了。

   private static final Object doSuspendFun2(int var0, int var1, Continuation var2) {// Continuation都是从上一个挂起函数中传进来的，并不是当前对象，所以才会重新创建new doSuspendFun2.1(var2)// 防止直接使用外面的的协程var2，影响到var2。doSuspendFun2.1 $continuation;label20: {// if (var2 instanceof doSuspendFun2.1) {$continuation = (doSuspendFun2.1)var2;if (($continuation.label & Integer.MIN_VALUE) != 0) {$continuation.label -= Integer.MIN_VALUE;break label20;}}// 就是下面的 Test14Kt$doSuspendFun2$1$continuation = new doSuspendFun2.1(var2);}Object $result = $continuation.result;// 它的值就是 COROUTINE_SUSPENDEDObject var5 = IntrinsicsKt.getCOROUTINE_SUSPENDED();switch ($continuation.label) {case 0:ResultKt.throwOnFailure($result);$continuation.getContext();// label加1$continuation.label = 1;if (DelayKt.delay(1000L, $continuation) == var5) {// delay返回 COROUTINE_SUSPENDED，所以直接退出方法return var5;}break;case 1:ResultKt.throwOnFailure($result);break;default:throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");}System.out.println("doSuspendFun2");// 没有返回值，默认就是 Unitreturn Unit.INSTANCE;}

协程中的Continuation这样理解成java中的Callback，应该简单了吧

挂起方法doSuspendFun2最后被编译成一个对象，继承ContinuationImpl

final class Test14Kt$doSuspendFun2$1 extends ContinuationImpl {// $FF: synthetic fieldObject result;int label;Test14Kt$doSuspendFun2$1(Continuation $completion) {super($completion);}@Nullablepublic final Object invokeSuspend(@NotNull Object $result) {this.result = $result;this.label |= Integer.MIN_VALUE;return Test14Kt.access$doSuspendFun2(0, 0, (Continuation)this);}
}

suspend修饰的方法中如果使用了挂起函数，并且挂起函数可以返回COROUTINE_SUSPENDED，jvm就会创建一个继承自ContinuationImpl的类，这个类的invokeSuspend方法就是在执行这个挂起方法（此时已经被转换成java的普通方法了）。

我们再看看main函数里面的launch处的方法。

final class Test14Kt$main$1 extends SuspendLambda implements Function2 {int label;Test14Kt$main$1(Continuation $completion) {super(2, $completion);}@Nullablepublic final Object invokeSuspend(@NotNull Object $result) {Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();switch (this.label) {case 0:ResultKt.throwOnFailure($result);System.out.println("launch");Continuation var10002 = (Continuation)this;this.label = 1;// 注意把当前对象传给 doSuspendFun2了，这就是Continuation再传递     if (Test14Kt.access$doSuspendFun2(1, 1, var10002) == var2) {// 如果doSuspendFun2方法返回COROUTINE_SUSPENDED，也会退出invokeSuspend方法return var2;}break;case 1:ResultKt.throwOnFailure($result);break;default:throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");}return Unit.INSTANCE;}@NotNullpublic final Continuation create(@Nullable Object value, @NotNull Continuation $completion) {return (Continuation)(new Test14Kt$main$1($completion));}@Nullablepublic final Object invoke(@NotNull CoroutineScope p1, @Nullable Continuation p2) {return ((Test14Kt$main$1)this.create(p1, p2)).invokeSuspend(Unit.INSTANCE);}
}

suspend CoroutineScope.() -> Unit会被编译继承SuspendLambda的一个类。