Kotlin協程概念原理與使用萬字梳理

2022-08-01 18:02:25

一.協程概述

1.概念

協程是Coroutine的中文簡稱，co表示協同、共同作業，routine表示程式。協程可以理解為多個互相共同作業的程式。協程是輕量級的執行緒，它的輕量體現在啟動和切換，協程的啟動不需要申請額外的堆疊空間；協程的切換髮生在使用者態，而非核心態，避免了複雜的系統呼叫。

2.特點

1）更加輕量級，佔用資源更少。

2）避免“回撥地獄”，增加程式碼可讀性。

3）協程的掛起不阻塞執行緒。

3.原理

Kotlin協程原理核心體現在“續體傳遞”與“狀態機”兩部分。

1）續體傳遞

續體傳遞是一種程式碼編寫風格——續體傳遞風格(Continuation-Passing-Style)，簡稱為CPS。續體傳遞本質上是程式碼的回撥與結果的傳遞。假設將順序執行程式碼分成兩部分，第一部分執行完成，返回一個結果(可能為空、一個物件參照、一個具體的值)。接著通過回撥執行第二部分程式碼，並傳入第一部分程式碼返回的結果，這種形式的程式碼編寫風格就是續體傳遞風格。

具體地，假設要計算一個複雜的計算，正常情況會這樣編寫，程式碼如下：

fun calculate(a: Int, b: Int): Int = a + b
fun main() {
    val result = calculate(1, 2)
    Log.d("liduo",result)
}

把上面的程式碼改造成續體傳遞風格。首先，定義一個續體傳遞介面，程式碼如下：

interface Continuation {
    fun next(result: Int)
}

對calculate方法進行改造，程式碼如下：

fun calculate(a: Int, b: Int, continuation: Continuation) = 
    continuation.next(a + b)
fun main() {
    calculate(1, 2) { result ->
        Log.d("liduo", result)
    }
}

經過續體傳遞改造後，列印紀錄檔的操作被封裝到了Continuation中，並且依賴計算操作的回撥。如果continuation方法不回撥執行引數continuation，列印紀錄檔的操作將永遠不會被執行。

原本順序執行一段程式碼(邏輯)，在經過一次續體改造後變成了兩段程式碼(邏輯)。

2）狀態機

協程的程式碼在經過Kotlin編譯器處理時，會被優化成狀態機模型。每段程式碼有三個狀態：未執行、掛起、已恢復(完成)。處於未執行狀態的程式碼可以被執行，執行過程中發生掛起，會進入掛起狀態，從掛起中恢復或執行完畢會進入已恢復(完成)狀態。當多個像這樣的程式碼進行共同作業時，可以組合出更復雜的狀態機。

二.協程基礎

1.協程的上下文

協程上下文是一組可以附加到協程中的持久化使用者定義物件，程式碼如下：

interface CoroutineContext {
    // 過載"[]"操作
    operator fun <E : Element> get(key: Key<E>): E?
    // 單值歸一化操作
    fun <R> fold(initial: R, operation: (R, Element) -> R): R
    // 過載 "+"操作
    operator fun plus(context: CoroutineContext): CoroutineContext
    // 獲取當前指定key外的其他上下文
    fun minusKey(key: Key<*>): CoroutineContext
    interface Element : CoroutineContext {
        val key: Key<*>
    }
    interface Key<E : Element>
}

Element介面繼承自CoroutineContext介面，協程中的攔截器、排程器、例外處理器以及代表協程自身生命週期等重要的類，都實現了Element介面。

Element介面規定每個實現該介面的物件都要有一個獨一無二的Key，以便在需要的時候可以在協程上下文中快速的找到。因此，協程上下文可以理解為是一個Element的索引集，一個結構介於Set和Map之間的索引集。

2.協程的作用域

協程作用域用於管理作用域內協程的生命週期，程式碼如下：

interface CoroutineScope {
    // 作用域內啟動協程的預設上下文
    val coroutineContext: CoroutineContext
}

協程中提供了兩個常用的方法來建立新的協程作用域，一個是coroutineScope方法，一個是supervisorScope方法，這兩種方法建立的作用域中的上下文會自動繼承父協程的上下文。除此之外，使用GlobalScope啟動協程，也會為協程建立一個新的協程作用域，但協程作用域的上下文為空上下文。

當父協程被取消或發生異常時，會自動取消父協程所有的子協程。當子協程取消或發生異常時，在coroutineScope作用域下，會導致父協程取消；而在supervisorScope作用域下，則不會影響父協程。

協程的作用域只對父子協程有效，對子孫協程無效。例如：啟動父協程，在supervisorScope作用域內啟動子協程。當子協程在啟動孫協程時，在不指定為supervisorScope作用域的情況下，預設為coroutineScope作用域。

3.協程排程器

協程排程器用於切換執行協程的執行緒。常見的排程器有以下4種：

Dispatchers.Default：預設排程器。它使用JVM的共用執行緒池，該排程器的最大並行度是CPU的核心數，預設為2。
Dispatchers.Unconfined：非受限排程器。該排程器不會限制程式碼在指定的執行緒上執行。即掛起函數後面的程式碼不會主動恢復到掛起之前的執行緒去執行，而是在執行掛起函數的執行緒上執行。
Dispatchers.IO：IO排程器。它將阻塞的IO任務分流到一個共用的執行緒池中。該排程器和Dispatchers.Default共用執行緒。
Dispatchers.Main：主執行緒排程器。一般用於操作與更新UI。

注意：Dispatchers.Default排程器和Dispatchers.IO 排程器分配的執行緒為守護執行緒。

4.協程的啟動模式

協程共有以下四種啟動模式：

CoroutineStart.DEFAULT：立即執行協程，可以隨時取消。
CoroutineStart.LAZY：建立一個協程，但不執行，在使用者需要時手動觸發執行。
CoroutineStart.ATOMIC：立即執行協程，但在協程執行前無法取消。目前處於試驗階段。
CoroutineStart.UNDISPATCHED：立即在當前執行緒執行協程，直到遇到第一個掛起。目前處於試驗階段。

5.協程的生命週期

每個協程在建立後都會返回一個Job介面指向的物件，一個Job物件代表一個協程，用於控制生命週期，程式碼如下：

interface Job : CoroutineContext.Element {
    ...
    // 三個狀態標誌
    val isActive: Boolean
    val isCompleted: Boolean
    val isCancelled: Boolean
    // 獲取具體的取消異常
    fun getCancellationException(): CancellationException
    // 啟動協程
    fun start(): Boolean
    // 取消協程
    fun cancel(cause: CancellationException? = null)
    ...
    // 等待協程執行結束
    suspend fun join()
    // 用於select語句
    val onJoin: SelectClause0
    // 用於註冊協程執行結束的回撥
    fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle
    ...
}

1）協程狀態的轉換

在DEFAULT、ATOMIC、UNDISPATCHED這三個模式下，啟動協程會進入Active狀態，而在LAZY模式下啟動的協程會進入New狀態，需要在手動呼叫start方法後進入Active狀態。

Completing是一個內部狀態，對外不可感知。

2）狀態標識的變化

State	[isActive]	[isCompleted]	[isCancelled]
New	false	false	false
Active	true	false	false
Completing	true	false	false
Cancelling	false	false	true
Cancelled	false	true	true
Completed	fasle	true	false

三.協程使用

1.協程的啟動

1）runBlocking方法

fun <T> runBlocking(context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() -> T): T

該方法用於在非協程作用域環境中啟動一個協程，並在這個協程中執行lambda表示式中的程式碼。同時，呼叫該方法會阻塞當前執行緒，直到lambda表示式執行完畢。該方法不應該在協程中被呼叫，該方法設計的目的是為了讓suspend編寫的程式碼可以在常規的阻塞程式碼中呼叫。如果不設定協程排程器，那麼協程將在當前被阻塞的執行緒中執行。範例程式碼如下：

private fun main() {
    // 不指定排程器，在方法呼叫的執行緒執行
    runBlocking {
        // 這裡是協程的作用域
        Log.d("liduo", "123")
    }
}
private fun main() {
    // 指定排程器，在IO執行緒中執行
    runBlocking(Dispatchers.IO) {
        // 這裡是協程的作用域
        Log.d("liduo", "123")
    }
}

2）launch方法

fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

該方法用於在協程作用域中非同步啟動一個新的協程，呼叫該方法不會阻塞執行緒。範例程式碼如下：

private fun test() {
    // 作用域為GlobalScope
    // 懶啟動，主執行緒執行
    val job = GlobalScope.launch(
            context = Dispatchers.Main, 
            start = CoroutineStart.LAZY) {
        Log.d("liduo", "123")
    }
    // 啟動協程
    job.start()
}

3）async方法

fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>

該方法用於在協程作用域中中非同步啟動一個新的協程，呼叫該方法不會阻塞執行緒。async方法與launch方法的不同之處在於可以攜帶返回值。呼叫該方法會返回一個Deferred介面指向的物件，呼叫該物件可以獲取協程執行的結果。同時，Deferred介面繼承自Job介面，因此仍然可以操作協程的生命週期。範例程式碼如下：

// suspend標記
private suspend fun test(): Int {
    // 作用域為GlobalScope，返回值為Int型別，，泛型可省略，自動推斷
    val deffer = GlobalScope.async<Int> {
        Log.d("liduo", "123")
        // 延時1s
        delay(1000)
        1
    }
    // 獲取返回值
    return deffer.await()
}

通過呼叫返回的Deferred介面指向物件的await方法可以獲取返回值。在呼叫await方法時，如果協程執行完畢，則直接獲取返回值。如果協程還在執行，則該方法會導致協程掛起，直到執行結束或發生異常。

4）suspend關鍵字

suspend關鍵字用於修飾一個方法(lambda表示式)。suspend修飾的方法稱為suspend方法，表示方法在執行中可能發生掛起。為什麼是可能呢？比如下面的程式碼雖然被suspend修飾，但實際並不會發生掛起：

private suspend fun test() {
    Log.d("liduo", "123")
}

由於會發生掛起，因此suspend方法只能在協程中使用。suspend方法內部可以呼叫其他的suspend方法，也可以非suspend方法。但suspend方法只能被其他的suspend方法呼叫。

5）withContext方法

suspend fun <T> withContext(
    context: CoroutineContext,
    block: suspend CoroutineScope.() -> T
): T

該方法用於在當前協程的執行過程中，切換到排程器指定的執行緒去執行引數block中的程式碼，並返回一個結果。呼叫該方法可能會使當前協程掛起，並在方法執行結束時恢復掛起。範例程式碼如下：

private suspend fun test() {
    // IO執行緒啟動並執行，啟動模式DEFAULT
    GlobalScope.launch(Dispatchers.IO) {
        Log.d("liduo", "start")
        // 執行緒主切換並掛起，泛型可省略，自動推斷
        val result = withContext<String>(Dispatchers.Main) {
            // 網路請求
            "json data"
        }
        // 切換回IO執行緒
        Log.d("liduo", result)
    }
}

6）suspend方法

inline fun <R> suspend(noinline block: suspend () -> R): suspend () -> R = block

該方法用於對掛起方法進行包裹，使掛起方法可以在非掛起方法中呼叫。該方法需要配合createCoroutine方法啟動協程。範例程式碼如下：

// 返回包含當前的協程程式碼的續體
val continuation = suspend {
    // 執行協程程式碼
    // 泛型可以修改需要的型別
}.createCoroutine(object : Continuation<Any> {
    override val context: CoroutineContext
        get() = EmptyCoroutineContext + Dispatchers.Main

    override fun resumeWith(result: Result<Any>) {
        // 獲取最終結果
    }
})
// 執行續體內容
continuation.resume(Unit)

一般開發中不會通過該方法啟動協程，但該方法可以更本質的展示協程的啟動、恢復、掛起。

2.協程間通訊

1）Channel

Channel用於協程間的通訊。Channel本質上是一個並行安全的佇列，類似BlockingQueue。在使用時，通過呼叫同一個Channel物件的send和receive方法實現通訊，範例程式碼如下：

suspend fun main() {
    // 建立
    val channel = Channel<Int>()
    val producer = GlobalScope.launch {
        var i = 0
        while (true){
            // 傳送
            channel.send(i++)
            delay(1000)
            // channel不需要時要及時關閉
            if(i == 10)
                channel.close()
        }
    }
    // 寫法1:常規
    val consumer = GlobalScope.launch {
        while(true){
            // 接收
            val element = channel.receive()
            Log.d("liduo", "$element")
        }
    }
    // 寫法2:迭代器
    val consumer = GlobalScope.launch {
        val iterator = channel.iterator()
        while(iterator.hasNext()){
            // 接收
            val element = iterator.next()
            Log.d("liduo", "$element")
        }
    }
    // 寫法3:增強for迴圈
    val consumer = GlobalScope.launch {
        for(element in channel){
            Log.d("liduo", "$element")
        }
    }
    // 上面的協程由於不是懶啟動，因此建立完成直接就會start去執行
    // 也就是說，程式碼走到這裡，上面的兩個協程已經開始工作
    // join方法會掛起當前協程，而不是上面已經啟動的兩個協程
    // 在Android環境中，下面兩行程式碼可以不用新增
    // producer.join()
    // consumer.join()
}

上述例子是一個經典的生產者-消費者模型。在寫法1中，由於send方法和receive方法被suspend關鍵字修飾，因此，在預設情況下，當生產速度與消費速度不匹配時，呼叫這兩個方法會導致協程掛起。

除此之外，Channel支援使用迭代器進行接收。其中，hasNext方法也可能會導致協程掛起。

Channel物件在不使用時要及時關閉，可以由傳送者關閉，也可以由接收者關閉，具體取決於業務場景。

2）Channel的容量

Channel方法不是Channel的構造方法，而是一個工廠方法，程式碼如下：

fun <E> Channel(capacity: Int = RENDEZVOUS): Channel<E> =
    when (capacity) {
        RENDEZVOUS -> RendezvousChannel()
        UNLIMITED -> LinkedListChannel()
        CONFLATED -> ConflatedChannel()
        BUFFERED -> ArrayChannel(CHANNEL_DEFAULT_CAPACITY)
        else -> ArrayChannel(capacity)
    }

在建立Channel時可以指定容量：

RENDEZVOUS：建立一個容量為0的Channel，類似於SynchronousQueue。send之後會掛起，直到被receive。列舉值為0。
UNLIMITED：建立一個容量無限的Channel，內部通過連結串列實現。列舉值為Int.MAX_VALUE。
CONFLATED：建立一個容量為1的Channel，當後一個的資料會覆蓋前一個資料。列舉值為-1。
BUFFERED：建立一個預設容量的Channel，預設容量為kotlinx.coroutines.channels.defaultBuffer設定變數指定的值，未設定情況下，預設為64。列舉值為-2。
如果capacity的值不為上述的列舉值，則建立一個指定容量的Channel。

3）produce方法與actor方法

fun <E> CoroutineScope.produce(
    context: CoroutineContext = EmptyCoroutineContext,
    capacity: Int = 0,
    @BuilderInference block: suspend ProducerScope<E>.() -> Unit
): ReceiveChannel<E>

fun <E> CoroutineScope.actor(
    context: CoroutineContext = EmptyCoroutineContext,
    capacity: Int = 0,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    onCompletion: CompletionHandler? = null,
    block: suspend ActorScope<E>.() -> Unit
): SendChannel<E>

與launch方法和async方法相同，使用produce方法與actor方法也可以啟動協程。但不同的是，在produce方法與actor方法中可以更簡潔的使用Channel。範例程式碼如下：

// 啟動協程，返回一個接收Channel
val receiveChannel: ReceiveChannel<Int> = GlobalScope.produce {
    while(true){
        delay(100)
        // 傳送
        send(1)
    }
}
// 啟動協程，返回一個傳送Channel
val sendChannel: SendChannel<Int> = GlobalScope.actor<Int> {
    while(true){
        // 接收
        val element = receive()
        Log.d("liduo","$element")
    }
}

produce方法與actor方法內部對Channel物件做了處理，當協程執行完畢，自動關閉Channel物件。

但目前，produce方法還處於試驗階段(被ExperimentalCoroutinesApi註解修飾)。而actor方法也已經過時(被ObsoleteCoroutinesApi註解修飾)。因此在實際開發中最好不要使用！

4）BroadcastChannel

當遇到一個傳送者對應多個接收者的場景時，可以使用BroadcastChannel。程式碼如下：

fun <E> BroadcastChannel(capacity: Int): BroadcastChannel<E> = 
    when (capacity) {
        0 -> throw IllegalArgumentException("Unsupported 0 capacity for BroadcastChannel")
        UNLIMITED -> throw IllegalArgumentException("Unsupported UNLIMITED capacity for BroadcastChannel")
        CONFLATED -> ConflatedBroadcastChannel()
        BUFFERED -> ArrayBroadcastChannel(CHANNEL_DEFAULT_CAPACITY)
        else -> ArrayBroadcastChannel(capacity)
    }

建立BroadcastChannel物件時，必須指定容量大小。接收者通過呼叫BroadcastChannel物件的openSubscription方法，獲取ReceiveChannel物件來接收訊息。範例程式碼如下：

// 建立BroadcastChannel，容量為5
val broadcastChannel = BroadcastChannel<Int>(5)
// 建立傳送者協程
GlobalScope.launch {
    // 傳送 1
    broadcastChannel.send(1)
    delay(100)
    // 傳送 2
    broadcastChannel.send(2)
    // 關閉
    broadcastChannel.close()
}.join()
// 建立接收者1協程
GlobalScope.launch {
    // 獲取ReceiveChannel
    val receiveChannel = broadcastChannel.openSubscription()
    // 接收
    for (element in receiveChannel) {
        Log.d("receiver_1: ", "$element")
    }
}.join()
// 建立接收者2協程
GlobalScope.launch {
    // 獲取ReceiveChannel
    val receiveChannel = broadcastChannel.openSubscription()
    // 接收
    for (element in receiveChannel) {
        Log.d("receiver_2: ", "$element")
    }
}.join()

每個接收者都可以收到傳送者傳送的每一條訊息。使用擴充套件方法broadcast可以直接將Channel物件轉化為BroadcastChannel物件，範例程式碼如下：

val channel = Channel<Int>()
val broadcastChannel = channel.broadcast(10)

BroadcastChannel的很多方法也處於試驗階段(被ExperimentalCoroutinesApi註解修飾)，使用時需慎重！

3.多路複用

協程中提供了類似Java中Nio的select方法，用於多路複用，程式碼如下：

suspend inline fun <R> select(crossinline builder: SelectBuilder<R>.() -> Unit): R

以Channel的多路複用為例，具體看一下select方法的使用。範例程式碼如下：

private suspend fun test() {
    // 建立一個Channel列表
    val channelList = mutableListOf<Channel<Int>>()
    // 假設其中有5個Channel
    channelList.add(Channel())
    channelList.add(Channel())
    channelList.add(Channel())
    channelList.add(Channel())
    channelList.add(Channel())
    // 呼叫select方法，協程掛起
    val result = select<Int> {
        // 對5個Channel進行註冊監聽，等待接收
        channelList.forEach {
            it.onReceive
        }
    }
    // 當5個Channel中任意一個接收到訊息時，select掛起恢復
    // 並將返回值賦給result
    Log.d("liduo", "$result")
}

除此之外，協程中還有很多介面定義了名字為"onXXX"的方法，比如Job介面的onJoin方法，Deferred介面的onAwait方法，都是用於配合select方法來進行多路複用。

4.序列生成器

協程中提供了sequence方法來生成序列。範例程式碼如下：

private suspend fun test() {
    // 建立一個可以輸出奇數的序列，泛型可省略，自動推斷
    val singleNumber = sequence<Int> {
        val i = 0
        while (true) {
            // 在需要輸出的地方呼叫yield方法
            yield(2 * i - 1)
        }
    }
    // 呼叫迭代器，獲取序列的輸出
    singleNumber.iterator().forEach {
        Log.d("liduo", "$it")
    }
    // 獲取序列前五項，迭代輸出
    singleNumber.take(5).forEach {
        Log.d("liduo", "$it")
    }
}

呼叫yield方法會使協程掛起，同時輸出這個序列當前生成的值。除此之外，也可以呼叫yieldAll方法來輸出序列產生值的合集，範例程式碼如下：

private suspend fun test() {
    // 建立一個可以輸出奇數的序列，泛型可省略，自動推斷
    val singleNumber = sequence<Int> {
        yieldAll(listOf(1,3,5,7))
        yieldAll(listOf(9,11,13))
        yieldAll(listOf(15,17))
    }
    // 呼叫迭代器，獲取序列的輸出，最多為9項
    singleNumber.iterator().forEach {
        Log.d("liduo", "$it")
    }
    // 獲取序列前五項，迭代輸出
    singleNumber.take(5).forEach {
        // 1，3，5，7，9
        Log.d("liduo", "$it")
    }    
}

5.協程非同步流

協程中提供了類似RxJava的響應式程式設計API——Flow(官方稱為非同步冷資料流，官方也提供了建立熱資料流的方法)。

1）基礎使用

// 在主執行緒上呼叫
GlobalScope.launch(Dispatchers.Main) {
    // 建立流
    flow<Int> {
        // 掛起，輸出返回值
        emit(1)
      // 設定流執行的執行緒，並消費流
    }.flowOn(Dispatchers.IO).collect {
            Log.d("liduo", "$it")
        }
}.join()

emit方法是一個掛起方法，類似sequence中的yield方法，用於輸出返回值。flowOn方法等同於Rxjava中的subscribeOn方法，用於切換flow執行的執行緒。為了避免理解混淆，Flow中沒有提供類似Rxjava中的observeOn方法，但可以通過指定流所在協程的上下文引數確定。collect方法等同於RxJava中的subscribe方法，用於觸發和消費流。

一個流可以被多次消費，範例程式碼如下：

GlobalScope.launch(Dispatchers.IO) {
    val mFlow = flow<Int> {
        emit(1)
    }.flowOn(Dispatchers.Main)
    mFlow.collect { Log.d("liduo1", "$it") }
    mFlow.collect { Log.d("liduo2", "$it") }
}.join()

2）例外處理

Flow支援類似try-catch-finally的例外處理。範例程式碼如下：

flow<Int> {
    emit(1)
    // 丟擲異常
    throw NullPointerException()
}.catch { cause: Throwable ->
    Log.d("liduo", "${cause.message}")
}.onCompletion { cause: Throwable? ->
    Log.d("liduo", "${cause?.message}")
}

catch方法用於捕獲異常。onCompletion方法等同於finally程式碼塊。Kotlin不建議直接在flow中通過try-catch-finally程式碼塊去捕獲異常！

Flow中還提供了類似RxJava的onErrorReturn方法的操作，範例程式碼如下：

flow<Int> {
    emit(1)
    // 丟擲異常
    throw NullPointerException()
}.catch { cause: Throwable ->
    Log.d("liduo", "${cause.message}")
    emit(-1)
}

3）觸發分離

Flow支援提前寫好流的消費，在必要的時候再去觸發消費的操作。範例程式碼如下：

// 建立Flow的方法
fun myFlow() = flow<Int> {
    // 生產過程
    emit(1)
}.onEach {
    // 消費過程
    Log.d("liduo", "$it")
}
suspend fun main() {
    // 寫法1
    GlobalScope.launch {
        // 觸發消費
        myFlow().collect()
    }.join()
    // 寫法2
    myFlow().launchIn(GlobalScope).join()
}

4）注意

Flow中不提供取消collect的方法。如果要取消flow的執行，可以直接取消flow所在的協程。
emit方法不是執行緒安全的，因此不要在flow中呼叫withContext等方法切換排程器。如果需要切換，可以使用channelFlow。

6.全域性上下文

在本文中，啟動協程使用的都是GlobalScope，但在實際開發過程中，不應該使用GlobalScope。GlobalScope會開啟一個全新的協程作用域，並且不受我們控制。假設Activity頁面關閉時，其中的協程還沒有執行結束，並且我們還無法取消協程的執行，這時可能會導致記憶體漏失。因此，在實際開發中，可以自定義一個全域性的協程作用域，或者至少按照以下方法書寫程式碼：

// 實現CoroutineScope介面
class MainActivity : AppCompatActivity(),CoroutineScope by MainScope() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 直接啟動協程
        launch {
            Log.d("liduo", "launch")
        }
    }
    override fun onDestroy() {
        super.onDestroy()
        // 取消頂級父協程
        cancel()
    }
}

MainScope的程式碼如下：

public fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)

Dispatchers.Main表示在主執行緒排程，SupervisorJob()表示子協程取消不會影響父協程。

到此這篇關於Kotlin協程概念原理與使用萬字梳理的文章就介紹到這了,更多相關Kotlin協程內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！