kotlin協程小記

例子一：

GlobalScope.launch(Dispatchers.Main) {
    //開啟子協程
    withContext(Dispatchers.IO) {
        for (i in 0 until 1000) {
        }
        Log.d("MainActivityXX", "withContext-> thread:" + Thread.currentThread().name)
    }
    Log.d("MainActivityXX", "GlobalScope-> thread:" + Thread.currentThread().name)
}
Log.d("MainActivityXX", "onCreate-> thread:" + Thread.currentThread().name)

列印log：

2022-10-09 20:24:21.100 8371-8371/com.example.xiecheng D/MainActivityXX: onCreate-> thread:main
2022-10-09 20:24:21.131 8371-8412/com.example.xiecheng D/MainActivityXX: withContext-> thread:DefaultDispatcher-worker-1
2022-10-09 20:24:21.258 8371-8371/com.example.xiecheng D/MainActivityXX: GlobalScope-> thread:main

例子二：

GlobalScope.launch(Dispatchers.Main) {
    //開啟子協程
    withContext(Dispatchers.IO) {
        for (i in 0 until 1000) {
        }
        Log.d("MainActivityXX", "withContext1-> thread:" + Thread.currentThread().name)
        withContext(Dispatchers.IO) {
            for (i in 0 until 1000) {
            }
            Log.d("MainActivityXX", "withContext2-> thread:" + Thread.currentThread().name)
        }
    }
    withContext(Dispatchers.IO) {
        for (i in 0 until 1000) {
        }
        Log.d("MainActivityXX", "withContext3-> thread:" + Thread.currentThread().name)
    }
    Log.d("MainActivityXX", "GlobalScope-> thread:" + Thread.currentThread().name)
}
Log.d("MainActivityXX", "onCreate-> thread:" + Thread.currentThread().name)

列印log：

onCreate-> thread:main
withContext1-> thread:DefaultDispatcher-worker-1
withContext2-> thread:DefaultDispatcher-worker-1
withContext3-> thread:DefaultDispatcher-worker-1
GlobalScope-> thread:main

主線程開啟一個協程，並不會阻礙主線程的執行，單個協程內部是串列執行的，這裡整一個都是串列執行的是因為withContext是一個掛起函數。

GlobalScope.launch(Dispatchers.Main) {
    //開啟子協程
    GlobalScope.launch (Dispatchers.IO) {
        Log.d("MainActivityXX", "withContext-> thread:" + Thread.currentThread().name)
    }
    Log.d("MainActivityXX", "GlobalScope-> thread:" + Thread.currentThread().name)
}

列印log：

GlobalScope-> thread:main
withContext-> thread:DefaultDispatcher-worker-1

例子二：

GlobalScope.launch(Dispatchers.Main) {
    //開啟子協程
    withContext(Dispatchers.IO) {
        get()
        Log.d("MainActivityXX", "withContext-> thread:" + Thread.currentThread().name)
    }
    Log.d("MainActivityXX", "GlobalScope-> thread:" + Thread.currentThread().name)
}

suspend fun get() {
    Thread {
        Thread.sleep(5000)
        Log.d("MainActivityXX", "get-> thread:" + Thread.currentThread().name)
    }.start()
}

列印log：

2022-11-01 20:56:25.220 20058-20100/com.example.xiecheng D/MainActivityXX: withContext-> thread:DefaultDispatcher-worker-1
2022-11-01 20:56:25.264 20058-20058/com.example.xiecheng D/MainActivityXX: GlobalScope-> thread:main
2022-11-01 20:56:30.222 20058-20103/com.example.xiecheng D/MainActivityXX: get-> thread:Thread-8

協程裡面開啟線程，那麼線程不會受協程影響。

例子三：

GlobalScope.launch(Dispatchers.Main) {
    fetchDocs()
}

suspend fun fetchDocs() {                             // Dispatchers.Main
    val result = get("https://developer.android.com") // Dispatchers.IO for `get`
    Log.d("MainActivityXX", "fetchDocs-> thread:" + Thread.currentThread().name) 
}
//withContext本身就是掛起函數
suspend fun get(url: String) = withContext (Dispatchers.IO) {
    Log.d("MainActivityXX", "get-> thread:" + Thread.currentThread().name)
}

列印log：

get-> thread:DefaultDispatcher-worker-1
fetchDocs-> thread:main

使用了掛起函數，會先等待get方法執行完再執行下麵得操作。

1、掛起函數並不會阻塞其所線上程，這樣就極大地提高了線程的併發靈活度，最大化了線程的利用效率。
當在 ThreadA 上運行的 CoroutineA 調用了delay(1000L)函數指定延遲一秒後再運行，ThreadA 會轉而去執行 CoroutineB，等到一秒後再來繼續執行 CoroutineA

2、withContext本身就是掛起函數。

3、掛起的對象是協程。

4、這個 suspend 關鍵字，既然它並不是真正實現掛起，它其實是一個提醒。函數的創建者對函數的使用者的提醒：我是一個耗時函數，我被我的創建者用掛起的方式放在後臺運行，所以請在協程里調用我。
為什麼 suspend 關鍵字並沒有實際去操作掛起，但 Kotlin 卻把它提供出來？
因為它本來就不是用來操作掛起的。掛起的操作 —— 也就是切線程，依賴的是掛起函數裡面的實際代碼，而不是這個關鍵字。
所以這個關鍵字，只是一個提醒。
所以，創建一個 suspend 函數，為了讓它包含真正掛起的邏輯，要在它內部直接或間接調用 Kotlin 自帶的 suspend 函數，你的這個 suspend 才是有意義的。

5、所以這個 suspend，其實並不是起到把任何把協程掛起，或者說切換線程的作用。真正掛起協程這件事，是 Kotlin 的協程框架幫我們做的。
所以我們想要自己寫一個掛起函數，僅僅只加上 suspend 關鍵字是不行的，還需要函數內部直接或間接地調用到 Kotlin 協程框架自帶的 suspend 函數才行。

6、開發者需要明白，協程是運行於線程上的，一個線程可以運行多個（可以是幾千上萬個）協程。線程的調度行為是由 OS 來操縱的，而協程的調度行為是可以由開發者來指定並由編譯器來實現的。當協程 A 調用 delay(1000L) 函數來指定延遲1秒後再運行時，協程 A 所在的線程只是會轉而去執行協程 B，等到1秒後再把協程 A 加入到可調度隊列里。所以說，線程並不會因為協程的延時而阻塞，這樣可以極大地提高線程的併發靈活度。