• Kotlin 进阶版 协程

    kotlin是协程的一种实现

    1. Dispatchers.IO：适用于执行磁盘或网络 I/O 操作的调度器，例如文件读写、网络请求等。在 Android 中，Dispatchers.IO 会使用一个专门的线程池来处理这些操作，以防止阻塞主线程。

    2. Dispatchers.Main：适用于处理与 UI 相关的操作的调度器，例如更新 UI 界面、响应用户输入等。在 Android 中，Dispatchers.Main 通常会将协程切换到主线程执行，确保 UI 操作在主线程中进行。

    3. Dispatchers.Unconfined：不对协程的执行环境做任何限制，使用该调度器时，协程将在调用它的线程中执行，直到遇到挂起函数为止，之后会在恢复执行时继续在之前的线程中执行。

    4. Dispatchers.Default：适用于执行 CPU 密集型任务的调度器，例如算法计算、数据处理等。Dispatchers.Default 在 Android 中会使用一个共享的线程池来处理这些任务，以便在多个协程之间进行合理的调度。

     

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.CoroutineScope
    4. import kotlinx.coroutines.Dispatchers
    5. import kotlinx.coroutines.delay
    6. import kotlinx.coroutines.launch
    7. import kotlinx.coroutines.withContext
    8.  
    9. fun main() {
    10.     //IO线程  超大密集的计算 Default
    11.  
    12.     /**
    13.      * IO
    14.      * Default
    15.      * Main
    16.      *
    17.      */
    18.     CoroutineScope(Dispatchers.IO).launch {
    19.         test()
    20. //        withContext(Dispatchers.Main){
    21. //
    22. //        }
    23.     }
    24.     println("主线程")
    25.     Thread.sleep(2000)
    26. }
    27.  
    28. /**
    29.  * 协程代码块
    30.  */
    31. suspend fun test() {
    32.     println("协程开始")
    33.     delay(1000)
    34.     println("协程结束")
    35. }

    1.runBlocking

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.Dispatchers
    4. import kotlinx.coroutines.delay
    5. import kotlinx.coroutines.runBlocking
    6.  
    7. fun main() {
    8.     println("hello")
    9.     //如果给的参数第一个为空，那么它会去找到这个协程外面调用它的这个线程 一般在写Test的时候才用一下 阻塞式协程
    10.     val i = runBlocking (Dispatchers.IO){
    11.         //如果制定了了调度器，它会被分配到另一个线程上面执行 ,但也可以阻塞当前线程
    12.         println(
    13.             Thread.currentThread().name
    14.         )
    15.         //这个协程会阻塞当前线程 同步执行
    16.         delay(2000)
    17.         1
    18.     }
    19.     println(
    20.         Thread.currentThread().name
    21.     )
    22.     println("world $i ")
    23. }

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.Dispatchers
    4. import kotlinx.coroutines.delay
    5. import kotlinx.coroutines.launch
    6. import kotlinx.coroutines.runBlocking
    7.  
    8. fun main() {
    9.     println("hello")
    10.     //如果给的参数第一个为空，那么它会去找到这个协程外面调用它调度器 一般在写Test的时候才用一下 阻塞式协程
    11.     //会等里面所有的协程执行完了，才会释放主线程
    12.     val i = runBlocking (Dispatchers.IO){
    13.         //如果制定了了调度器，它会被分配到另一个线程上面执行 ,但也可以阻塞当前线程
    14.         println(
    15.             Thread.currentThread().name
    16.         )
    17.  
    18.         println(this)
    19.         //this :BlockingCoroutine 可以再次开启一个协程
    20.         val job = this.launch {
    21.             //这个开启的协程不会阻塞当前线程，异步
    22.             println(
    23.                 //没有指定 ，他会默认继承上面所在的调度器 被这个调度器管理的线程池的线程去执行
    24.                 Thread.currentThread().name
    25.             )
    26.             delay(5200)
    27.         }
    28.  
    29.         println(job.isActive)
    30.         println(job.cancel())
    31.         println(job.isActive)
    32.         println("延迟了吗")
    33.  
    34.  
    35.         //这个协程会阻塞当前线程 同步执行
    36.         delay(2000)
    37.         1
    38.     }
    39.     println(
    40.         Thread.currentThread().name
    41.     )
    42.     println("world $i ")
    43.  
    44.  
    45.     /**
    46.      * 总结
    47.      * IO 网络请求 数据库
    48.      * default 密集型数据处理操作 数据计算
    49.      * main UI操作
    50.      *
    51.      */
    52. }

     

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.Dispatchers
    4. import kotlinx.coroutines.delay
    5. import kotlinx.coroutines.runBlocking
    6. import kotlinx.coroutines.withContext
    7.  
    8. fun main() {
    9.     println("hello")
    10.     val i = runBlocking (Dispatchers.IO){
    11.  
    12.             request{
    13.                 //手动切换到UI线程里
    14.                 withContext(Dispatchers.Main){
    15.                     //修改UI
    16.                 
    17.  
    18.                 }
    19.  
    20.             }
    21.  
    22.     }
    23.     println("world $i")
    24. }
    25.  
    26. suspend fun request(finish:suspend ()->Unit){
    27.     delay(3000)
    28.     println("网络请求成功")
    29.     finish()
    30. }

    好处：不会出现在其他的线程里出现UI报错的问题了

    2.GlobalScope

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.GlobalScope
    4. import kotlinx.coroutines.delay
    5. import kotlinx.coroutines.launch
    6.  
    7. fun main() {
    8.     val launch = GlobalScope.launch { //全局指的是整个程序的生命周期 就算Activity销毁了这个GlobalScope还是存在的
    9.         // 这样可能会造成一些奇怪的问题
    10.         delay(3000)
    11.         println("hello")
    12.     }//这不是阻塞当前线程的一个协程操作
    13.     val launch1 = GlobalScope.launch {
    14.  
    15.     }
    16.  
    17.     println(launch===launch1)
    18.     //不能调用cancel 方法,因为作用域是整个生命周期的，不能由我们来管理
    19.  
    20.     while (true);
    21. }

    3.CoroutineScope

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.CoroutineScope
    4. import kotlinx.coroutines.Dispatchers
    5. import kotlinx.coroutines.cancel
    6. import kotlinx.coroutines.delay
    7. import kotlinx.coroutines.launch
    8.  
    9. fun main() {
    10.     //推荐使用这个  不是全局的
    11.     val coroutineScope1 = CoroutineScope(Dispatchers.Default)
    12.  
    13.  
    14.     coroutineScope1.launch {
    15.        delay(3000)
    16.  
    17.         println("结束")
    18.     }
    19.     coroutineScope1.launch {
    20.         delay(3000)
    21.  
    22.         println("结束")
    23.     }
    24.     coroutineScope1.cancel() //可以手动进行取消，不会涉及到全局 整个程序的生命周期
    25.     Thread.sleep(4000)
    26.     println("主线程结束")
    27. }

    4.Launch分析

    4.1 第一个参数 context: CoroutineContext

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.CoroutineDispatcher
    4. import kotlinx.coroutines.CoroutineName
    5. import kotlinx.coroutines.CoroutineScope
    6. import kotlinx.coroutines.CoroutineStart
    7. import kotlinx.coroutines.Dispatchers
    8. import kotlinx.coroutines.InternalCoroutinesApi
    9. import kotlinx.coroutines.Job
    10.  
    11. import kotlinx.coroutines.launch
    12. import kotlinx.coroutines.newCoroutineContext
    13. import kotlinx.coroutines.runBlocking
    14. import kotlin.coroutines.CoroutineContext
    15. import kotlin.coroutines.EmptyCoroutineContext
    16.  
    17. @OptIn(ExperimentalStdlibApi::class)
    18. fun main() {
    19.  
    20.  
    21.     val runBlocking = runBlocking {
    22.         val launch = this.launch(Dispatchers.Default) {
    23.             println(this.coroutineContext.get(CoroutineDispatcher).toString())//拿到调度器信息
    24.  
    25.         }
    26.         println(launch)
    27.         launch
    28.     }//是同一个对象
    29.     println(runBlocking)
    30.  
    31. }
    32.  
    33.  

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.CoroutineDispatcher
    4. import kotlinx.coroutines.CoroutineName
    5. import kotlinx.coroutines.CoroutineScope
    6. import kotlinx.coroutines.CoroutineStart
    7. import kotlinx.coroutines.Dispatchers
    8. import kotlinx.coroutines.InternalCoroutinesApi
    9. import kotlinx.coroutines.Job
    10.  
    11. import kotlinx.coroutines.launch
    12. import kotlinx.coroutines.newCoroutineContext
    13. import kotlinx.coroutines.runBlocking
    14. import kotlin.coroutines.CoroutineContext
    15. import kotlin.coroutines.EmptyCoroutineContext
    16.  
    17. @OptIn(ExperimentalStdlibApi::class)
    18. fun main() {
    19.  
    20.  
    21.     val runBlocking = runBlocking(Dispatchers.IO) {
    22.         val launch = this.launch (Dispatchers.Default){
    23.             println(this.coroutineContext.get(CoroutineDispatcher).toString())//拿到调度器信息
    24.  
    25.         }
    26.         println(launch)
    27.         launch
    28.     }//是同一个对象
    29.     println(runBlocking)
    30.  
    31. }
    32.  
    33.

     

    4.2 第二个参数 start:CoroutineStart

     

    1. default 是协程默认的启动方式  由默认协程调度去调度 决定在哪一个线程上面执行
    1.  
    2.     val runBlocking = runBlocking(Dispatchers.IO) {
    3.         val launch = this.launch{
    4.             println("hello")
    5.             delay(1000)
    6.             println("end")
    7.         }
    8.         //异步就会走到下面，end不执行
    9.         launch.cancel()
    10.     }//是同一个对象

    2. ATOMIC

    1.     val runBlocking = runBlocking(Dispatchers.IO) {
    2.         val launch = this.launch(start = CoroutineStart.ATOMIC){//ATOMIC是一个立即启动的过程 把执行此协程的优先级调上去
    3.             
    4.             println("hello")
    5.             delay(1000)
    6.             println("end")
    7.         }
    8.         //异步就会走到下面，end不执行
    9.         launch.cancel()
    10.     }//是同一个对象

    3.LAZY 可以自己控制何时启动

    1.  val runBlocking = runBlocking(Dispatchers.IO) {
    2.         val launch = this.launch(start = CoroutineStart.LAZY){//LAZY 可以自己控制何时启动
    3.             println("hello")
    4.             delay(1000)
    5.             println("end")
    6.         }
    7.         println("先打印，在启动")
    8.         //异步就会走到下面，end不执行
    9.         launch.start()
    10.     }//是同一个对象
    11.

    5. async详解

    1.   this.async(Dispatchers.Default, start = CoroutineStart.DEFAULT){
    2.  
    3.                 println("进来异步了")
    4.                 delay(1000)
    5.                 println("被卡住了")
    6.  
    7.  
    8.         }

    1.获取值方法1

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.CoroutineScope
    4. import kotlinx.coroutines.CoroutineStart
    5. import kotlinx.coroutines.Dispatchers
    6. import kotlinx.coroutines.async
    7. import kotlinx.coroutines.delay
    8.  
    9. fun main() {
    10.     val coroutineScope = CoroutineScope(Dispatchers.Default)
    11.  
    12.     val async = coroutineScope.async(Dispatchers.Default, start = CoroutineStart.DEFAULT) {
    13.  
    14.         println("进来异步了")
    15.         delay(1000)
    16.         println("被卡住了")
    17.  
    18.         "协程异步返回值"
    19.     }
    20.         Thread.sleep(3000)
    21.     val completed = async.getCompleted()
    22.     println(completed)
    23. }
    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.CoroutineScope
    4. import kotlinx.coroutines.CoroutineStart
    5. import kotlinx.coroutines.Dispatchers
    6. import kotlinx.coroutines.async
    7. import kotlinx.coroutines.delay
    8. import kotlinx.coroutines.runBlocking
    9.  
    10. fun main() {
    11.  
    12.     runBlocking {
    13.         val async = this.async {
    14.             test1()
    15.         }
    16.         for (i in 0..10) {
    17.             println("hello $i")
    18.         }
    19.         val await = async.await()
    20.  
    21.         println(await)
    22.  
    23.  
    24.  
    25.     }
    26.  
    27. }
    28.  
    29. suspend fun test1():Int{
    30.     println("执行中")
    31.     delay(3000)
    32.     return 100
    33. }

    6.select函数 与 onAwait方法

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.CoroutineScope
    4. import kotlinx.coroutines.CoroutineStart
    5. import kotlinx.coroutines.Dispatchers
    6. import kotlinx.coroutines.async
    7. import kotlinx.coroutines.delay
    8. import kotlinx.coroutines.runBlocking
    9. import kotlinx.coroutines.selects.select
    10.  
    11. fun main() {
    12.  
    13.     runBlocking {
    14.         val d = this.async {
    15.             delay(2000)
    16.             test1(1)
    17.         }//同时启动的
    18.         val c = this.async {
    19.             test1(2)
    20.         }//同时启动的
    21.  
    22.         //泛型是协程返回的类型
    23.         //select可以等待多个协程的结束
    24.         //select会阻塞当前的线程
    25.         println(select {
    26.             c.onAwait.invoke {
    27.                 "c"  //it是协程返回值
    28.             }
    29.             d.onAwait.invoke {
    30.                 "d"
    31.             }
    32.             //谁先执行结束就返回谁
    33.         })
    34.  
    35.         println("end")
    36.  
    37.  
    38.  
    39.  
    40.  
    41.  
    42.  
    43.     }
    44.  
    45. }
    46.  
    47. suspend fun test1(item:Int):Int{
    48.     println("执行中$item")
    49.     delay(3000)
    50.     return 100
    51. }

    7. withContenxt

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.CoroutineDispatcher
    4. import kotlinx.coroutines.Dispatchers
    5. import kotlinx.coroutines.delay
    6. import kotlinx.coroutines.runBlocking
    7. import kotlinx.coroutines.withContext
    8.  
    9. @OptIn(ExperimentalStdlibApi::class)
    10. fun main() {
    11.     runBlocking(Dispatchers.IO) {
    12.         println(coroutineContext.get(CoroutineDispatcher).toString())
    13.         val withContext = withContext(Dispatchers.Default) {
    14.             //会对协程有一个阻塞  挂起就是阻塞的意思
    15.             delay(2000)
    16.             println(coroutineContext.get(CoroutineDispatcher).toString())
    17.             //返回值就是lamda最后一行 ,并且结束以后会回到之前的那个协程上面继续执行
    18.             "withContext result"
    19.         }
    20.         println(withContext)
    21.         println(coroutineContext.get(CoroutineDispatcher).toString())
    22.     }
    23. }

    1. package com.tiger.kotlincoroutine.coroutine
    2.  
    3. import kotlinx.coroutines.CoroutineDispatcher
    4. import kotlinx.coroutines.Dispatchers
    5. import kotlinx.coroutines.delay
    6. import kotlinx.coroutines.launch
    7. import kotlinx.coroutines.runBlocking
    8. import kotlinx.coroutines.withContext
    9.  
    10. @OptIn(ExperimentalStdlibApi::class)
    11. fun main() {
    12.     //如果不想阻塞当前协程，那就重新开一个
    13.     runBlocking(Dispatchers.IO) {
    14.         println(coroutineContext.get(CoroutineDispatcher).toString())
    15.       launch {
    16.           val withContext = withContext(Dispatchers.Default) {
    17.               //会对协程有一个阻塞  挂起就是阻塞的意思
    18.               delay(2000)
    19.               println(coroutineContext.get(CoroutineDispatcher).toString())
    20.               //返回值就是lamda最后一行 ,并且结束以后会回到之前的那个协程上面继续执行
    21.               "withContext result"
    22.           }
    23.           println(withContext)
    24.       }
    25.  
    26.  
    27.         println(coroutineContext.get(CoroutineDispatcher).toString())
    28.     }
    29. }

    8.suspend关键字

    协程就是任务代码块，有调度器进行线程分配执行此代码块，可以公用一个线程，异步执行代码块，也可以不是一个线程执行.

    suspend 声明一个挂起函数，可以阻塞当前协程去执行代码块里的内容，主要是针对协程的。

    因为 Thread.sleep 是停止线程的，协程是在线程上面跑的。

    delay是延迟当前协程，不停线程，其他协程在此线程上面跑的话，那么都会被停止

  • 相关阅读:
    使用Qt Designer为您的Qt for Python项目创建基于Qt Widgets的图形界面的两种方法
    qt-C++笔记之两个窗口ui的交互
    【论文阅读】TEMPORAL ENSEMBLING FOR SEMI-SUPERVISED LEARNING
    从政府工作报告探云计算、大数据与人工智能的应用与推动作用
    Python每日一练——第9天：选择排序【含动图展示】
    Go使用Gin+mysql实现增删改查
    网上电子元器件采购商城：打破采购环节信息不对称难题，赋能企业高效协同管理
    怎么查找女性人数的不同年龄段的人数
    根据以下电路图，补全STM32F103RCT6的IO口初始化程序
    浅谈keras.preprocessing.text
  • 原文地址：https://blog.csdn.net/qq_53374893/article/details/136231631