反編譯后代碼分析

public final class ExampleUnitTest {
   @Test
   public final void addition_isCorrect() {
      Assert.assertEquals(4L, 4L);

      BuildersKt.launch$default((CoroutineScope)GlobalScope.INSTANCE, (CoroutineContext)null, (CoroutineStart)null, (Function2)(new Function2((Continuation)null) {
         int label;

         @Nullable
         public final Object invokeSuspend(@NotNull Object $result) {
            ExampleUnitTest var10000;
            String var2;
            boolean var3;
            Object var4;
            //對應的標志位
            label34: {
               label33: {
                  var4 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
                  switch(this.label) {
                  case 0:
                     ResultKt.throwOnFailure($result);
                     var2 = "掛起點1開始";
                     var3 = false;
                     System.out.println(var2);
                     this.label = 1;
                     //根據返回值判斷是否為掛起函數，如果為掛起函數直接返回
                     // 掛起函數會持有Continuation，掛起函數執行后調用其resumeWith方法，之后就會回到invokeSuspend中
                     if (DelayKt.delay(1000L, this) ** var4) {
                        //協程退出
                        return var4;
                     }
                     break;
                  case 1:
                     //檢測上一步也就是delay是否發生異常或者失敗,接著執行-----》掛起點1結束
                     ResultKt.throwOnFailure($result);
                     break;
                  case 2:
                     //檢測上一步也就是hello是否發生異常或者失敗,接著執行-----》掛起點2結束
                     ResultKt.throwOnFailure($result);
                     break label33;
                  case 3:
                     //檢測上一步也就是delay是否發生異常或者失敗,接著執行-----》掛起點3結束
                     ResultKt.throwOnFailure($result);
                     break label34;
                  case 4:
                     ResultKt.throwOnFailure($result);
                     return Unit.INSTANCE;
                  default:
                     throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                  }

                  var2 = "掛起點1結束";
                  var3 = false;
                  //打印
                  System.out.println(var2);
                  var10000 = ExampleUnitTest.this;
                  //label增加，表示上一步執行完成，指向下一個該執行的函數體
                  this.label = 2;
                  //檢測hello是否為掛起函數
                  if (var10000.hello(this) ** var4) {
                     //協程退出
                     return var4;
                  }
               }

               //退出label33后執行的函數
               var2 = "掛起點2結束";
               var3 = false;
               System.out.println(var2);
               //再次更正
               this.label = 3;
               //檢測是否為掛起函數
               if (DelayKt.delay(1000L, this) ** var4) {
                  //直接退出協程
                  return var4;
               }
            }
            //退出label34后執行的函數
            var2 = "掛起點3結束";
            var3 = false;
            System.out.println(var2);
            var10000 = ExampleUnitTest.this;
            this.label = 4;
             //檢測是否為掛起函數
            if (var10000.word(this) ** var4) {
               return var4;
            } else {
               return Unit.INSTANCE;
            }
         }


         @NotNull
         public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
            Intrinsics.checkNotNullParameter(completion, "completion");
            Function2 var3 = new constructor>(completion);
            return var3;
         }

         public final Object invoke(Object var1, Object var2) {
            return (()this.create(var1, (Continuation)var2)).invokeSuspend(Unit.INSTANCE);
         }
      }), 3, (Object)null);
   }

}

「看完上面的反編譯解析會發現還差了兩個方法，沒錯，接下來就是自定的掛起函數的反編譯代碼，根據上面的分析請讀者親自分析下接下來的這兩個函數」

@Nullable
public final Object hello(@NotNull Continuation $completion) {
   Object var10000 = BuildersKt.withContext((CoroutineContext)Dispatchers.getIO(), (Function2)(new Function2((Continuation)null) {
      int label;

      @Nullable
      public final Object invokeSuspend(@NotNull Object $result) {
      Object var4 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
      switch(this.label) {
         case 0:
         ResultKt.throwOnFailure($result);
         this.label = 1;
         if (DelayKt.delay(1000L, this) ** var4) {
            return var4;
         }
         break;
         case 1:
         ResultKt.throwOnFailure($result);
         break;
         default:
         throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }

      String var2 = "hello";
      boolean var3 = false;
      System.out.println(var2);
      return Unit.INSTANCE;
   }

      @NotNull
      public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
      Intrinsics.checkNotNullParameter(completion, "completion");
      Function2 var3 = new constructor>(completion);
      return var3;
   }

      public final Object invoke(Object var1, Object var2) {
      return (()this.create(var1, (Continuation)var2)).invokeSuspend(Unit.INSTANCE);
   }
   }), $completion);
   return var10000 ** IntrinsicsKt.getCOROUTINE_SUSPENDED() ? var10000 : Unit.INSTANCE;
}

@Nullable
public final Object word(@NotNull Continuation $completion) {
   Object var10000 = BuildersKt.withContext((CoroutineContext)Dispatchers.getIO(), (Function2)(new Function2((Continuation)null) {
      int label;

      @Nullable
      public final Object invokeSuspend(@NotNull Object $result) {
      Object var4 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
      switch(this.label) {
         case 0:
         ResultKt.throwOnFailure($result);
         this.label = 1;
         if (DelayKt.delay(1000L, this) ** var4) {
            return var4;
         }
         break;
         case 1:
         ResultKt.throwOnFailure($result);
         break;
         default:
         throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
      }

      String var2 = "word";
      boolean var3 = false;
      System.out.println(var2);
      return Unit.INSTANCE;
   }

      @NotNull
      public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
      Intrinsics.checkNotNullParameter(completion, "completion");
      Function2 var3 = new constructor>(completion);
      return var3;
   }

      public final Object invoke(Object var1, Object var2) {
      return (()this.create(var1, (Continuation)var2)).invokeSuspend(Unit.INSTANCE);
   }
   }), $completion);
   return var10000 ** IntrinsicsKt.getCOROUTINE_SUSPENDED() ? var10000 : Unit.INSTANCE;
}

總而言之，言而總之。還是上一篇博客總結的道理，就是不斷的invokeSuspend標記標志位和掛起函數調用resumeWith。

文末致辭：

感謝東方月初提供的資料，和在分析協程原理時給予的支持。