Android Kotlin 協程初探

京東雲技術團隊發表於2023-10-24
AndroidKotlin

1 它是什麼（協程 和 Kotlin協程）

1.1 協程是什麼

維基百科：協程，英文Coroutine [kəru’tin] （可入廳），是計算機程式的一類元件，推廣了協作式多工的子程式，允許執行被掛起與被恢復。

作為Google欽定的Android開發首選語言Kotlin，協程並不是 Kotlin 提出來的新概念，目前有協程概念的程式語言有Lua語言、Python語言、Go語言、C語言等，它只是一種程式設計思想，不侷限於特定的語言。

而每一種程式語言中的協程的概念及實現又不完全一樣，本次分享主要講Kotlin協程。

1.2 Kotlin協程是什麼

Kotlin官網：協程是輕量級執行緒

可簡單理解：一個執行緒框架，是全新的處理併發的方式，也是Android上方便簡化非同步執行程式碼的方式

類似於 Java：執行緒池 Android：Handler和AsyncTask，RxJava的Schedulers

注：Kotlin不僅僅是面向JVM平臺的，還有JS/Native，如果用kotlin來寫前端，那Koltin的協程就是JS意義上的協程。如果僅僅JVM 平臺，那確實應該是執行緒框架。

1.3 程式、執行緒、協程比較

可透過以下兩張圖理解三者的不同和關係

2 為什麼選擇它（協程解決什麼問題）

非同步場景舉例：

  1. 第一步：介面獲取當前使用者token及使用者資訊
  2. 第二步：將使用者的暱稱展示介面上
  3. 第三步：然後再透過這個token獲取當前使用者的訊息未讀數
  4. 第四步：並展示在介面上

2.1 現有方案實現

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()
            }
        })
    }
})

現有方案如何拿到非同步任務的資料，得不到就毀掉哈哈哈，就是透過回撥函式來解決。
若巢狀多了，這種畫風是不是有點回撥地獄的感覺，俗稱的「callback hell」

2.2 協程實現

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
    }
}

紅色框框內的就是一個協程程式碼塊。

可以看得出在協程實現中告別了callback，所以再也不會出現回撥地獄這種情況了，協程解決了回撥地獄

協程可以讓我們用同步的程式碼寫出非同步的效果，這也是協程最大的優勢，非同步程式碼同步去寫。

小結：協程可以非同步程式碼同步去寫，解決回撥地獄，讓程式設計師更方便地處理非同步業務，更方便地切執行緒，保證主執行緒安全。

它是怎麼做到的？

3 它是怎麼工作的（協程的原理淺析）

3.1 協程的掛起和恢復

掛起（非阻塞式掛起）

suspend 關鍵字，它是協程中核心的關鍵字，是掛起的標識。

下面看一下上述示例程式碼切換執行緒的過程：

每一次從主執行緒切到IO執行緒都是一次協程的掛起操作；

每一次從IO執行緒切換主執行緒都是一次協程的恢復操作；

掛起和恢復是suspend函式特有的能力，其他函式不具備，掛起的內容是協程，不是掛起執行緒，也不是掛起函式，當執行緒執行到suspend函式的地方，不會繼續執行當前協程的程式碼了，所以它不會阻塞執行緒，是非阻塞式掛起。

有掛起必然有恢復流程， 恢復是指將已經被掛起的目標協程從掛起之處開始恢復執行。在協程中，掛起和恢復都不需要我們手動處理，這些都是kotlin協程幫我們自動完成的。

那Kotlin協程是如何幫我們自動實現掛起和恢復操作的呢？

它是透過Continuation來實現的。 [kənˌtɪnjuˈeɪʃ(ə)n] （繼續；延續；連續性；後續部分）

3.2 協程的掛起和恢復的工作原理（Continuation）

CPS + 狀態機

Java中沒有suspend函式，suspend是Kotlin中特有的關鍵字，當編譯時，Kotlin編譯器會將含有suspend關鍵字的函式進行一次轉換。

這種被編譯器轉換在kotlin中叫CPS轉換（cotinuation-passing-style）。

轉換流程如下所示

程式設計師寫的掛起函式程式碼：

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

假想的一種中間態程式碼（便於理解）：

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

轉換後的程式碼：

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

我們透過Kotlin生成位元組碼工具檢視位元組碼，然後將其反編譯成Java程式碼：

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

這也驗證了確實是會透過引入一個Continuation物件來實現恢復的流程，這裡的這個Continuation物件中包含了Callback的形態。

它有兩個作用：1. 暫停並記住執行點位；2. 記住函式暫停時刻的區域性變數上下文。

所以為什麼我們可以用同步的方式寫非同步程式碼，是因為Continuation幫我們做了回撥的流程。

下面看一下這個Continuation 的原始碼部分

可以看到這個Continuation中封裝了一個resumeWith的方法，這個方法就是恢復用的。

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() 這個方法是恢復的關鍵一步

繼續看上述例子：

這是一個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執行緒更新介面
}

當前掛起函式里有兩個掛起函式

透過kotlin編譯器編譯後：

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
}
}

透過一個label標籤控制分支程式碼執行,label為0,首先會進入第一個分支,首先將label設定為下一個分支的數值,然後執行第一個suspend方法並傳遞當前Continuation,得到返回值,如果是COROUTINE SUSPENDED,協程框架就直接return,協程掛起,當第一個suspend方法執行完成,會回撥Continuation的invokeSuspend方法,進入第二個分支執行,以此類推執行完所有suspend方法。

每一個掛起點和初始掛起點對應的 Continuation 都會轉化為一種狀態，協程恢復只是跳轉到下一種狀態中。掛起函式將執行過程分為多個 Continuation 片段，並且利用狀態機的方式保證各個片段是順序執行的。

小結：協程的掛起和恢復的本質是CPS + 狀態機

4 總結

總結幾個不用協程實現起來很麻煩的騷操作：

  1. 如果有一個函式，它的返回值需要等到多個耗時的非同步任務都執行完畢返回之後，組合所有任務的返回值作為 最終返回值
  2. 如果有一個函式，需要順序執行多個網路請求，並且後一個請求依賴前一個請求的執行結果
  3. 當前正在執行一項非同步任務，但是你突然不想要它執行了，隨時可以取消
  4. 如果你想讓一個任務最多執行3秒，超過3秒則自動取消

Kotlin協程之所以被認為是假協程，是因為它並不在同一個執行緒執行，而是真的會建立多個執行緒。

Kotlin協程在Android上只是一個類似執行緒池的封裝，真就是一個執行緒框架。但是它卻可以讓我們用同步的程式碼風格寫出非同步的效果，至於怎麼做的，這個不需要我們操心，這些都是kotlin幫我們處理好了，我們需要關心的是怎麼用好它

它就是一個執行緒框架。

作者：京東物流 王斌

來源：京東雲開發者社群 自猿其說Tech 轉載請註明來源

相關文章