[In-depth understanding of Kotlin coroutines] Creation, startup, and suspension functions of coroutines [Theory]

Here, under the action of the RestrictsSuspension annotation, the external suspension function delay cannot be called inside the coroutine body. This feature is very helpful for many coroutine bodies created in specific scenarios, and can avoid Invalid or even dangerous calls to suspend functions. The Sequence Builder in the standard library uses this annotation.

Suspend function

We already know that a function modified with the suspend keyword is called a suspend function, and suspend function can only be called within a coroutine body or other suspend functions. In this way, the functions in the entire Kotlin language system are divided into two factions: Ordinary functions and Suspension functions. Among them, suspended functions can call any function, and ordinary functions can only call ordinary functions.

Through the above two suspend functions, we found that the suspend function can return synchronously like a normal function (such as suspendFunc01), and can also handle asynchronous logic (such as suspendFunc02). Since it is a function，They also have their own function types, suspend (Int) -> Unit and suspend (String, String) -> Int in turn.

In the definition of suspendFunc02 , we used suspendCoroutine again to obtain the Continuation of the current coroutine body The instance is used as a parameter to treat the suspending function as an asynchronous function, and the newly created thread executes the Continutation.resumeWith operation at ① of Code Listing 3-7, so the coroutine calls suspendFunc02 It cannot be executed synchronously and will enter a suspended state until the result is returned.

The so-called suspension of the coroutine actually means that when the program execution process is called asynchronously, the execution state of the current calling process enters the waiting state. Please note that the suspend function does not necessarily actually suspend, but only provides the conditions for suspending. Then under what circumstances will it really hang?

Hang point

In the previous definition of suspendFunc02, we found that if a function wants to suspend itself, all it needs is an instance of Continuation , and we can indeed pass suspendCoroutine function gets it, but where does this Continuation come from?

Recalling the process of creating and running a coroutine, our coroutine body itself is a Continuation instance, which is why the suspend function runs inside the body of the coroutine. The place where the function is suspended inside the coroutine is called the suspension point. If there is an asynchronous call at the suspend point, the current coroutine will be suspended until the corresponding Continuation ‘s resume function is called to resume execution.

We already know that the Continuation obtained through the suspendCoroutine function is an instance of SafeContinuation, which is the same as when creating a coroutine The resulting Continuation instance used to start the coroutine is not fundamentally different. The role of the SafeContinuation class is also very simple. It can ensure that it will only be suspended when an asynchronous call occurs. For example, the situation shown in Listing 3-8 also has a resume function Called, but the coroutine doesn’t actually hang.

Whether the asynchronous call occurs depends on whether the call of the resume function and the corresponding suspend function are on the same call stack. The method of switching the function call stack can be to switch to another thread for execution, or not to switch the thread but Execute at a certain moment after the current function returns. The former is easier to understand, while the latter usually saves the instance of Continuation first, and then calls it at an appropriate time in the future. Platforms with event loops can easily do this, such as the main thread Looper loop of the Android platform.

CPS transformation

Continuation Passing Style (Continuation Passing Style): A programming specification is agreed. The function does not return the result value directly, but passes in a callback function parameter at the last parameter position of the function, and completes the execution of the function When using callback to process the result. The callback function callback is called Continuation, which determines the next behavior of the program, and the logic of the entire program is spliced ​​together through Continuations.

CPS Transformation (Continuation-Passing-Style Transformation), that is, passing Continuation To control asynchronous call process, and solve the problem of callback hell and stack space occupation .

• Kotlin suspend suspend functions are written in the same way as ordinary functions, but the compiler will perform CPS transformation on the function of the suspend keyword. This is what we often say to write asynchronous code in a way that looks synchronous, eliminating callback hell ( callback hell).

• In addition, in order to avoid the problem of excessive stack space, the Kotlin compiler does not convert the code into the form of function callback, but uses the state machine model. Every two suspension points can be seen as a state, every time you enter the state machineThere is a current state, and then the code corresponding to the state is executed; if the program is executed, the result value is returned, otherwise a special value is returned, which means exit from this state and wait for the next entry. It is equivalent to creating a reusable callback, using the same callback every time, and executing different codes according to different states.

The continuation is a relatively abstract concept. Simply put, it wraps the code that the coroutine should continue to execute after it is suspended; during the compilation process, a complete coroutine is divided into continuations one after another. Each suspending function is regarded as a suspending point, and after the suspending function is executed, the execution of the follow-up body is resumed from the suspending point.

Let’s imagine, when the program is suspended, what is the most important thing to do? Is the save suspension point. The thread is similar, when it is interrupted, the interruption point is saved in the call stack.

When the Kotlin coroutine is suspended, the information of the suspension point is saved in the Continuation object. Continuation carries the context needed to continue the execution of the coroutine. When resuming execution, you only need to execute its resume call and pass in the required parameters or exceptions. As an ordinary object, Continuation occupies very little memory, which is an important reason why stackless coroutines are popular.

As we mentioned earlier, if the suspend function needs to be suspended, it needs to get the Continuation instance through suspendCoroutine , we already know that it is a coroutineProgram body, but how did this instance come in?

Let’s still take the code listing 3-8 as an example. The notSuspend function does not seem to receive any parameters. The Kotlin syntax does not seem to tell us any truth. There are two ways to get to the bottom of it: look at the bytecode or use Java The code calls it directly, and the other is to use Kotlin reflection. These two behaviors can almost be considered as violating Kotlin grammar, and they are only used for research and study, and must not be written in a production environment. Let’s first look at how to call the suspend function with Java code, as shown in Listing 3-9.

We found that the function notSuspend of type suspend () -> Int is actually of type (Continuation) -> Object in Java language, which means Just like the asynchronous callback method we wrote, just pass a callback in and wait for the result to return.

But why does the return value Object appear here? Usually our callback method will not have a return value. There are two cases for the return value Object here:

• The suspend function returns synchronously, resumeWith of the Continuation passed in as a parameter will not be called, the function > The actual return value of the number isIt serves as the return value of the suspending function. Although notSuspend seems to call resumeWith, the calling object is SafeContinuation, which we have mentioned many times before, so its implementation belongs to synchronous return.

• Suspend function suspends, performs asynchronous logic. At this time, the actual return value of the function is a suspended flag, through which the external coroutine can know that the function needs to be suspended and wait until the asynchronous logic is executed. In Kotlin this flag is a constant defined in Intrinsics.kt:

suspend fun main() {
....
}

fun main(continuation: Continuation): Any? {
return println("Hello")
}

fun main() {
runSuspend(::main1 as suspend () -> Unit)
}

/**
* Wrapper for `suspend fun main` and `@Test suspend fun testXXX` functions.
*/
@SinceKotlin("1.3")
internal fun runSuspend(block: suspend () -> Unit) {
val run = RunSuspend()
block. startCoroutine(run)
run. await()
}

private class RunSuspend : Continuation {
override val context: CoroutineContext
get() = EmptyCoroutineContext

//-Xallow-result-rreturn-type
var result: Result? = null

override fun resumeWith(result: Result) = synchronized(this) {
`` this.result = result
  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") (this as Object).notifyAll()
}

fun await() = synchronized(this) {
while (true) {
When (val result = this.result) {
  null -> @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") (this as Object).wait()
else -> {
        result. getOrThrow() // throw up failure
return
            }
}
}
}
}