Kotlin 进阶版 协程

已于 2024-07-15 18:04:50 修改
阅读量995 收藏 10
点赞数 12
分类专栏： Kotlin 文章标签： kotlin 开发语言 android
于 2024-02-22 17:02:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53374893/article/details/136231631
版权
本文详细解释了Kotlin中的Dispatchers不同调度器（如IO、Main、Unconfined和Default）的作用，以及它们在Android中的具体应用，重点讨论了如何在协程中处理网络I/O、UI操作和CPU密集任务的调度策略。
摘要由CSDN通过智能技术生成

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 中会使用一个共享的线程池来处理这些任务，以便在多个协程之间进行合理的调度。

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

fun main() {
    //IO线程  超大密集的计算 Default

    /**
     * IO
     * Default
     * Main
     *
     */
    CoroutineScope(Dispatchers.IO).launch {
        test()
//        withContext(Dispatchers.Main){
//
//        }
    }
    println("主线程")
    Thread.sleep(2000)
}

/**
 * 协程代码块
 */
suspend fun test() {
    println("协程开始")
    delay(1000)
    println("协程结束")
}

1.runBlocking

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

fun main() {
    println("hello")
    //如果给的参数第一个为空，那么它会去找到这个协程外面调用它的这个线程 一般在写Test的时候才用一下 阻塞式协程
    val i = runBlocking (Dispatchers.IO){
        //如果制定了了调度器，它会被分配到另一个线程上面执行 ,但也可以阻塞当前线程
        println(
            Thread.currentThread().name
        )
        //这个协程会阻塞当前线程 同步执行
        delay(2000)
        1
    }
    println(
        Thread.currentThread().name
    )
    println("world $i ")
}

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main() {
    println("hello")
    //如果给的参数第一个为空，那么它会去找到这个协程外面调用它调度器 一般在写Test的时候才用一下 阻塞式协程
    //会等里面所有的协程执行完了，才会释放主线程
    val i = runBlocking (Dispatchers.IO){
        //如果制定了了调度器，它会被分配到另一个线程上面执行 ,但也可以阻塞当前线程
        println(
            Thread.currentThread().name
        )

        println(this)
        //this :BlockingCoroutine 可以再次开启一个协程
        val job = this.launch {
            //这个开启的协程不会阻塞当前线程，异步
            println(
                //没有指定 ，他会默认继承上面所在的调度器 被这个调度器管理的线程池的线程去执行
                Thread.currentThread().name
            )
            delay(5200)
        }

        println(job.isActive)
        println(job.cancel())
        println(job.isActive)
        println("延迟了吗")


        //这个协程会阻塞当前线程 同步执行
        delay(2000)
        1
    }
    println(
        Thread.currentThread().name
    )
    println("world $i ")


    /**
     * 总结
     * IO 网络请求 数据库
     * default 密集型数据处理操作 数据计算
     * main UI操作
     *
     */
}

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext

fun main() {
    println("hello")
    val i = runBlocking (Dispatchers.IO){

            request{
                //手动切换到UI线程里
                withContext(Dispatchers.Main){
                    //修改UI
                

                }

            }

    }
    println("world $i")
}

suspend fun request(finish:suspend ()->Unit){
    delay(3000)
    println("网络请求成功")
    finish()
}

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

2.GlobalScope

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

fun main() {
    val launch = GlobalScope.launch { //全局指的是整个程序的生命周期 就算Activity销毁了这个GlobalScope还是存在的
        // 这样可能会造成一些奇怪的问题
        delay(3000)
        println("hello")
    }//这不是阻塞当前线程的一个协程操作
    val launch1 = GlobalScope.launch {

    }

    println(launch===launch1)
    //不能调用cancel 方法,因为作用域是整个生命周期的，不能由我们来管理

    while (true);
}

3.CoroutineScope

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.cancel
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

fun main() {
    //推荐使用这个  不是全局的
    val coroutineScope1 = CoroutineScope(Dispatchers.Default)


    coroutineScope1.launch {
       delay(3000)

        println("结束")
    }
    coroutineScope1.launch {
        delay(3000)

        println("结束")
    }
    coroutineScope1.cancel() //可以手动进行取消，不会涉及到全局 整个程序的生命周期
    Thread.sleep(4000)
    println("主线程结束")
}

4.Launch分析

4.1 第一个参数 context: CoroutineContext

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.CoroutineName
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.CoroutineStart
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.InternalCoroutinesApi
import kotlinx.coroutines.Job

import kotlinx.coroutines.launch
import kotlinx.coroutines.newCoroutineContext
import kotlinx.coroutines.runBlocking
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext

@OptIn(ExperimentalStdlibApi::class)
fun main() {


    val runBlocking = runBlocking {
        val launch = this.launch(Dispatchers.Default) {
            println(this.coroutineContext.get(CoroutineDispatcher).toString())//拿到调度器信息

        }
        println(launch)
        launch
    }//是同一个对象
    println(runBlocking)

}




package com.kotlincoroutine.coroutine

import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.CoroutineName
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.CoroutineStart
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.InternalCoroutinesApi
import kotlinx.coroutines.Job

import kotlinx.coroutines.launch
import kotlinx.coroutines.newCoroutineContext
import kotlinx.coroutines.runBlocking
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext

@OptIn(ExperimentalStdlibApi::class)
fun main() {


    val runBlocking = runBlocking(Dispatchers.IO) {
        val launch = this.launch (Dispatchers.Default){
            println(this.coroutineContext.get(CoroutineDispatcher).toString())//拿到调度器信息

        }
        println(launch)
        launch
    }//是同一个对象
    println(runBlocking)

}

 

4.2 第二个参数 start:CoroutineStart

  1. default 是协程默认的启动方式  由默认协程调度去调度 决定在哪一个线程上面执行

    val runBlocking = runBlocking(Dispatchers.IO) {
        val launch = this.launch{
            println("hello")
            delay(1000)
            println("end")
        }
        //异步就会走到下面，end不执行
        launch.cancel()
    }//是同一个对象

2. ATOMIC

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

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

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

5. async详解

  this.async(Dispatchers.Default, start = CoroutineStart.DEFAULT){

                println("进来异步了")
                delay(1000)
                println("被卡住了")


        }

1.获取值方法1

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.CoroutineStart
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.delay

fun main() {
    val coroutineScope = CoroutineScope(Dispatchers.Default)

    val async = coroutineScope.async(Dispatchers.Default, start = CoroutineStart.DEFAULT) {

        println("进来异步了")
        delay(1000)
        println("被卡住了")

        "协程异步返回值"
    }
        Thread.sleep(3000)
    val completed = async.getCompleted()
    println(completed)
}
package com.kotlincoroutine.coroutine

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.CoroutineStart
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

fun main() {

    runBlocking {
        val async = this.async {
            test1()
        }
        for (i in 0..10) {
            println("hello $i")
        }
        val await = async.await()

        println(await)



    }

}

suspend fun test1():Int{
    println("执行中")
    delay(3000)
    return 100
}

6.select函数 与 onAwait方法

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.CoroutineStart
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.selects.select

fun main() {

    runBlocking {
        val d = this.async {
            delay(2000)
            test1(1)
        }//同时启动的
        val c = this.async {
            test1(2)
        }//同时启动的

        //泛型是协程返回的类型
        //select可以等待多个协程的结束
        //select会阻塞当前的线程
        println(select<String> {
            c.onAwait.invoke {
                "c"  //it是协程返回值
            }
            d.onAwait.invoke {
                "d"
            }
            //谁先执行结束就返回谁
        })

        println("end")







    }

}

suspend fun test1(item:Int):Int{
    println("执行中$item")
    delay(3000)
    return 100
}

7. withContenxt

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    runBlocking(Dispatchers.IO) {
        println(coroutineContext.get(CoroutineDispatcher).toString())
        val withContext = withContext(Dispatchers.Default) {
            //会对协程有一个阻塞  挂起就是阻塞的意思
            delay(2000)
            println(coroutineContext.get(CoroutineDispatcher).toString())
            //返回值就是lamda最后一行 ,并且结束以后会回到之前的那个协程上面继续执行
            "withContext result"
        }
        println(withContext)
        println(coroutineContext.get(CoroutineDispatcher).toString())
    }
}

package com.kotlincoroutine.coroutine

import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    //如果不想阻塞当前协程，那就重新开一个
    runBlocking(Dispatchers.IO) {
        println(coroutineContext.get(CoroutineDispatcher).toString())
      launch {
          val withContext = withContext(Dispatchers.Default) {
              //会对协程有一个阻塞  挂起就是阻塞的意思
              delay(2000)
              println(coroutineContext.get(CoroutineDispatcher).toString())
              //返回值就是lamda最后一行 ,并且结束以后会回到之前的那个协程上面继续执行
              "withContext result"
          }
          println(withContext)
      }


        println(coroutineContext.get(CoroutineDispatcher).toString())
    }
}

8.suspend关键字

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

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

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

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

荭色海湾
关注
专栏目录
Android开发学习笔记——Kotlin协程
qq_36425800的博客
12-13 812
Android开发学习笔记——Kotlin协程Android中的异步编程协程基本使用 Android中的异步编程 我们知道，Android App的进程也是一个DVM，内部有许多线程在执行，比如，主UI线程（Main Thread），垃圾回收线程等。其中主UI线程负责执行我们写的应用代码。对于只做很少的I/O操作或耗时操作的App，单一线程开发模式问题不大，但是如果有大量IO或者CPU计算的任务，我们就必须在其他线程内完成了。 在实际的开发过程中，我们通常会要求应用的帧率达到60帧，也就是说每16毫秒就必须
Kotlin：Kotlin协程基础教程
kkchenjj的博客
08-06 1204
除了Kotlin提供的内置调度器，你还可以创建自定义的调度器，以满足特定的并发需求。自定义调度器通常用于控制协程的执行环境，例如，创建一个只在特定线程上运行的调度器，或者一个可以模拟不同并发模型的调度器。自定义调度器可以通过继承类并实现其方法来创建。主要的方法包括dispatch和等。在Kotlin协程中，Channel是一个用于在协程之间传递数据的通信机制。它类似于线程间的，但更轻量级，且与协程的调度紧密集成。Channel支持异步通信，允许生产者协程将数据发送到通道，而消费者协程从通道接收数据。
Kotlin（android）协程中文翻译
weixin_34309543的博客
09-01 444
1.官方文档地址 github.com/Kotlin/kotl… 2. 协程的配置 compile "org.jetbrains.kotlinx:kotlinx-coroutines-android:0.18" 3.开启协程 Coroutines are experimental feature in Kotlin. You need to enable coroutines in Ko...
【Android Kotlin】Kotlin协程介绍
最新发布
Ho博客
08-29 1369
Kotlin协程的核心内容涵盖了协程的基本概念、构建块、启动方式、挂起函数、结构化并发、异常处理以及协程的取消机制。协程通过提供一种轻量级的并发编程模型，使得处理异步任务更加直观和简洁，同时保持代码的可读性和可维护性。它们在Android开发中得到了广泛应用，尤其是在需要处理复杂的异步操作时。
Android Kotlin-协程
风的轨迹
05-18 1656
文章目录1.线程与协程2.异步与协程2.1传统的方式完成异步任务网络加载2.2下面是使用协程的方式3.协程的挂起与恢复4.协程背后的状态机原理5.协程+MVVM+Jecpack项目架构5.1Google Jecpack+MVVM架构设计5.2.协程+Retrofit+MVVM+DataBinding 1.线程与协程 线程的封装框架，从宏观角度看，可以这么认为 协程有点像轻量级的线程 从包含关系上看，协程跟线程的关系，有点像“线程与进程的关系”，协程不可能脱离线程运行 协程虽然不能脱离线程，但是可以在不同的
Android Kotlin协程
weixin_26739079的博客
08-22 207
Recently, Kotlin Coroutines introduce an advanced and efficient approach of concurrency design pattern, which can be used on Android to simplify asynchronous codes. As a matter of fact, this approach ...
Android Kotlin 协程
Bull_DaGuanRen的博客
02-26 3489
Android Kotlin 携程一、协程是什么？二、使用三、关键字介绍 一、协程是什么？ 携程就是Kotlin的线程框架，类似于Thread、executors、Handler等等。 二、使用 在{}代码块就是携程，调用 GlobalScope.launch(Dispatchers.Main) { var s=suspendSetTitle("123") //协程 } suspend fun suspendSetTitle(titl
Kotlin从入门到进阶实战.pdf
03-17
《Kotlin从入门到进阶实战》从Kotlin 语言的基础语法讲起，逐步深入到Kotlin进阶实战，并在最后配合项目实战案例，重点介绍了使用Kotlin+Spring Boot进行服务端开发和使用Kotlin进行Android应用程序开发的内容，让...
史上最详Android版kotlin协程入门进阶实战指南，你学废了吗？
zhireshini233的博客
01-05 812
Kotlin协程 Kotlin协程是目前很流行的一款用于异步任务处理的库，都知道它处理异步任务特别好用，但是很少人去探究它背后的原理。还有一点，由于它是用于处理异步任务的，很多人将协程与线程做对比，也有一些人将协程与Rxjava做对比。这篇文章将从最简单的用法开始，层层递进的讲解协成知识点。 如何使用使用协程，以及协程中的一些重要概念 首先先介绍一下怎么开启一个协程，在Android开发中，如果是在Activity或者Fragment中，那么可以通过以下这种方式开启一个协程。 class MainActiv
Android基础到进阶四大组件之ContentProvider详解，kotlin线程池+协程
m0_65145685的博客
12-22 460
需要实现的主要方法是： 「insert()」、「delete()」、「update()」、「query()」：用于对数据集的增删改查操作。 「onCreate()」：一般用来初始化底层数据集和建立数据连接等工作 「getType()」：用来返回指定Uri的MIME数据类型， 若Uri是单条数据，则返回的MIME数据类型以vnd.Android.cursor.item开头； 若Uri是多条数据，则返回的MIME数据类型以vnd.android.cursor.dir/开头。 数据访问方法
一篇文章带你彻底搞懂Kotlin的协程
Android_1314的博客
04-27 416
} [](()CoroutineScope（作用范围） 控制协程代码块执行的线程，生命周期等，包括GlobeScope、lifecycleScope、viewModelScope以及其他自定义的CoroutineScope GlobeScope：全局范围，不会自动结束执行 lifecycleScope：生命周期范围，用于activity等有生命周期的组件，在DESTROYED的时候会自动结束，需额外引入 viewModelScope：viewModel范围，用于ViewModel中，在ViewMod
Android kotlin协程
FlyPig_Vip的博客
09-25 551
额,听说 协程是个轻量级的线程.咱也不懂, 一个应用呢,后台就是个进程,然后这个进程能开一堆线程,线程能做耗时任务,Android 有很多地方都比较需要线程,比如:定时任务,耗时任务,网络请求~但是呢,一般开多了就容易GG,不是有个面试题经常问多线程并发么,反正我没遇到~ 然后呢,kotlin这个协程感觉是轻量化这个线程,然后就能无限开咯,老套路了:没有好的解决方案那就从根本上替换他!翻译过来...
Android Kotlin：协程
前期后期
07-23 1024
1）协程是什么？2）协程和线程的关系？3）协程如何使用？切线程是什么4）挂起函数是什么？5）withContext和lanuch的区别在哪里？6）Defualt、IO和Main的区别。
Android 官方 Kotlin 协程
赵小龙同学的博客
10-22 251
Android 上的 Kotlin 协程https://developer.android.com/kotlin/coroutines
Android - kotlin 协程极简入门
龙衣
09-23 593
背景 协程的作用是解决并发，并发的常见场景是多线程。 “并发”和“并行”经常弄混。下面是我的理解，当然我理解也不一定是对的 “并发”是宏观上多个任务同时执行，而微观上任务是同一时间只有一个在执行。而“并行”不管宏观微观都是多个任务在同时执行。 举个生活中的例子：“并发”就像是吃饭的时候讲话，微观上同一时间只能是吃饭或者是讲话，是一个人在执行。“并行”就是让一个人吃饭，另一个人去讲话，是两个人去执行。 多线程情况下就不可避免的涉及以下的问题： 线程什么时候执行结束 线程间的相互通信 多个线程的管理
Android Kotlin 协程详解
袁震的博客
09-20 1560
什么是协程？要理解协程，就要将它和线程联系起来理解。线程是什么？我想大家都清楚，而协程，它比线程更加轻量级，一个线程上面可以有多个协程。如果我们应用开启一万个线程，可能就崩溃了，但是如果我们开启10万个协程，对应用的性能也不会有太大的影响。协程是可挂起计算的实例，它需要一个代码块运行，并具有类似的生命周期（可以被创建、启动和取消），它不绑定到任何特定的线程，可以在一个线程中挂起其执行，并在另一个线程中恢复，它在完结时可能伴随着某种结果（值或异常）
Android Kotlin 协程（coroutine ）入门篇
我怀里的猫的博客
03-24 8834
ps：文章会很长 协同程序（coroutine）实在是太好用了，所以我们来学习吧！
【Android】Kotlin 协程 高效并发详解（ Kotlin Coroutine ）
full courage的博客
05-14 3301
协程是一种编程思想，并不局限于特定的语言。除 Kotlin 以外，其他的一些语言，如 Go、Python 等都可以在语言层面上实现协程。 Kotlin Coroutine 本质上是 Kotlin 官方提供的一套线程封装 API，其设计初衷是为了解决并发问题，让协作式多任务实现起来更方便。子任务协作运行，优雅的处理异步问题解决方案。 协程是一种比线程更加轻量级的存在，不是线程，但是可以把它类比成线程。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值