如何正確的在 Android 上使用協程 ？

前言

你還記得是哪一年的 Google IO 正式宣佈 Kotlin 成爲 Android 一級開發語言嗎？是 Google IO 2017 。現在兩年時間過去了，站在一名 Android 開發者的角度來看，Kotlin 的生態環境愈來愈好了，相關的開源項目和學習資料也日漸豐富，身邊願意去使用或者試用 Kotlin 的朋友也變多了。常年混跡掘金的我也能明顯感受到 Kotlin 標籤下的文章慢慢變多了（其實仍然少的可憐）。今年的 Google IO 也放出了 Kotlin First 的口號，許多新的 API 和功能特性將優先提供 Kotlin 支持。因此，時至今日，實在找不到安卓開發者不學 Kotlin 的理由了。

今天想聊聊的是 Kotlin Coroutine。雖然在 Kotlin 發佈之初就有了協程，可是直到 2018 年的 KotlinConf 大會上，JetBrain 發佈了 Kotlin1.3RC，這才帶來了穩定版的協程。即便穩定版的協程已經發布了一年之餘，可是好像並無足夠多的用戶，至少在我看來是這樣。在我學習協程的各個階段中，遇到問題都鮮有地方能夠求助，拋到技術羣基本就石沉大海了。基本只能靠一些英文文檔來解決問題。

關於協程的文章我看過不少，總結一下，無非下面幾類。

第一類是 Medium 上熱門文章的翻譯，其實我也翻譯過：

在 Android 上使用協程（一）：Getting The Background

在 Android 上使用協程（二）：Getting started

在 Android 上使用協程（三） ：Real Work

說實話，這三篇文章的確加深了我對協程的理解。

第二類就是官方文檔的翻譯了，我看過至少不下於五個翻譯版本，仍是以爲看 官網文檔 比較好，若是英文看着實在吃力，能夠對照着 Kotlin 中文站的翻譯來閱讀。

在看完官方文檔的很長一段時間，我幾乎只知道 GlobalScope。的確，官方文檔上基本從頭至尾都是在用 GlobalScope 寫示例代碼。因此一部分開發者，也包括我本身，在寫本身的代碼時也就直接 GlobalScope 了。一次偶然的機會才發現其實這樣的問題是很大的。在 Android 中，通常是不建議直接使用 GlobalScope 的。那麼，在 Android 中應該如何正確使用協程呢？再細分一點，如何直接在 Activity 中使用呢？如何配合 ViewModel 、LiveData 、LifeCycle 等使用呢？我會經過簡單的示例代碼來闡述 Android 上的協程使用，你也能夠跟着動手敲一敲。

協程在 Android 上的使用

GlobalScope

在通常的應用場景下，咱們都但願能夠異步進行耗時任務，好比網絡請求，數據處理等等。當咱們離開當前頁面的時候，也但願能夠取消正在進行的異步任務。這兩點，也正是使用協程中所須要注意的。既然不建議直接使用 GlobalScope，咱們就先試驗一下使用它會是什麼效果。

private fun launchFromGlobalScope() {
    GlobalScope.launch(Dispatchers.Main) {
        val deferred = async(Dispatchers.IO) {
            // network request
            delay(3000)
            "Get it"
        }
        globalScope.text = deferred.await()
        Toast.makeText(applicationContext, "GlobalScope", Toast.LENGTH_SHORT).show()
    }
}
複製代碼

在 launchFromGlobalScope() 方法中，我直接經過 GlobalScope.launch() 啓動一個協程，delay(3000) 模擬網絡請求，三秒後，會彈出一個 Toast 提示。使用上是沒有任何問題的，能夠正常的彈出 Toast 。可是當你執行這個方法以後，當即按返回鍵返回上一頁面，仍然會彈出 Toast 。若是是實際開發中經過網絡請求更新頁面的話，當用戶已經不在這個頁面了，就根本沒有必要再去請求了，只會浪費資源。GlobalScope 顯然並不符合這一特性。Kotlin 文檔 中其實也詳細說明了，以下所示:

Global scope is used to launch top-level coroutines which are operating on the whole application lifetime and are not cancelled prematurely. Another use of the global scope is operators running in Dispatchers.Unconfined, which don’t have any job associated with them.

Application code usually should use an application-defined CoroutineScope. Using async or launch on the instance of GlobalScope is highly discouraged.

大體意思是，Global scope 一般用於啓動頂級協程，這些協程在整個應用程序生命週期內運行，不會被過早地被取消。程序代碼一般應該使用自定義的協程做用域。直接使用 GlobalScope 的 async 或者 launch 方法是強烈不建議的。

GlobalScope 建立的協程沒有父協程，GlobalScope 一般也不與任何生命週期組件綁定。除非手動管理，不然很難知足咱們實際開發中的需求。因此，GlobalScope 能不用就儘可能不用。

MainScope

官方文檔中提到要使用自定義的協程做用域，固然，Kotlin 已經給咱們提供了合適的協程做用域 MainScope 。看一下 MainScope 的定義：

public fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)
複製代碼

記着這個定義，在後面 ViewModel 的協程使用中也會借鑑這種寫法。

給咱們的 Activity 實現本身的協程做用域：

class BasicCorotineActivity : AppCompatActivity(), CoroutineScope by MainScope() {}
複製代碼

經過擴展函數 launch() 能夠直接在主線程中啓動協程，示例代碼以下：

private fun launchFromMainScope() {
    launch {
        val deferred = async(Dispatchers.IO) {
            // network request
            delay(3000)
            "Get it"
        }
        mainScope.text = deferred.await()
        Toast.makeText(applicationContext, "MainScope", Toast.LENGTH_SHORT).show()
    }
}
複製代碼

最後別忘了在 onDestroy() 中取消協程，經過擴展函數 cancel() 來實現：

override fun onDestroy() {
    super.onDestroy()
    cancel()
}
複製代碼

如今來測試一下 launchFromMainScope() 方法吧！你會發現這徹底符合你的需求。實際開發中能夠把 MainScope 整合到 BaseActivity 中，就不須要重複書寫模板代碼了。

ViewModelScope

若是你使用了 MVVM 架構，根本就不會在 Activity 上書寫任何邏輯代碼，更別說啓動協程了。這個時候大部分工做就要交給 ViewModel 了。那麼如何在 ViewModel 中定義協程做用域呢？還記得上面 MainScope() 的定義嗎？沒錯，搬過來直接使用就能夠了。

class ViewModelOne : ViewModel() {

    private val viewModelJob = SupervisorJob()
    private val uiScope = CoroutineScope(Dispatchers.Main + viewModelJob)

    val mMessage: MutableLiveData<String> = MutableLiveData()

    fun getMessage(message: String) {
        uiScope.launch {
            val deferred = async(Dispatchers.IO) {
                delay(2000)
                "post $message"
            }
            mMessage.value = deferred.await()
        }
    }

    override fun onCleared() {
        super.onCleared()
        viewModelJob.cancel()
    }
}
複製代碼

這裏的 uiScope 其實就等同於 MainScope。調用 getMessage() 方法和以前的 launchFromMainScope() 效果也是同樣的，記得在 ViewModel 的 onCleared() 回調裏取消協程。

你能夠定義一個 BaseViewModel 來處理這些邏輯，避免重複書寫模板代碼。然而 Kotlin 就是要讓你作一樣的事，寫更少的代碼，因而 viewmodel-ktx 來了。看到 ktx ，你就應該明白它是來簡化你的代碼的。引入以下依賴：

implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0-alpha03"
複製代碼

而後，什麼都不須要作，直接使用協程做用域 viewModelScope 就能夠了。viewModelScope 是 ViewModel 的一個擴展屬性，定義以下：

val ViewModel.viewModelScope: CoroutineScope
        get() {
            val scope: CoroutineScope? = this.getTag(JOB_KEY)
            if (scope != null) {
                return scope
            }
            return setTagIfAbsent(JOB_KEY,
                CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main))
        }
複製代碼

看下代碼你就應該明白了，仍是熟悉的那一套。當 ViewModel.onCleared() 被調用的時候，viewModelScope 會自動取消做用域內的全部協程。使用示例以下：

fun getMessageByViewModel() {
    viewModelScope.launch {
        val deferred = async(Dispatchers.IO) { getMessage("ViewModel Ktx") }
        mMessage.value = deferred.await()
    }
}
複製代碼

寫到這裏，viewModelScope 是能知足需求的最簡寫法了。實際上，寫徹底篇，viewModelScope 仍然是我認爲的最好的選擇。

LiveData

Kotlin 一樣爲 LiveData 賦予了直接使用協程的能力。添加以下依賴：

implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0-alpha03"
複製代碼

直接在 liveData {} 代碼塊中調用須要異步執行的掛起函數，並調用 emit() 函數發送處理結果。示例代碼以下所示：

val mResult: LiveData<String> = liveData {
    val string = getMessage("LiveData Ktx")
    emit(string)
}
複製代碼

你可能會好奇這裏好像並無任何的顯示調用，那麼，liveData 代碼塊是在什麼執行的呢？當 LiveData 進入 active 狀態時，liveData{ } 會自動執行。當 LiveData 進入 inactive 狀態時，通過一個可配置的 timeout 以後會自動取消。若是它在完成以前就取消了，當 LiveData 再次 active 的時候會從新運行。若是上一次運行成功結束了，就不會再從新運行。也就是說只有自動取消的 liveData{ } 能夠從新運行。其餘緣由（好比 CancelationException）致使的取消也不會從新運行。

因此 livedata-ktx 的使用是有必定限制的。對於須要用戶主動刷新的場景，就沒法知足了。在一次完整的生命週期內，一旦成功執行完成一次，就沒有辦法再觸發了。 這句話不知道對不對，我我的是這麼理解的。所以，仍是 viewmodel-ktx 的適用性更廣，可控性也更好。

LifecycleScope

implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-alpha03"
複製代碼

lifecycle-runtime-ktx 給每一個 LifeCycle 對象經過擴展屬性定義了協程做用域 lifecycleScope 。你能夠經過 lifecycle.coroutineScope 或者 lifecycleOwner.lifecycleScope 進行訪問。示例代碼以下：

fun getMessageByLifeCycle(lifecycleOwner: LifecycleOwner) {
    lifecycleOwner.lifecycleScope.launch {
        val deferred = async(Dispatchers.IO) { getMessage("LifeCycle Ktx") }
        mMessage.value = deferred.await()
    }
}
複製代碼

當 LifeCycle 回調 onDestroy() 時，協程做用域 lifecycleScope 會自動取消。在 Activity/Fragment 等生命週期組件中咱們能夠很方便的使用，可是在 MVVM 中又不會過多的在 View 層進行邏輯處理，viewModelScope 基本就能夠知足 ViewModel 中的需求了，lifecycleScope 也顯得有點那麼食之無味。可是他有一個特殊的用法：

suspend fun <T> Lifecycle.whenCreated()
suspend fun <T> Lifecycle.whenStarted()
suspend fun <T> Lifecycle.whenResumed()
suspend fun <T> LifecycleOwner.whenCreated()
suspend fun <T> LifecycleOwner.whenStarted()
suspend fun <T> LifecycleOwner.whenResumed()
複製代碼

能夠指定至少在特定的生命週期以後再執行掛起函數，能夠進一步減輕 View 層的負擔。

總結

以上簡單的介紹了在 Android 中合理使用協程的一些方案，示例代碼已上傳至 Github。關於 MVVM + 協程 的實戰項目，能夠看看個人開源項目 wanandroid，同時也期待你寶貴的意見。

文章首發微信公衆號： 秉心說 ， 專一 Java 、 Android 原創知識分享，LeetCode 題解。

更多最新原創文章，掃碼關注我吧！