Kotlin之深入理解协程

冷不防 2022-11-27 03:24 379阅读 0赞

## 1 协程基础 ##

### 1.1 带问题理解协程 ###

GlobalScope.launch(Dispatchers.Main) {
        
         suspendSimpleDelay()
    }
    
    suspend fun suspendSimpleDelay(): Unit {
        
         withContext(Dispatchers.IO) {
        
              delay(10000) 
         }
    }

### 1.2 Kotlin协程中挂起的是什么？ ###

协程。

### 1.3 什么是协程？ ###

**kotlin协程为launch()、async() 等中的代码，协同多个程序之间进行合作，帮助我们轻松的写出复杂的并发代码。launch在创建的一个协程，在执行到某一个suspend函数(挂起函数)时，这个协程会被 suspend(被挂起)。**

### 1.4 协程是执行在单线程中的吗？ ###

协程本质上还是一套基于原生Java Thread API 的封装。只要没有魔改JVM，start了几个线程，操作系统就会创建几个线程；**Kotlin协程只是做了一个类似线程池的封装，根本谈不上什么性能更好。协程是协作式任务，线程是抢占式任务，本质上两者都属于并发**。

### 1.5 什么时候要用到协程的？ ###

**需要切换线程的时候要用到协程**。

#### 1.5.1 挂起是怎么做到的？ ####

**在suspend修饰的挂起函数中，调用另外一个协程自带的、内部实现了协程挂起代码的挂起函数withContext()，让它来做真正的挂起，实现线程切换的工作**。

#### 1.5.2 挂起的本质是什么？ ####

**挂起的本质是切线程**。

#### 1.5.3 既然suspend不能真正的做到挂起函数，那么suspend的作用是什么呢? ####

（1）**作用是：提醒，提醒调用者该函数为耗时操作，避免主线程调用了一个耗时操作。因此创建一个挂起函数，一定要在内部调用别的挂起函数，否则这个挂起函数就是没有必要的**。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center]  
（2）withContext的两种写法：

private suspend fun doWord(): Int {
          // 写法1
        withContext(Dispatchers.IO) {
        
        	delay(5000L)
            LogUtils.d(TAG, "suspendLaunch World! ${Thread.currentThread()}")
        }
        return 1
    }
    
    private suspend fun doWord2(): Int = withContext(Dispatchers.IO) {
         // 写法2
    	delay(5000L)
        LogUtils.d(TAG, "suspendLaunch World! ${Thread.currentThread()}")
        return@withContext 1
    }

（3）挂起函数 suspend 的例子

/**
         * 挂起函数 suspend，演示了launch(Dispatchers.Main)-->通过withContext(Dispatchers.IO)——>切换到IO线程
         * 计算过程阻塞运行该代码的主线程 当这些值由异步代码计算时，我们可以使用 suspend 修饰符标记函数 simple，
         * 这样它就可以在不阻塞的情况下执行其工作并将结果作为列表返回：
         */
        private fun suspend() {
        
            LogUtils.d(TAG, "suspend start")
            // suspend 修饰的挂起函数。挂起的含义就是：暂时切走，稍后在切回来；就是切换线程，不过在执行完毕会切换回来。
            // 什么时候需要自定义挂起函数：耗时(特殊：等待)
            // 怎么写挂起函数：添加关键字 suspend，内部代码使用 withContext 获取他挂起函数包裹
            suspend fun simpleDelay(): Int {
        
                LogUtils.d(TAG, "simpleDelay1 ${Thread.currentThread().name}")
                // withContext使用新CoroutineContext-->中Dispatchers.IO的dispatcher，
                // 将[块]的执行转移到 不同的线程，如果指定了一个新的调度程序，并返回到原始的调度程序
                withContext(Dispatchers.IO) {
        
                    LogUtils.d(TAG, "simpleDelay withContext1 ${Thread.currentThread().name}")
                    // 假装我们在这里做了一些异步的事情
                    delay(3000)
                    LogUtils.d(TAG, "simpleDelay withContext2 ${Thread.currentThread().name}")
                }
                LogUtils.d(TAG, "simpleDelay2 ${Thread.currentThread().name}")
                return 11111
            }
    
            LogUtils.d(TAG, "suspend middle")
    //        runBlocking<Unit> { } // 注意：runBlocking{ }是会阻塞当前线程来等待
            GlobalScope.launch(Dispatchers.Main) {
        
                LogUtils.e(TAG, "I'm working1 in thread ${Thread.currentThread().name}")
                // 挂起函数（子线程）执行完后，返回结果，再在协程中（主线程）获取其值
                val result = simpleDelay()
                LogUtils.e(TAG, "I'm working2 result：${result} in thread ${Thread.currentThread().name}")
                LogUtils.e(TAG, "I'm working2 in thread ${Thread.currentThread().name}")
            }
            LogUtils.d(TAG, "suspend over")
    
    //        CoroutineActivity :: suspend start
    //        CoroutineActivity :: suspend middle
    //        CoroutineActivity :: suspend over
    
    //        CoroutineActivity :: I'm working1 in thread main
    //        CoroutineActivity :: simpleDelay1 main
    //        CoroutineActivity :: simpleDelay withContext1 DefaultDispatcher-worker-1
    //        CoroutineActivity :: simpleDelay withContext2 DefaultDispatcher-worker-1
    //        CoroutineActivity :: simpleDelay2 main
    //        CoroutineActivity :: I'm working2 result：11111 in thread main
    //        CoroutineActivity :: I'm working2 in thread main
        }

#### 1.5.4 从哪挂起？ ####

**从当前正在执行它的线程挂起(脱离)，将协程挂到自己指定的线程中去执行，在执行完毕会切换回来；分离后当前的线程不会卡住，该干嘛干嘛去。**

#### 1.5.5 为什么挂起函数只能在协程里或者另一个挂起函数中调用？ ####

**挂起之后是需要恢复的，也就是把线程给切回来，而恢复这个动作必须由协程实现**。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 1]

[“吹Kotlin协程的，可能吹错了！” 带你真正理解一波][Kotlin_]

## 2 协程如何使用 ##

### 2.1 三种方式创建协程？ ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 2]

#### 2.1.1 runBlocking和coroutineScope这两个 作用域构建器 的区别？ ####

(1)runBlocking作用域构建器，通常适用于单元测试的场景，而业务开发中不会用到这种方法，因为它是线程阻塞的。

(2)本质上runBlocking是创建了Coroutinescope对象，构造成协程作用域，并实现了线程阻塞逻辑。

(3)**runBlocking方法会阻塞当前线程来等待，而coroutineScope只是挂起，会释放底层线程用于其他用途**。

// 作用域构建器：创建一个协程作用域
    coroutineScope {
         
    	launch {
        
    		delay(500L)
    		LogUtils.d(TAG, "coroutineScopes Task2 from nested launch")
        }
        delay(100L)
        LogUtils.d(TAG, "coroutineScopes Task3 from coroutine scope") // 这一行会在内嵌 launch 之前输出
    }
    LogUtils.d(TAG, "coroutineScopes 4 Coroutine scope is over") // 这一行在内嵌 launch 执行完毕后才输出

#### 2.1.2 自行通过CoroutineContext创建一个CoroutineScope对象，管理协程的生命周期 ####

/**
         * 通过协程作用域，管理协程的生命周期
         */
    
        /**
         * 通过创建一个 作用域：CoroutineScope 实例来管理协程的生命周期，并使它与 activity 的生命周期相关联。
         * 作用域：CoroutineScope 可以通过 CoroutineScope() 创建，或者通过 MainScope() 工厂函数创建
         */
        private val mainScope = CoroutineScope(Dispatchers.Default)  // private val mainScope = MainScope()
    
        private fun coroutineScopeLife() {
        
            runBlocking<Unit> {
        
                LogUtils.d(TAG, "Launched coroutines")
                doSomething() // 运行测试函数
            }
    //        kotlin + CoroutineActivity :: Coroutine 0 is done
    //        kotlin + CoroutineActivity :: Coroutine 1 is done
    //        kotlin + CoroutineActivity :: Coroutine 2 is done
    //        kotlin + CoroutineActivity :: Coroutine 3 is done
    //        kotlin + CoroutineActivity :: Coroutine 4 is done
    //        kotlin + CoroutineActivity :: destroyCoroutineScope，取消协程作用域
        }
    
        fun doSomething() {
        
            // 在示例中启动了 10 个协程，且每个都工作了不同的时长
            repeat(100) {
         i ->
                mainScope.launch {
        
                    delay((i + 1) * 500L) // 延迟 200 毫秒、400 毫秒、600 毫秒等等不同的时间
                    LogUtils.d(TAG, "Coroutine $i is done")
                }
            }
        }
    
        // Activity类结束时取消协程作用域
        fun destroyCoroutineScope() {
        
            mainScope.cancel()
            LogUtils.d(TAG, "destroyCoroutineScope，取消协程作用域")
        }

![在这里插入图片描述][20201227203152102.png]

### 2.2 协程实现合并请求？ ###

（1）方法一  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 3]  
（2）方法二  
![在这里插入图片描述][2020082313470485.png_pic_center]

## 8 源码 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 2]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][20210403221025418.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 6]

设计如此："Return suspended." 作为 resume 的参数传入，返回值就是 continuation 的 resume 参数
    
    而 suspend 函数调用之后的代码就是 continuation 的回调，即是 resume 函数中代码，
    
    本质上就是通过这个参数来获取所谓的返回值的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 8]

val result = runSuspend()
    println(result)
    
    // 本质上就是 
    runSuspend(new Continuation {
          
    	void resume(String result) {
          
    		System.out.println(result); 
    	}  
    }

SuspendLambda -> ContinuationImpl -> BaseContinuationImpl -> Continuation

**启动协程流程是 resume(Unit)->resumeWith()->invokeSuspend()，协程的挂起通过 suspend 挂起函数实现，协程的恢复通过 Continuation.resumeWith 实现**。

[Kotlin Jetpack 实战：图解协程原理][Kotlin Jetpack]

[破解 Kotlin 协程(6) - 协程挂起篇][Kotlin _6_ -]

[Kotlin Coroutines(协程) 完全解析（二），深入理解协程的挂起、恢复与调度][Kotlin Coroutines_]

## 9 学习链接 ##

[1、扔物线-Kotlin协程1：Kotlin 的协程用力瞥一眼 - 学不会协程？][1_-Kotlin_1_Kotlin _ -]

[2、扔物线-Kotlin协程2：Kotlin 协程的挂起好神奇好难懂？][2_-Kotlin_2_Kotlin]

[3、扔物线-Kotlin协程3：到底什么是「非阻塞式」挂起？协程真的更轻量级吗？][3_-Kotlin_3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/0112f156669649eba227d182245e806d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221124/cdadf0a5281e4eab8a7d695a7df10306.png
[Kotlin_]: https://mp.weixin.qq.com/s/N5mCacpoxGIvS_ASDAiQDQ
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221124/f91a80e57e9e490e9d77e3f38a7e93ff.png
[20201227203152102.png]: /images/20221124/449fda1c682749b9a0bbf94d70e849d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221124/960495cbebaf4550bb019f2ef3ed2db2.png
[2020082313470485.png_pic_center]: /images/20221124/6c2ed390614d42e7802aa6fdf9a5273e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70]: /images/20221124/d3d9bc30edf8400da324d91e998f4c83.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 1]: /images/20221124/8f17fee67b8744639c2116745a568fc9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 2]: /images/20221124/eb1c9fe3c2c74530b9de5e3bc01a2182.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 3]: /images/20221124/86bb5e08d2004becbe687f01cfac6fb2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 4]: /images/20221124/bf4756b85dc5420b90d2d68d51d314d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 5]: /images/20221124/1c3ed39876f441fe8e0e44cb84a17806.png
[20210403221025418.png]: /images/20221124/274740e08f3744218d9380c8b9e2c9a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 6]: /images/20221124/dc5a1847db034148a244ce9376742f19.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 7]: /images/20221124/81b15e1059994d539aa7a4b54a6f72fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70 8]: /images/20221124/d3bc2a45f50545ad8ea940a5f6cf5be6.png
[Kotlin Jetpack]: https://mp.weixin.qq.com/s/7nAs1T4hh_lGpEEEYjTVDg
[Kotlin _6_ -]: https://zhuanlan.zhihu.com/p/65651040?from_voters_page=true
[Kotlin Coroutines_]: https://www.jianshu.com/p/2979732fb6fb?from=singlemessage
[1_-Kotlin_1_Kotlin _ -]: https://kaixue.io/kotlin-coroutines-1/
[2_-Kotlin_2_Kotlin]: https://kaixue.io/kotlin-coroutines-2/
[3_-Kotlin_3]: https://kaixue.io/kotlin-coroutines-3/