Detailed explanation of the principle of Kotlin coroutine launch startup process

fun main() {
    coroutineTest()
    (2000L)
}
val block = suspend {
    println("Hello")
    delay(1000L)
    println("Kotlin")
}
private fun coroutineTest() {
    CoroutineScope(Job()).launch {
        withContext() {
            ()
        }
    }
}

public final class CoroutineDemoKt {
   @NotNull
   private static final Function1 block;
   public static final void main() {
      coroutineTest();
      (2000L);
   }
   // $FF: synthetic method
   public static void main(String[] var0) {
      main();
   }
   @NotNull
   public static final Function1 getBlock() {
      return block;
   }
   private static final void coroutineTest() {
      $default(((CoroutineContext)$default((Job)null, 1, (Object)null)), (CoroutineContext)null, (CoroutineStart)null, (Function2)(new Function2((Continuation)null) {
         int label;
         @Nullable
         public final Object invokeSuspend(@NotNull Object $result) {
            Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            switch() {
            case 0:
               ($result);
               CoroutineContext var10000 = (CoroutineContext)();
               Function2 var10001 = (Function2)(new Function2((Continuation)null) {
                  int label;
                  @Nullable
                  public final Object invokeSuspend(@NotNull Object $result) {
                     Object var2 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
                     switch() {
                     case 0:
                        ($result);
                        Function1 var10000 = ();
                         = 1;
                        if ((this) == var2) {
                           return var2;
                        }
                        break;
                     case 1:
                        ($result);
                        break;
                     default:
                        throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                     }
                     return ;
                  }
                  @NotNull
                  public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
                     (completion, "completion");
                     Function2 var3 = new <anonymous constructor>(completion);
                     return var3;
                  }
                  public final Object invoke(Object var1, Object var2) {
                     return ((<undefinedtype>)(var1, (Continuation)var2)).invokeSuspend();
                  }
               });
                = 1;
               if ((var10000, var10001, this) == var2) {
                  return var2;
               }
               break;
            case 1:
               ($result);
               break;
            default:
               throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            return ;
         }
         @NotNull
         public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
            (completion, "completion");
            Function2 var3 = new <anonymous constructor>(completion);
            return var3;
         }
         public final Object invoke(Object var1, Object var2) {
            return ((<undefinedtype>)(var1, (Continuation)var2)).invokeSuspend();
         }
      }), 3, (Object)null);
   }
   static {
      Function1 var0 = (Function1)(new Function1((Continuation)null) {
         int label;
         @Nullable
         public final Object invokeSuspend(@NotNull Object $result) {
            Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            String var2;
            switch() {
            case 0:
               ($result);
               var2 = "Hello";
               (var2);
                = 1;
               if ((1000L, this) == var3) {
                  return var3;
               }
               break;
            case 1:
               ($result);
               break;
            default:
               throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            var2 = "Kotlin";
            (var2);
            return ;
         }
         @NotNull
         public final Continuation create(@NotNull Continuation completion) {
            (completion, "completion");
            Function1 var2 = new <anonymous constructor>(completion);
            return var2;
         }
         public final Object invoke(Object var1) {
            return ((<undefinedtype>)((Continuation)var1)).invokeSuspend();
         }
      });
      block = var0;
   }
}

public fun (
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = ,
    block: suspend CoroutineScope.() -> Unit
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if ()
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    (start, coroutine, block)
    return coroutine
}

public abstract class AbstractCoroutine<in T>(
    parentContext: CoroutineContext,
    initParentJob: Boolean,
    active: Boolean
) : JobSupport(active), Job, Continuation<T>, CoroutineScope {
    ...
    /**
      * Start this coroutine with the given code block and start the policy.  This function is called at most once on this coroutine.
      */
    public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
        start(block, receiver, this)
    }
}

public enum class CoroutineStart {
    ...
    /**
      * Use this coroutine startup strategy to start the corresponding block as coroutine.
      */
    public operator fun <T> invoke(block: suspend () -> T, completion: Continuation<T>): Unit =
    when (this) {
        DEFAULT -> (completion)
        ATOMIC -> (completion)
        UNDISPATCHED -> (completion)
        LAZY -> Unit // will start lazily
    }
}

/**
  * Create a coroutine with no receiver and the result type T. This function creates a new pending instance every time it is called.
  */ 
public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}

//#createCoroutineUnintercepted
/**
  * Create a non-interceptor coroutine with no receiver and result type T.  This function creates a new pending instance every time it is called.
  */
public actual fun <T> (suspend () -> T).createCoroutineUnintercepted(
    completion: Continuation<T>
): Continuation<Unit> {
    val probeCompletion = probeCoroutineCreated(completion)
    return if (this is BaseContinuationImpl)
        create(probeCompletion)
    else
        createCoroutineFromSuspendFunction(probeCompletion) {
            (this as Function1<Continuation<T>, Any?>).invoke(it)
        }
}

//#create
public open fun create(completion: Continuation<*>): Continuation<Unit> {
    throw UnsupportedOperationException("create(Continuation) has not been overridden")
}
public open fun create(value: Any?, completion: Continuation<*>): Continuation<Unit> {
    throw UnsupportedOperationException("create(Any?;Continuation) has not been overridden")
}

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

//#createCoroutineFromSuspendFunction
/**
  * When a suspend-modified lambda expression does not inherit the BaseContinuationImpl class, a coroutine is created through this method.
  *
  * It happens in two situations:
  * Other suspended methods are called in the expression
  * 2. The suspend method is implemented through Java
  *
  * It must be encapsulated into an instance that extends [BaseContinuationImpl], because this is the expectation of all coroutine mechanisms. 
  */
private inline fun <T> createCoroutineFromSuspendFunction(
	completion: Continuation<T>,
	crossinline block: (Continuation<T>) -> Any?
		): Continuation<Unit> {
	val context = 
	// Create a restricted coroutine for context for null	return if (context === EmptyCoroutineContext)
	//Restricted coroutines: Only the suspend method provided in the coroutine scope can be called to suspend, and other suspend methods cannot be called	object : RestrictedContinuationImpl(completion as Continuation<Any?>) {
		private var label = 0
		override fun invokeSuspend(result: Result<Any?>): Any? =
		when (label) {
			0 -> {
				label = 1
				() // If you try to start with an exception, the exception is re-thrown (will be caught)				block(this) // Run the block, can return or hang			}
			1 -> {
				label = 2
				() // This is the result of block hang			}
			else -> error("This coroutine had already completed")
		}
	}
	else
	//Create a normal coroutine	object : ContinuationImpl(completion as Continuation<Any?>, context) {
		private var label = 0
		override fun invokeSuspend(result: Result<Any?>): Any? =
		when (label) {
			0 -> {
				label = 1
				() // If you try to start with an exception, the exception is re-thrown (will be caught)				block(this) // Run the block, can return or hang			}
			1 -> {
				label = 2
				() // This is the result of block hang			}
			else -> error("This coroutine had already completed")
		}
	}
}

public expect fun <T> Continuation<T>.intercepted(): Continuation<T>
//Detailed implementation//#intercepted
public actual fun <T> Continuation<T>.intercepted(): Continuation<T> =
    (this as? ContinuationImpl)?.intercepted() ?: this

internal abstract class ContinuationImpl(
    completion: Continuation<Any?>?,
    private val _context: CoroutineContext?
) : BaseContinuationImpl(completion) {
	...
    @Transient
    private var intercepted: Continuation<Any?>? = null
	//If there is no cache, get the interceptor from the context and call interceptContinuation to intercept	//Save the obtained content to a global variable    public fun intercepted(): Continuation<Any?> =
        intercepted
            ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
                .also { intercepted = it }
}

/**
  * Resumes the corresponding coroutine pass value as the return value of the last pending point.
  */
public inline fun <T> Continuation<T>.resume(value: T): Unit =
	resumeWith((value))
public interface Continuation<in T> {
	/**
      * The context of the coroutine corresponding to this continuation.
      */
	public val context: CoroutineContext
	/**
      * Resumes the corresponding coroutine pass value as the return value of the last pending point.
      */
	public fun resumeWith(result: Result<T>)
}

//#startCoroutineCancellable
public fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>): Unit = runSafely(completion) {
    createCoroutineUnintercepted(completion).intercepted().resumeCancellableWith((Unit))
}

//DispatchedContinuation#resumeCancellableWith
public fun <T> Continuation<T>.resumeCancellableWith(
	result: Result<T>,
	onCancellation: ((cause: Throwable) -> Unit)? = null
): Unit = when (this) {
	is DispatchedContinuation -> resumeCancellableWith(result, onCancellation)
	else -> resumeWith(result)
}
// We inline it to save an entry on the stack, in the case it displays (unlimited scheduler)// It is only used in Continuation<T>.resumeCancellableWith@Suppress("NOTHING_TO_INLINE")
inline fun resumeCancellableWith(
	result: Result&lt;T&gt;,
	noinline onCancellation: ((cause: Throwable) -&gt; Unit)?
		) {
	val state = (onCancellation)
	//Does it need to be distributed	if ((context)) {
		_state = state
		resumeMode = MODE_CANCELLABLE
		//Distribute the execution of the runnable block to another thread in the given context		(context, this)
	} else {
		executeUnconfined(state, MODE_CANCELLABLE) {
			//The coroutine has not been cancelled			if (!resumeCancelled(state)) {
				// Resuming execution				resumeUndispatchedWith(result)
			}
		}
	}
}
//Before resume execution, determine whether the coroutine has been cancelled.inline fun resumeCancelled(state: Any?): Boolean {
	//Get the current coroutine task	val job = context[Job]
	//If it is not empty and is not active	if (job != null &amp;&amp; !) {
		val cause = ()
		cancelCompletedResult(state, cause)
		//throw an exception		resumeWithException(cause)
		return true
	}
	return false
}
//We need to inline it to save an entry in the stackinline fun resumeUndispatchedWith(result: Result&lt;T&gt;) {
	withContinuationContext(continuation, countOrElement) {
		(result)
	}
}