What? 你還不知道Kotlin Coroutine?

今天我們來聊聊Kotlin Coroutine，如果你還沒有了解過，那麼我要提前恭喜你，因爲你將掌握一個新技能，對你的代碼方面的提升將是很好的助力。

What Coroutine

簡單的來說，Coroutine是一個併發的設計模式，你能通過它使用更簡潔的代碼來解決異步問題。

例如，在Android方面它主要能夠幫助你解決以下兩個問題：

1. 在主線程中執行耗時任務導致的主線程阻塞，從而使App發生ANR。
2. 提供主線程安全，同時對來自於主線程的網絡回調、磁盤操提供保障。

這些問題，在接下來的文章中我都會給出解決的示例。

Callback

說到異步問題，我們先來看下我們常規的異步處理方式。首先第一種是最基本的callback方式。

callback的好處是使用起來簡單，但你在使用的過程中可能會遇到如下情形

        GatheringVoiceSettingRepository.getInstance().getGeneralSettings(RequestLanguage::class.java)
                .observe(this, { language ->
                    convertResult(language, { enable -> 
                        // todo something
                    })
                })

這種在其中一個callback中回調另一個callback回調，甚至更多的callback都是可能存在。這些情況導致的問題是代碼間的嵌套層級太深，導致邏輯嵌套複雜，後續的維護成本也要提高，這不是我們所要看到的。

那麼有什麼方法能夠解決呢？當然有，其中的一種解決方法就是我接下來要說的第二種方式。

Rx系列

對多嵌套回調，Rx系列在這方面處理的已經非常好了，例如RxJava。下面我們來看一下RxJava的解決案例

        disposable = createCall().map {
            // return RequestType
        }.subscribeWith(object : SMDefaultDisposableObserver<RequestType>{
            override fun onNext(t: RequestType) {
                // todo something
            }
        })

RxJava豐富的操作符，再結合Observable與Subscribe能夠很好的解決異步嵌套回調問題。但是它的使用成本就相對提高了，你要對它的操作符要非常瞭解，避免在使用過程中濫用或者過度使用，這樣自然複雜度就提升了。

那麼我們渴望的解決方案是能夠更加簡單、全面與健壯，而我們今天的主題Coroutine就能夠達到這種效果。

Coroutine在Kotlin中的基本要點

在Android裏，我們都知道網絡請求應該放到子線程中，相應的回調處理一般都是在主線程，即ui線程。正常的寫法就不多說了，那麼使用Coroutine又該是怎麼樣的呢？請看下面代碼示例：

    private suspend fun get(url: String) = withContext(Dispatchers.IO) {
        // to do network request
        url
    }
 
    private suspend fun fetch() { // 在Main中調用
        val result = get("https://rousetime.com") // 在IO中調用
        showToast(result) // 在Main中調用
    }

如果fetch方法在主線程調用，那麼你會發現使用Coroutine來處理異步回調就像是在處理同步回調一樣，簡潔明瞭、行雲流水，同時再也沒有嵌套的邏輯了。

注意看方法，Coroutine爲了能夠實現這種簡單的操作，增加了兩個操作來解決耗時任務，分別爲suspend與resume

• suspend: 掛起當前執行的協同程序，並且保存此刻的所有本地變量
• resume: 從它被掛起的位置繼續執行，並且掛起時保存的數據也被還原

解釋的有點生硬，簡單的來說就是suspend可以將該任務掛起，使它暫時不在調用的線程中，以至於當前線程可以繼續執行別的任務，一旦被掛起的任務已經執行完畢，那麼就會通過resume將其重新插入到當前線程中。

所以上面的示例展示的是，當get還在請求的時候，fetch方法將會被掛起，直到get結束，此時纔會插入到主線程中並返回結果。

一圖勝千言，我做了一張圖，希望能有所幫助。

另外需要注意的是，suspend方法只能夠被其它的suspend方法調用或者被一個coroutine調用，例如launch。

Dispatchers

另一方面Coroutine使用Dispatchers來負責調度協調程序執行的線程，這一點與RxJava的schedules有點類似，但不同的是Coroutine一定要執行在Dispatchers調度中，因爲Dispatchers將負責resume被suspend的任務。

Dispatchers提供三種模式切換，分別爲

1. Dispatchers.Main: 使Coroutine運行中主線程，以便UI操作
2. Dispatchers.IO: 使Coroutine運行在IO線程，以便執行網絡或者I/O操作
3. Dispatchers.Default: 在主線程之外提高對CPU的利用率，例如對list的排序或者JSON的解析。

再來看上面的示例

    private suspend fun get(url: String) = withContext(Dispatchers.IO) {
        // to do network request
        url
    }
 
    private suspend fun fetch() { // 在Main中調用
        val result = get("https://rousetime.com") // 在IO中調用
        showToast(result) // 在Main中調用
    }

爲了讓get操作運行在IO線程，我們使用withContext方法，對該方法傳入Dispatchers.IO，使得它閉包下的任務都處於IO線程中，同時witchContext也是一個suspend函數。

創建Coroutine

上面提到suspend函數只能在相應的suspend中或者Coroutine中調用。那麼Coroutine又該如何創建呢？

有兩種方式，分別爲launch與async

1. launch: 開啓一個新的Coroutine，但不返回結果
2. async: 開啓一個新的Coroutine，但返回結果

還是上面的例子，如果我們需要執行fetch方法，可以使用launch創建一個Coroutine

    private fun excute() {
        CoroutineScope(Dispatchers.Main).launch {
            fetch()
        }
    }

另一種async，因爲它返回結果，如果要等所有async執行完畢，可以使用await或者awaitAll

    private suspend fun fetchAll() {
        coroutineScope {
            val deferredFirst = async { get("first") }
            val deferredSecond = async { get("second") }
            deferredFirst.await()
            deferredSecond.await()

//            val deferred = listOf(
//                    async { get("first") },
//                    async { get("second") }
//            )
//            deferred.awaitAll()
        }
    }

所以通過await或者awaitAll可以保證所有async完成之後再進行resume調用。

Architecture Components

如果你使用了Architecture Component，那麼你也可以在其基礎上使用Coroutine，因爲Kotlin Coroutine已經提供了相應的api並且定製了CoroutineScope。

如果你還不瞭解Architecture Component，強烈推薦你閱讀我的Android Architecture Components 系列

在使用之前，需要更新architecture component的依賴版本，如下所示

object Versions {
    const val arch_version = "2.2.0-alpha01"
    const val arch_room_version = "2.1.0-rc01"
}
 
object Dependencies {
    val arch_lifecycle = "androidx.lifecycle:lifecycle-extensions:${Versions.arch_version}"
    val arch_viewmodel = "androidx.lifecycle:lifecycle-viewmodel-ktx:${Versions.arch_version}"
    val arch_livedata = "androidx.lifecycle:lifecycle-livedata-ktx:${Versions.arch_version}"
    val arch_runtime = "androidx.lifecycle:lifecycle-runtime-ktx:${Versions.arch_version}"
    val arch_room_runtime = "androidx.room:room-runtime:${Versions.arch_room_version}"
    val arch_room_compiler = "androidx.room:room-compiler:${Versions.arch_room_version}"
    val arch_room = "androidx.room:room-ktx:${Versions.arch_room_version}"
}

ViewModelScope

在ViewModel中，爲了能夠使用Coroutine提供了viewModelScope.launch，同時一旦ViewModel被清除，對應的Coroutine也會自動取消。

    fun getAll() {
        viewModelScope.launch {
            val articleList = withContext(Dispatchers.IO) {
                articleDao.getAll()
            }
            adapter.clear()
            adapter.addAllData(articleList)
        }
    }

在IO線程通過articleDao從數據庫取數據，一旦數據返回，在主線程進行處理。如果在取數據的過程中ViewModel已經清除了，那麼數據獲取也會停止，防止資源的浪費。

LifecycleScope

對於Lifecycle，提供了LifecycleScope，我們可以直接通過launch來創建Coroutine

    private fun coroutine() {
        lifecycleScope.launch {
            delay(2000)
            showToast("coroutine first")
            delay(2000)
            showToast("coroutine second")
        }
    }

因爲Lifecycle是可以感知組件的生命週期的，所以一旦組件onDestroy了，相應的LifecycleScope.launch閉包中的調用也將取消停止。

lifecycleScope本質是Lifecycle.coroutineScope

val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope
    get() = lifecycle.coroutineScope
 
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        if (lifecycle.currentState <= Lifecycle.State.DESTROYED) {
            lifecycle.removeObserver(this)
            coroutineContext.cancel()
        }
    }

它會在onStateChanged中監聽DESTROYED狀態，同時調用cancel取消Coroutine。

另一方面，lifecycleScope還可以根據Lifecycle不同的生命狀態進行suspend處理。例如對它的STARTED進行特殊處理

    private fun coroutine() {
        lifecycleScope.launchWhenStarted {

        }
        lifecycleScope.launch {
            whenStarted {  }
            delay(2000)
            showToast("coroutine first")
            delay(2000)
            showToast("coroutine second")
        }
    }

不管是直接調用launchWhenStarted還是在launch中調用whenStarted都能達到同樣的效果。

LiveData

LiveData中可以直接使用liveData，在它的參數中會調用一個suspend函數，同時會返回LiveData對象

fun <T> liveData(
    context: CoroutineContext = EmptyCoroutineContext,
    timeoutInMs: Long = DEFAULT_TIMEOUT,
    @BuilderInference block: suspend LiveDataScope<T>.() -> Unit
): LiveData<T> = CoroutineLiveData(context, timeoutInMs, block)

所以我們可以直接使用liveData來是實現Coroutine效果，我們來看下面一段代碼

    // Room
    @Query("SELECT * FROM article_model WHERE title = :title LIMIT 1")
    fun findByTitle(title: String): ArticleModel?
    // ViewModel
    fun findByTitle(title: String) = liveData(Dispatchers.IO) {
        MyApp.db.articleDao().findByTitle(title)?.let {
            emit(it)
        }
    }
    // Activity
    private fun checkArticle() {
        vm.findByTitle("Android Architecture Components Part1:Room").observe(this, Observer {
        })
    }

通過title從數據庫中取數據，數據的獲取發生在IO線程，一旦數據返回，再通過emit方法將返回的數據發送出去。所以在View層，我們可以直接使用checkArticle中的方法來監聽數據的狀態。

另一方面LiveData有它的active與inactive狀態，對於Coroutine也會進行相應的激活與取消。對於激活，如果它已經完成了或者非正常的取消，例如拋出CancelationException異常，此時將不會自動激活。

對於發送數據，還可以使用emitSource，它與emit共同點是在發送新的數據之前都會將原數據清除，而不同點是，emitSource會返回一個DisposableHandle對象，以便可以調用它的dispose方法進行取消發送。

最後我使用Architecture Component與Coroutine寫了個簡單的Demo，大家可以在Github中進行查看

源碼地址: https://github.com/idisfkj/an...

推薦閱讀

Android Architecture Components Part1:Room

Android Architecture Components Part2:LiveData

Android Architecture Components Part3:Lifecycle

Android Architecture Components Part4:ViewModel

公衆號

掃描二維碼，關注微信公衆號，獲取獨家最新IT技術！