日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

Kotlin啟動協程的三種方式示例詳解_Android

作者：無糖可樂愛好者 ? 更新時間： 2023-01-05 編程語言

1.launch啟動協程

fun main() = runBlocking {
    launch { 
        delay(1000L) 
        println("World!") 
    }
    println("Hello") 
}
fun main() {
    GlobalScope.launch {
        delay(1000L)
        println("World!")
    }
    println("Hello")
    Thread.sleep(2000L)
}
//輸出結果
//Hello
//World!

上面是兩段代碼，這兩段代碼都是通過launch啟動了一個協程并且輸出結果也是一樣的。

第一段代碼中的runBlocking是協程的另一種啟動方式，這里先看第二段代碼中的launch的啟動方式；

  • GlobalScope.launch

GlobalScope.launch是一個擴展函數，接收者是CoroutineScope，意思就是協程作用域，這里的launch等價于CoroutineScope的成員方法，如果要調用launch來啟動一個協程就必須先拿到CoroutineScope對象。GlobalScope.launch源碼如下

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

里面有三個參數：

  • context： 意思是上下文，默認是EmptyCoroutineContext，有默認值就可以不傳，但是也可以傳遞Kotlin提供的Dispatchers來指定協程運行在哪一個線程中；
  • start： CoroutineStart代表了協程的啟動模式，不傳則默認使用DEFAULT(根據上下文立即調度協程執行)，除DEFAULT外還有其他類型：

LAZY：延遲啟動協程，只在需要時才啟動。

ATOMIC：以一種不可取消的方式，根據其上下文安排執行的協程；

UNDISPATCHED：立即執行協程，直到它在當前線程中的第一個掛起點；

  • block： suspend是掛起的意思，CoroutineScope.()是一個擴展函數，Unit是一個函數類似于Java的void，那么suspend CoroutineScope.() -> Unit就可以這么理解了：首先，它是一個掛起函數，然后它還是CoroutineScope類的成員或者擴展函數，參數為空，返回值類型為Unit。
  • delay()： delay()方法從字面理解就是延遲的意思，在上面的代碼中延遲了1秒再執行World，從源碼可以看出來它跟其他方法不一樣，多了一個suspend關鍵字
//      掛起
//       ↓
public suspend fun delay(timeMillis: Long) {
    if (timeMillis <= 0) return // don't delay
    return suspendCancellableCoroutine sc@ { cont: CancellableContinuation<Unit> ->
        // if timeMillis == Long.MAX_VALUE then just wait forever like awaitCancellation, don't schedule.
        if (timeMillis < Long.MAX_VALUE) {
            cont.context.delay.scheduleResumeAfterDelay(timeMillis, cont)
        }
    }
}

suspend的意思就是掛起，被它修飾的函數就是掛起函數， 這也就意味著delay()方法具有掛起和恢復的能力；

  • Thread.sleep(2000L)

這個是休眠2秒，那么這里為什么要有這個呢？要解答這疑問其實不難，將Thread.sleep(2000L)刪除后在運行代碼可以發現只打印了Hello然后程序就結束了，World!并沒有被打印出來。

為什么？ 將上面的代碼轉換成線程實現如下：

fun main() {
    thread(isDaemon = true) {
        Thread.sleep(1000L)
        println("Hello World!")
    }
}

如果不添加isDaemon = true結果輸出正常，如果加了那么就沒有結果輸出。isDaemon的加入后其實是創建了一個【守護線程】，這就意味著主線程結束的時候它會跟著被銷毀，所以對于將Thread.sleep刪除后導致GlobalScope創建的協程不能正常運行的主要原因就是通過launch創建的協程還沒開始執行程序就結束了。那么Thread.sleep(2000L)的作用就是為了不讓主線程退出。

另外這里還有一點需要注意：程序的執行過程并不是按照順序執行的。

fun main() {
    GlobalScope.launch {                // 1
        println("Launch started!")      // 2
        delay(1000L)                    // 3
        println("World！")         	   // 4
    }
    println("Hello")            		// 5
    Thread.sleep(2000L)                 // 6
    println("Process end!")             // 7
}
/*
輸出結果：
Hello
Launch started!
World！
Process end!
*/

上面的代碼執行順序是1、5、6、2、3、4、7，這個其實好理解，首先執行1，然后再執行5，執行6的時候等待2秒，在這個等待過程中協程創建完畢了開始執行2、3、4都可以執行了，當2、3、4執行完畢后等待6執行完畢，最后執行7，程序結束。

2.runBlocking啟動協程

fun main() {
    runBlocking {                // 1
        println("launch started!")      // 2
        delay(1000L)           // 3
        println("World！")         	    // 4
    }
    println("Hello")            		// 5
    Thread.sleep(2000L)           // 6
    println("Process end!")             // 7
}

上面這段代碼只是將GlobalScope.launch改成了runBlocking，但是執行順序卻完全不一樣，它的執行順訊為代碼順序1~7，這是因為runBlocking是帶有阻塞屬性的，它會阻塞當前線程的執行。這是它跟launch的最大差異。

runBlocking與lanuch的另外一個差異是GlobalScope，從代碼中可以看出runBlocking并不需要這個，這點可以從源碼中分析

public actual fun <T> runBlocking(
    context: CoroutineContext, 
    block: suspend CoroutineScope.() -> T): T {
    ...
}

頂層函數：類似于Java中的靜態函數，在Java中常用與工具類，例如StringUtils.lastElement();

runBlocking是一個頂層函數，因此可以直接使用它；在它的第二個參數block中有一個返回值類型：T，它剛好跟runBlocking的返回值類型是一樣的，因此可以推測出runBlocking是可以有返回值的

fun main() {
    val result = test(1)
    println("result:$result")
}
fun test(num: Int) = runBlocking {
    return@runBlocking num.toString()
}
//輸出結果：
//result:1

但是，Kotlin在文檔中注明了這個函數不應該從協程中使用。它的設計目的是將常規的阻塞代碼與以掛起風格編寫的庫連接起來，以便在主函數和測試中使用。 因此在正式環境中這種方式最好不用。

3.async啟動協程

在 Kotlin 當中，可以使用 async{} 創建協程，并且還能通過它返回的句柄拿到協程的執行結果。

fun main() = runBlocking {
    val deferred = async {
        1 + 1
    }
    println("result:${deferred.await()}")
}
//輸出結果：
//result:2

上面的代碼啟動了兩個協程，啟動方式是runBlocking和async，因為async的調用需要一個作用域，而runBlocking恰好滿足這個條件，GlobalScope.launch也可以滿足這個條件但是GlobalScope也不建議在生產環境中使用，因為GlobalScope 創建的協程沒有父協程，GlobalScope 通常也不與任何生命周期組件綁定。除非手動管理，否則很難滿足我們實際開發中的需求。

上面的代碼多了一個deferred.await()它就是獲取最終結果的關鍵。

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T> {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyDeferredCoroutine(newContext, block) else
        DeferredCoroutine<T>(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

async和launch一樣也是一個擴展函數，也有三個參數，和launch的區別在于兩點：

  • block的函數類型： launch返回的是Unit類型，async返回的是泛型T
  • 返回值不同： launch返回的是Job，async返回的是Deffered<T>，而async可以返回執行結果的關鍵就在這里。

啟動協程的三種方式都講完了，這里存在一個疑問，launch和async都有返回值，為什么async可以獲取執行結果，launch卻不行？

這主要跟launch的返回值有關，launch的返回值Job代表的是協程的句柄，而句柄并不能返回協程的執行結果。

句柄： 句柄指的是中間媒介，通過這個中間媒介可以控制、操作某樣東西。舉個例子，door handle 是指門把手，通過門把手可以去控制門，但 door handle 并非 door 本身，只是一個中間媒介。又比如 knife handle 是刀柄，通過刀柄可以使用刀。

協程的三中啟動方式區別如下：

  • launch：無法獲取執行結果，返回類型Job，不會阻塞；
  • async：可獲取執行結果，返回類型Deferred，調用await()會阻塞不調用則不會但也無法獲取執行結果；
  • runBlocking：可獲取執行結果，阻塞當前線程的執行，多用于Demo、測試，官方推薦只用于連接線程與協程。

原文鏈接：https://juejin.cn/post/7171981069720223751

欄目分類
最近更新