使用 Kotlin 協同程式提升應用程式效能

Kotlin 協同程式 可讓您編寫簡潔、簡化的非同步程式碼 應用程式回應速度，同時管理長時間執行的工作 (例如網路呼叫) 或磁碟作業

本主題會詳細介紹 Android 上的協同程式。如果您還不熟悉協同程式，在閱讀本主題前，請務必先參考「Android 上的 Kotlin 協同程式」。

管理長時間執行的工作

協同程式會在常見函式中增添兩項作業，以處理長時間執行的工作。亦即，除了 invoke (或 call) 和 return 外，協同程式還新增了 suspend 和 resume：

• suspend 會暫停執行當前的協同程式，並儲存所有本機變數。
• resume 會在先前暫停處繼續執行已暫停的協同程式。

您只能透過其他 suspend 函式呼叫 suspend 函式，或使用協同程式建構工具 (例如 launch) 來啟動新的協同程式。

以下範例顯示，在某個長時間執行的工作中，實作簡易的協同程式：

suspend fun fetchDocs() {                             // Dispatchers.Main
    val result = get("https://developer.android.com") // Dispatchers.IO for `get`
    show(result)                                      // Dispatchers.Main
}

suspend fun get(url: String) = withContext(Dispatchers.IO) { /* ... */ }

在這個範例中，get() 仍在主執行緒上執行，但在執行網路要求前，先讓協同程式暫停了。當網路要求完成時，get 繼續執行已暫停的協同程式，而不是使用回呼來通知主執行緒。

Kotlin 使用「堆疊框架」來管理要搭配本機變數執行的函式。暫停協同程式時，系統會複製和儲存目前的堆疊框架，供日後使用。繼續執行協同程式時，系統會從儲存的位置複製堆疊框架，並再次執行函式。即使程式碼看起來是普通的連續封鎖要求，但協同程式仍能確保網路要求不會封鎖主執行緒。

使用協同程式，確保不影響主執行緒

Kotlin 協同程式使用「調度器」，來判定哪些執行緒會用於執行協同程式。如要在主執行緒外執行程式碼，您可以指示 Kotlin 協同程式在「預設」或「IO」調度器上執行作業。在 Kotlin 中，所有協同程式都必須在調度器內執行，即使在主執行緒上執行也是如此。協同程式可以自行暫停，而調度器負責繼續執行協同程式。

為指定協同程式的執行位置，Kotlin 提供了三個調度器，供您使用：

• Dispatchers.Main - 使用這個調度器在 Android 主執行緒上執行協同程式。這個調度器應只用於與 UI 互動及執行快速作業。例如，呼叫 suspend 函式、執行 Android UI 架構作業，以及更新 LiveData 物件。
• Dispatchers.IO - 這個調度器已完成最佳化調整，以便在主執行緒外執行磁碟或網路 I/O。例如，使用 Room 元件、讀取或寫入檔案，以及執行任何網路作業。
• Dispatchers.Default - 這個調度器已完成最佳化調整，以便在主執行緒外執行大量使用 CPU 的工作。用途包括為清單排序和剖析 JSON。

延續上一個範例，您可以使用調度器重新定義 get 函式。在 get 的主體中，呼叫 withContext(Dispatchers.IO) 來建立在 IO 執行緒集區上執行的區塊。您放入該區塊的所有程式碼一律會透過 IO 調度器執行。由於 withContext 本身是暫停函式，所以 get 函式也是暫停函式。

suspend fun fetchDocs() {                      // Dispatchers.Main
    val result = get("developer.android.com")  // Dispatchers.Main
    show(result)                               // Dispatchers.Main
}

suspend fun get(url: String) =                 // Dispatchers.Main
    withContext(Dispatchers.IO) {              // Dispatchers.IO (main-safety block)
        /* perform network IO here */          // Dispatchers.IO (main-safety block)
    }                                          // Dispatchers.Main
}

透過協同程式，您可以使用精細的控制項來調派執行緒。withContext() 可讓您控管任何程式碼行的執行緒集區，而不會導入回呼，因此您可以將此程式碼套用到極小的函式，例如從資料庫讀取資料，或執行網路要求。建議您使用 withContext()，確認每個函式都「不影響主執行緒」，也就是可以從主執行緒呼叫函式。如此一來，呼叫端就不必考慮使用哪個執行緒來執行函式。

在上一個範例中，fetchDocs() 會在主執行緒上執行；但它可以安全呼叫 get，後者會在背景中執行網路要求。由於協同程式支援 suspend 和 resume，所以在執行 withContext 區塊後，主執行緒上的協同程式會立即繼續執行 get 結果。

withContext() 的效能

withContext()敬上 與同等的回呼型回呼相比，未增加額外負荷 。而且在某些情況下，還能將 withContext() 呼叫最佳化，使其效能超越同等的回呼型實作。例如，如果函式呼叫網路十次，您可以使用外部 withContext()，指示 Kotlin 只切換一次執行緒。這樣的話，即使網路程式庫多次使用 withContext()，程式庫仍會留在同一個調度器上，不會切換執行緒。此外，Kotlin 會對 Dispatchers.Default 和 Dispatchers.IO 之間的切換作業進行最佳化調整，盡量避免切換執行緒。

啟動協同程式

您可以透過下列任一方式啟動協同程式：

• launch敬上 會啟動新的協同程式，但不會將結果傳回呼叫端。任何視為「射後不理」的工作都可以使用 launch 啟動。
• async敬上 啟動新的協同程式，並透過暫停的方式傳回結果 函式 await。

一般函式無法呼叫 await，因此您通常從一般函式對新協同程式執行 launch 作業。只有在其他協同程式內時，或在暫停函式內，並執行平行分解時，才使用 async。

平行分解

在 suspend 函式內啟動的所有協同程式，都必須在函式傳回時停止，因此您可能需要確保，這些協同程式要在傳回值前執行完畢。使用 Kotlin 中的「結構化並行」，您就可以定義 coroutineScope 來啟動一個或多個協同程式。然後，使用 await() (針對一個協同程式) 或 awaitAll() (針對多個協同程式)，就可確保這些協同程式在從函式傳回值前執行完畢。

例如，我們來定義 coroutineScope，用於以非同步方式擷取兩份文件。在每個延遲的參照上呼叫 await()，就能確保，兩項 async 作業都會在傳回值之前執行完畢：

suspend fun fetchTwoDocs() =
    coroutineScope {
        val deferredOne = async { fetchDoc(1) }
        val deferredTwo = async { fetchDoc(2) }
        deferredOne.await()
        deferredTwo.await()
    }

您也可以在集合上使用 awaitAll()，如以下範例所示：

suspend fun fetchTwoDocs() =        // called on any Dispatcher (any thread, possibly Main)
    coroutineScope {
        val deferreds = listOf(     // fetch two docs at the same time
            async { fetchDoc(1) },  // async returns a result for the first doc
            async { fetchDoc(2) }   // async returns a result for the second doc
        )
        deferreds.awaitAll()        // use awaitAll to wait for both network requests
    }

即使 fetchTwoDocs() 使用 async 啟動新的協同程式，函式還是會使用 awaitAll() 來等待已啟動的協同程式執行完畢，然後才會傳回值。不過請注意，即使未呼叫 awaitAll()，coroutineScope 建構工具也不會繼續執行呼叫了 fetchTwoDocs 的協同程式，直到所有新協同程式執行完畢為止。

此外，coroutineScope 會擷取協同程式擲回的例外狀況，並轉送至呼叫端。

如要進一步瞭解平行分解，請參閱「撰寫暫停函式」。

協同程式概念

CoroutineScope

CoroutineScope 可使用 launch 或 async 追蹤其建立的任何協同程式。您可以隨時呼叫 scope.cancel()，來取消進行中的工作 (即執行中的協同程式)。在 Android 中，部分 KTX 程式庫會為特定的生命週期類別提供專屬的 CoroutineScope。例如，ViewModel 有 viewModelScope，Lifecycle 則有 lifecycleScope。但與調度器不同，CoroutineScope 不執行協同程式。

viewModelScope 也用於使用協同程式的 Android 背景執行緒中列出的範例。不過，如果您需要建立自己的 CoroutineScope，來控管應用程式特定層中協同程式的生命週期，您可以按照以下方式來建立：

class ExampleClass {

    // Job and Dispatcher are combined into a CoroutineContext which
    // will be discussed shortly
    val scope = CoroutineScope(Job() + Dispatchers.Main)

    fun exampleMethod() {
        // Starts a new coroutine within the scope
        scope.launch {
            // New coroutine that can call suspend functions
            fetchDocs()
        }
    }

    fun cleanUp() {
        // Cancel the scope to cancel ongoing coroutines work
        scope.cancel()
    }
}

已取消的範圍無法建立更多協同程式。因此，只有在刪除控管生命週期的類別時，您才要呼叫 scope.cancel()。使用 viewModelScope 時，ViewModel 類別會在 ViewModel 的 onCleared() 方法中自動取消範圍。

工作

Job 是協同程式的控制代碼。使用 launch 或 async 建立的每個協同程式都會傳回 Job 執行個體，用來以唯一的方式識別協同程式，並管理生命週期。您也可以將 Job 傳遞至 CoroutineScope，來進一步管理生命週期，如以下範例所示：

class ExampleClass {
    ...
    fun exampleMethod() {
        // Handle to the coroutine, you can control its lifecycle
        val job = scope.launch {
            // New coroutine
        }

        if (...) {
            // Cancel the coroutine started above, this doesn't affect the scope
            // this coroutine was launched in
            job.cancel()
        }
    }
}

CoroutineContext

CoroutineContext 使用以下元素定義協同程式的行為：

• Job：控管協同程式的生命週期。
• CoroutineDispatcher：將工作調派給適當的執行緒。
• CoroutineName：協同程式的名稱，用於偵錯。
• CoroutineExceptionHandler：處理未擷取的例外狀況。

如果是在範圍內建立的新協同程式，系統會將新的 Job 執行個體指派給新的協同程式，並從涵蓋的範圍沿用其他 CoroutineContext 元素。您可以將新的 CoroutineContext 傳遞至 launch 或 async 函式，來覆寫沿用的元素。請注意，將 Job 傳遞至 launch 或 async 不會有任何作用，因為 Job 的新執行個體始終會被指派給新的協同程式。

class ExampleClass {
    val scope = CoroutineScope(Job() + Dispatchers.Main)

    fun exampleMethod() {
        // Starts a new coroutine on Dispatchers.Main as it's the scope's default
        val job1 = scope.launch {
            // New coroutine with CoroutineName = "coroutine" (default)
        }

        // Starts a new coroutine on Dispatchers.Default
        val job2 = scope.launch(Dispatchers.Default + CoroutineName("BackgroundCoroutine")) {
            // New coroutine with CoroutineName = "BackgroundCoroutine" (overridden)
        }
    }
}

其他協同程式資源

如需取得更多協同程式資源，請參閱下列連結：

• Android 上的 Kotlin 協同程式
• Kotlin 協同程式和資料流的其他資源