A Preliminary Study on Android Kotlin Coroutines

1. What is it (coroutines and Kotlin coroutines)

1.1 What is a coroutine?

Wikipedia: Coroutine \[kəru'tin\] (coroutine) is a type of component in a computer program that generalizes cooperative multitasking subroutines, allowing execution to be suspended and resumed.

Kotlin is Google's preferred language for Android development. Coroutine is not a new concept proposed by Kotlin. Currently, programming languages ​​that have the concept of coroutine include Lua, Python, Go, C, etc. It is just a programming idea and is not limited to a specific language.

The concept and implementation of coroutines in each programming language are not exactly the same. This sharing mainly talks about Kotlin coroutines.

1.2 What is Kotlin coroutine

Kotlin official website: Coroutines are lightweight threads

It can be simply understood as a thread framework, a new way to handle concurrency, and a convenient way to simplify asynchronous execution of code on Android.

Similar to Java: Thread Pool Android: Handler and AsyncTask, RxJava Schedulers

Note: Kotlin is not only for JVM platform, but also for JS/Native. If you use Kotlin to write the front-end, then Kotlin's coroutine is the coroutine in the sense of JS. If it is only for JVM platform, then it should indeed be a thread framework.

1.3 Comparison of processes, threads, and coroutines

The differences and relationships between the three can be understood through the following two pictures

A Preliminary Study on Android Kotlin Coroutines | JD Logistics Technology Team_User

A Preliminary Study on Android Kotlin Coroutines | JD Logistics Technical Team_User_02

2. Why choose it (what problems does the coroutine solve)

Example of asynchronous scenario:

1. Step 1: Get the current user token and user information through the interface
2. Step 2: Display the user's nickname on the interface
3. Step 3: Then use this token to get the current user's message unread count
4. Step 4: Display on the interface

2.1 Implementation of existing solutions

 apiService.getUserInfo().enqueue(object :Callback<User>{ override fun onResponse(call: Call<User>, response: Response<User>) { val user = response.body() tvNickName.text = user?.nickName apiService.getUnReadMsgCount(user?.token).enqueue(object :Callback<Int>{ override fun onResponse(call: Call<Int>, response: Response<Int>) { val tvUnReadMsgCount = response.body() tvMsgCount.text = tvUnReadMsgCount.toString() } }) } })

How does the existing solution get the data of asynchronous tasks? If it cannot be obtained, it will be destroyed. Hahaha, it is solved through callback functions.
If there are too many nested calls, this style of painting will feel a bit like callback hell, commonly known as "callback hell"

2.2 Coroutine Implementation

 mainScope.launch { val user = apiService.getUserInfoSuspend() //IO线程请求数据tvNickName.text = user?.nickName //UI线程更新界面val unReadMsgCount = apiService.getUnReadMsgCountSuspend(user?.token) //IO线程请求数据tvMsgCount.text = unReadMsgCount.toString() //UI线程更新界面}

 suspend fun getUserInfoSuspend() :User? { return withContext(Dispatchers.IO){ //模拟网络请求耗时操作delay(10) User("asd123", "userName", "nickName") } } suspend fun getUnReadMsgCountSuspend(token:String?) :Int{ return withContext(Dispatchers.IO){ //模拟网络请求耗时操作delay(10) 10 } }

A Preliminary Study on Android Kotlin Coroutines | JD Logistics Technical Team_Kotlin_03

The red box is a coroutine code block.

It can be seen that callbacks are no longer used in coroutine implementations, so callback hell will never occur again. Coroutines solve callback hell.

A Preliminary Study on Android Kotlin Coroutines | JD Logistics Technical Team_Kotlin_04

Coroutines allow us to use synchronous code to write asynchronous effects. This is also the biggest advantage of coroutines. Asynchronous code can be written synchronously.

Summary: Coroutines can be written synchronously with asynchronous code, solving the callback hell problem, allowing programmers to handle asynchronous business more conveniently, switch threads more conveniently, and ensure the safety of the main thread.

How does it do that?

3. How does it work (a brief analysis of the principle of coroutines)

3.1 Suspending and resuming coroutines

Suspend (non-blocking suspend)

The suspend keyword is the core keyword in the coroutine and is the identifier of suspension.

Let's take a look at the process of switching threads in the above sample code:

A Preliminary Study on Android Kotlin Coroutines | JD Logistics Technical Team_State Machine_05

Each switch from the main thread to the IO thread is a coroutine suspension operation;

Each switch from the IO thread to the main thread is a coroutine recovery operation;

Suspend and resume are unique capabilities of the suspend function, which other functions do not have. The content of suspension is the coroutine, not the suspended thread or the suspended function. When the thread executes to the suspend function, it will not continue to execute the code of the current coroutine, so it will not block the thread. It is a non-blocking suspension.

If there is a suspension, there must be a recovery process. Recovery means resuming the execution of the suspended target coroutine from the point where it was suspended. In the coroutine, we do not need to handle suspension and recovery manually, these are all done automatically by Kotlin coroutines.

So how does Kotlin coroutine help us automatically implement suspend and resume operations?

It is achieved through Continuation. \[kənˌtɪnjuˈeɪʃ(ə)n\] (continue; continuation; continuity; subsequent part)

3.2 How coroutine suspension and resumption work (Continuation)

CPS + State Machine

There is no suspend function in Java. Suspend is a keyword unique to Kotlin. When compiling, the Kotlin compiler will convert the function containing the suspend keyword.

This kind of conversion by the compiler is called CPS conversion (cotinuation-passing-style) in Kotlin.

The conversion process is as follows

The suspend function code written by the programmer:

 suspend fun getUserInfo() : User { val user = User("asd123", "userName", "nickName") return user }

A hypothetical intermediate code (for easy understanding):

 fun getUserInfo(callback: Callback<User>): Any? { val user = User("asd123", "userName", "nickName") callback.onSuccess(user) return Unit }

Converted code:

 fun getUserInfo(cont: Continuation<User>): Any? { val user = User("asd123", "userName", "nickName") cont.resume(user) return Unit }

We use the Kotlin bytecode generator to view the bytecode and then decompile it into Java code:

 @Nullable public final Object getUserInfo(@NotNull Continuation $completion) { User user = new User("asd123", "userName", "nickName"); return user; }

This also verifies that the recovery process is indeed implemented by introducing a Continuation object, where the Continuation object contains the Callback form .

It has two functions: 1. Pause and remember the execution point; 2. Remember the local variable context at the time the function is paused.

So why can we write asynchronous code in a synchronous way? It is because Continuation helps us with the callback process.

Let's take a look at the source code of this Continuation

A Preliminary Study on Android Kotlin Coroutines | JD Logistics Technical Team_User_06

You can see that this Continuation encapsulates a resumeWith method, which is used for recovery.

 internal abstract class BaseContinuationImpl() : Continuation<Any?> { public final override fun resumeWith(result: Result<Any?>) { //省略好多代码invokeSuspend() //省略好多代码} protected abstract fun invokeSuspend(result: Result<Any?>): Any? } internal abstract class ContinuationImpl( completion: Continuation<Any?>?, private val _context: CoroutineContext? ) : BaseContinuationImpl(completion) { protected abstract fun invokeSuspend(result: Result<Any?>): Any? //invokeSuspend() 这个方法是恢复的关键一步

Continuing with the above example:

This is a code before CPS:

 suspend fun testCoroutine() { val user = apiService.getUserInfoSuspend() //挂起函数IO线程tvNickName.text = user?.nickName //UI线程更新界面val unReadMsgCount = apiService.getUnReadMsgCountSuspend(user?.token) //挂起函数IO线程tvMsgCount.text = unReadMsgCount.toString() //UI线程更新界面}

There are two suspend functions in the current suspend function

After compiling with the kotlin compiler:

 fun testCoroutine(completion: Continuation<Any?>): Any? { // TestContinuation本质上是匿名内部类class TestContinuation(completion: Continuation<Any?>?) : ContinuationImpl(completion) { // 表示协程状态机当前的状态var label: Int = 0 // 两个变量，对应原函数的2个变量lateinit var user: Any lateinit var unReadMsgCount: Int // result 接收协程的运行结果var result = continuation.result // suspendReturn 接收挂起函数的返回值var suspendReturn: Any? = null // CoroutineSingletons 是个枚举类// COROUTINE_SUSPENDED 代表当前函数被挂起了val sFlag = CoroutineSingletons.COROUTINE_SUSPENDED // invokeSuspend 是协程的关键// 它最终会调用testCoroutine(this) 开启协程状态机// 状态机相关代码就是后面的when 语句// 协程的本质，可以说就是CPS + 状态机override fun invokeSuspend(_result: Result<Any?>): Any? { result = _result label = label or Int.Companion.MIN_VALUE return testCoroutine(this) } } // ... val continuation = if (completion is TestContinuation) { completion } else { // 作为参数// ↓ TestContinuation(completion)

 loop = true while(loop) { when (continuation.label) { 0 -> { // 检测异常throwOnFailure(result) // 将label 置为1，准备进入下一次状态continuation.label = 1 // 执行getUserInfoSuspend（第一个挂起函数） suspendReturn = getUserInfoSuspend(continuation) // 判断是否挂起if (suspendReturn == sFlag) { return suspendReturn } else { result = suspendReturn //go to next state } } 1 -> { throwOnFailure(result) // 获取user 值user = result as Any // 准备进入下一个状态continuation.label = 2 // 执行getUnReadMsgCountSuspend suspendReturn = getUnReadMsgCountSuspend(user.token, continuation) // 判断是否挂起if (suspendReturn == sFlag) { return suspendReturn } else { result = suspendReturn //go to next state } } 2 -> { throwOnFailure(result) user = continuation.mUser as Any unReadMsgCount = continuation.unReadMsgCount as Int loop = false } }

The execution of branch code is controlled by a label tag. When the label is 0, it will first enter the first branch, set the label to the value of the next branch, then execute the first suspend method and pass the current Continuation to get the return value. If it is COROUTINE SUSPENDED, the coroutine framework will directly return and the coroutine will be suspended . When the first suspend method is executed, the invokeSuspend method of Continuation will be called back to enter the second branch for execution, and so on until all suspend methods are executed.

Each suspend point and the Continuation corresponding to the initial suspend point will be converted into a state, and the coroutine recovery just jumps to the next state. The suspend function divides the execution process into multiple Continuation fragments, and uses the state machine to ensure that each fragment is executed sequentially.

Summary: The essence of coroutine suspension and resumption is CPS + state machine

IV. Conclusion

Here are some tricky operations that are difficult to implement without coroutines:

1. If there is a function, its return value needs to wait until multiple time-consuming asynchronous tasks are completed and returned, and the return values ​​of all tasks are combined as the final return value
2. If there is a function that needs to execute multiple network requests in sequence, and the next request depends on the execution result of the previous request
3. An asynchronous task is currently being executed, but you suddenly don't want it to be executed. You can cancel it at any time.
4. If you want a task to run for a maximum of 3 seconds, it will be automatically canceled if it exceeds 3 seconds.

The reason why Kotlin coroutine is considered a fake coroutine is that it does not run in the same thread, but actually creates multiple threads.

Kotlin coroutines on Android are just a thread pool-like encapsulation, which is really a thread framework. However, it allows us to write asynchronous effects in a synchronous code style. As for how to do it, we don't need to worry about it. Kotlin has taken care of it for us. What we need to care about is how to use it well.

It is a thread framework.