Collecting and Analysis of Basic Elements of Kotlin Coroutines

The basic elements of Kotlin coroutines: Continuation, SafeContinuation, CoroutineContext, CombinedContext, CancellationException, intrinsics. CombinedContext is an implementation class of CoroutineContext, and SafeContinuation is an implementation class of Continuation.

What is Continuation?

class Call<T>(callBack: <T>) {
    fun cancel() {
    }
    interface CallBack<T> {
        fun onSuccess(data: T)
        fun onFail(throwable: Throwable)
    }
}
suspend fun <T : Any> Call<T>.await(): T =
    suspendCancellableCoroutine<T> { continuation ->
        val call = Call(object : <T> {
            override fun onSuccess(data: T) {
                (data, onCancellation = null)
            }
            override fun onFail(throwable: Throwable) {
                (throwable)
            }
        })
         {
            ()
        }
    }

When implementing suspended functions, you can use two higher-order functions: suspendCoroutine{} and suspendCancellableCoroutine{}. In their Lambda, we can use the continuation object it exposes to pass the execution result or exception of the program to the outside. Commonly used to implement the internal logic of suspended functions.

fun checkLength() {
    runBlocking {
        val result = getStrLengthSuspend("Kotlin")
        println(result)
    }
}
suspend fun getStrLengthSuspend(text:String):Int = suspendCoroutine {
    continuation ->
    thread {
        (1000L)
        ()
    }
}
Log
6
Process finished with exit code 0

The suspend function is implemented using suspendCoroutine{}. Inside it, the return value of the suspend function is passed using () method.

Why can the result be received by the suspended function in such an asynchronous way as ()?

suspend fun getStrLengthSuspend(text: String): Int = suspendCoroutine { continuation ->
    thread {
        (1000L)
        ()
    }
}
fun checkLength2() {
    val func = ::getStrLengthSuspend as (String, Continuation<Int>) -> Any?
    func("Kotlin", object :Continuation<Int> {
        override val context: CoroutineContext
            get() = EmptyCoroutineContext
 
        override fun resumeWith(result: Result<Int>) {
            println(())
        }
    })
    (2000L)
}
Log
6
Process finished with exit code 0

Force the function to a function type with Continuation, and then create a Continuation object and pass it in through an anonymous internal class. The essence of suspending functions is Callback!

Change Continuation to Callback:

fun getStrLength() {
    func2("Kotlin", object : MyCallBack<Int> {
        override fun resume(value: Int) {
            println(value)
        }
    })
}
fun func2(text: String, callBack: MyCallBack<Int>) {
    thread {
        (1000L)
        ()
    }
}
interface MyCallBack<T> {
    fun resume(value: T)
}
Log
6
Process finished with exit code 0

After Continuation is changed to Callback, use anonymous internal classes to create Callback to receive asynchronous results; inside the asynchronous function, use () to pass the results out.

The function of Continuation in the Kotlin coroutine is actually equivalent to Callback. It can be used to implement suspended functions and pass results to the outside of the suspended functions; it can also be used to call suspended functions. We can create anonymous internal class of Continuation to receive the results passed by the suspended functions.

How to call Kotlin's suspended function in Java code?

  public static void main(String[] args) {
        (new Continuation<String>() {
            @NonNull
            @Override
            public CoroutineContext getContext() {
                return ;
            }
            @Override
            public void resumeWith(@NonNull Object o) {
                (o + "");
            }
        });
    }
object SuspendFromJavaDo {
    suspend fun getUserInfo():String {
        delay(1000L)
        return "Kotlin"
    }
}

Therefore, when implementing suspend function logic, suspendCarcellableCoroutine{} and suspendCancellableCoroutine{} are often used.

Source code

public interface Continuation<in T> {
    /**
     * The context of the coroutine that corresponds to this continuation.
     */
    public val context: CoroutineContext
    /**
     * Resumes the execution of the corresponding coroutine passing a successful or failed [result] as the
     * return value of the last suspension point.
     */
    public fun resumeWith(result: Result<T>)
}

public suspend inline fun <T> suspendCoroutine(crossinline block: (Continuation<T>) -> Unit): T {
    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
    return suspendCoroutineUninterceptedOrReturn { c: Continuation<T> ->
        val safe = SafeContinuation(())
        block(safe)
        ()
    }
}

suspendCoroutineUninterceptedOrReturn{} implements suspendCoroutine{}.

val safe = SafeContinuation(()) packContinuation。

block(safe) calls the logic in Lambda.

() Take out the running results of block(safe), and the result can be stored in Continuation. This Result may be the correct result or an exception.

@Suppress("UNUSED_PARAMETER", "RedundantSuspendModifier")
public suspend inline fun <T> suspendCoroutineUninterceptedOrReturn(crossinline block: (Continuation<T>) -> Any?): T {
    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
    throw NotImplementedError("Implementation of suspendCoroutineUninterceptedOrReturn is intrinsic")
}

Why does the source code of this higher-order function throw an exception?

"Implementation of suspendCoroutineUninterceptedOrReturn is intrinsic." suspendCoroutineUninterceptedOrReturn is a compiler built-in function that is implemented by the Kotlin compiler.

The parameter of suspendCoroutineUninterceptedOrReturn will receive a Lambda with the type (Continuation<T>) -> Any?, the "Any?" type here can actually represent whether the current suspend function is actually suspended.

fun test() {
    runBlocking {
        val result = testNoSuspendCoroutinue()
        println(result)
    }
}
private suspend fun testNoSuspendCoroutinue() = suspendCoroutineUninterceptedOrReturn<String>{
    continuation ->
    return@suspendCoroutineUninterceptedOrReturn "Kotlin"
}
Log
Kotlin
Process finished with exit code 0

The suspend function is implemented directly using suspendCoroutineUninterceptedOrReturn, and, in its Lambda, we do not call (). This result can indeed be received outside the suspend function.

 private static final Object testNoSuspendCoroutinue(Continuation $completion) {
      int var2 = false;
      if ("Kotlin" == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
         ($completion);
      }
      return "Kotlin";
   }

This function is actually a pseudo-hanging function, and its internals will not really hang. In this way, when we call this function from the outside, the function will immediately return the result.

private suspend fun testSuspendCoroutinues() =
    suspendCoroutineUninterceptedOrReturn<String> { continuation ->
        thread {
            (2000L)
            ("Kotlin")
        }
        return@suspendCoroutineUninterceptedOrReturn .COROUTINE_SUSPENDED
    }
fun main() {
    runBlocking {
        val testSuspendCoroutinues = testSuspendCoroutinues()
        println(testSuspendCoroutinues)
    }
}
Kotlin
Process finished with exit code 0

With (), this result can also be received outside the suspended function.

   private static final Object testSuspendCoroutinues(Continuation $completion) {
      int var2 = false;
      $default(false, false, (ClassLoader)null, (String)null, 0, (Function0)(new TestCoroutine777Kt$testSuspendCoroutinues$2$1($completion)), 31, (Object)null);
      Object var10000 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
        // Assign var10000 to the COROUTINE_SUSPENDED suspend flag bit.      if (var10000 == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
         ($completion);
      }
//Return the suspend flag bit, which means that the function testSuspendCoroutinues() will actually suspend.      return var10000;
   }
$default((CoroutineContext)null, (Function2)(new Function2((Continuation)null) {
         int label;
         @Nullable
         public final Object invokeSuspend(@NotNull Object $result) {
            Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            Object var10000;
            switch() {
            case 0:
               ($result);
                = 1;
               var10000 = (this);
               if (var10000 == var3) {
                  return var3;
               }
               break;
            case 1:
               ($result);
               var10000 = $result;
               break;
            default:
               throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            String testSuspendCoroutinues = (String)var10000;
            (testSuspendCoroutinues);
            return ;
         }
         @NotNull
         public final Continuation create(@Nullable Object value, @NotNull Continuation completion) {
            (completion, "completion");
            Function2 var3 = new &lt;anonymous constructor&gt;(completion);
            return var3;
         }
         public final Object invoke(Object var1, Object var2) {
            return ((&lt;undefinedtype&gt;)(var1, (Continuation)var2)).invokeSuspend();
         }
      }), 1, (Object)null);

Because the suspend modified function may return either CoroutineSingletons.COROUTINE_SUSPENDED, or the actual result, or even null. In order to adapt to all possibilities, the CPS converted function's return value type can only be Any?.

suspendCoroutineUninterceptedOrReturn{} The function of this higher-order function: it can expose the Continuation in the suspend function as a parameter. In its Lambda, we can directly return the result, and at this time it is a "pseudo-suspension function"; or we can also return the suspend flag bit COROUTINE_SUSPENDED and then pass the result using (). Correspondingly, the two higher-order functions suspendCaroutine{} and suspendCancellableCoroutine{} are just a kind of encapsulation of it.

This is the article about the basic elements of Kotlin coroutines. For more related contents of Kotlin coroutines, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!