Kotlin协程：启动模式

已于 2023-01-08 21:27:46 修改
阅读量891 收藏 3
点赞数 2
分类专栏： Kotlin 协程 文章标签： kotlin android 开发语言
于 2023-01-04 11:31:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32955807/article/details/128542242
版权

启动模式

前言

我们看launch、async 构造函数需要传入一个协程上下文、协程启动模式、协程作用域。

本文我们重点介绍启动模式

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,//上下文
    start: CoroutineStart = CoroutineStart.DEFAULT,//启动模式
    block: suspend CoroutineScope.() -> Unit	//作用域
): Job {
  ......
}

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,//上下文
    start: CoroutineStart = CoroutineStart.DEFAULT,//启动模式
    block: suspend CoroutineScope.() -> T	//作用域
): Deferred<T> {
   
}

1、使用启动模式

使用启动模式只需要在构造传参：start=启动模式

CoroutineStart.DEFAULT 是默认启动模式，可以不用设置

launch(){//......}//默认CoroutineStart.DEFAULT
launch(start = CoroutineStart.DEFAULT){//......}
launch(start = CoroutineStart.ATOMIC){//......}
launch(start = CoroutineStart.LAZY){//......}
launch(start = CoroutineStart.UNDISPATCHED){//......}

async() {//......}//默认CoroutineStart.DEFAULT
async(start = CoroutineStart.DEFAULT) {//......}
async(start = CoroutineStart.ATOMIC){//......}
async(start = CoroutineStart.LAZY){//......}
async(start = CoroutineStart.UNDISPATCHED){//......}

2、启动模式概况

模式描述
CoroutineStart.DEFAULT协程创建后立即开始调度，在调度前如果协程被取消，就直接进入取消响应的状态，虽然是立即调度，但也有可能在执行前被取消
CoroutineStart.ATOMIC协程创建后立即开始调度，协程执行到第一个挂起点之前不响应取消，因此协程也一定会执行第一个挂起点前的逻辑
CoroutineStart.LAZY协程创建后等待调度，只有协程主动调用该协程的start、join或者await等函数时才会开始调度，如果调度前就被取消，就直接进入取消响应的状态
CoroutineStart.UNDISPATCHED协程创建后立即在当前函数调用栈中立即执行直到遇到第一个真正挂起的点，因此协程一定会执行

DEFAULT、LAZY两种模式是我们实际开发中比较常用的模式

上面描述说到几个概念：调度、执行、挂起点
要理解上面的启动模式就必须搞清楚什么是调度，什么是执行，什么是挂起点

挂起点

挂起点就是协程中遇到的挂起函数，一个挂起函数就是一个挂起点

我们知道delay是官方的一个挂机函数、suspendTest是我们自定义的一个挂起函数，那么在协程中的挂起点入下：

@Test
fun runBlockTest(): Unit = runBlocking {
    launch {
        delay(1000)//挂起点
        suspendTest()//挂起点
    }
    delay(1000)//挂起点
}

private suspend fun suspendTest(){
    println("我是一个挂起函数")
    delay(1000)
}

挂起点在编译器中也会明细的标记出来
挂起点

调度和执行

这里我用一段代码来说明

@Test
fun coroutineStudy(): Unit = runBlocking {
    val studyJob = launch(start = CoroutineStart.DEFAULT) {
        println("studyJob 协程调度后，执行阶段1")
        println("studyJob 协程调度后，执行阶段2")
        println("studyJob 协程调度后，执行阶段3")
        println("studyJob 协程调度后，执行阶段4")
        println("studyJob 协程调度后，执行阶段5")
        println("----studyJob 执行结束，studyJob 执行结束----")
    }
    println("studyJob 协程调度前1")
    println("studyJob 协程调度前2")
    println("studyJob 协程调度前3")
    println("studyJob 协程调度前4")
    println("studyJob 协程调度前5")
    //挂起点，调度前到执行是很快的1ms都不需要
    delay(1)
    println("studyJob 协程执行结束6")
    println("studyJob 协程执行结束7")
    println("studyJob 协程执行结束8")
    println("studyJob 协程执行结束9")
    println("studyJob 协程执行结束10")
}

调度、执行

执行输出结果：

studyJob 协程调度前1
studyJob 协程调度前2
studyJob 协程调度前3
studyJob 协程调度前4
studyJob 协程调度前5
studyJob 协程调度后，执行阶段1
studyJob 协程调度后，执行阶段2
studyJob 协程调度后，执行阶段3
studyJob 协程调度后，执行阶段4
studyJob 协程调度后，执行阶段5
----studyJob 执行结束，studyJob 执行结束----
studyJob 协程执行结束6
studyJob 协程执行结束7
studyJob 协程执行结束8
studyJob 协程执行结束9
studyJob 协程执行结束10

从代码可知调度到执行的状态切换是很快的，知识挂起了1ms,协程就已经进入了执行阶段

理解了上面的示例代码相信已经理解了调度、执行、挂起点的概念，那么下面对各个启动模式进行介绍。

3、模式 CoroutineStart.DEFAULT

描述：协程创建后立即开始调度，在调度前如果协程被取消，就直接进入取消响应的状态，虽然是立即调度，但也有可能在执行前被取消

示例1：协程立即调度，所以先调度再执行

@Test
fun coroutineStartDefault(): Unit = runBlocking {
    launch(start = CoroutineStart.DEFAULT) {
        //协程只是立即调度，执行打印后输出
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
    }
    //协程立即调度，所以调度打印先输出
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5

示例2：调度前协程被取消，就直接进入取消响应的状态

@Test
fun coroutineStartDefaultCancel(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.DEFAULT) {
    	//协程已经取消，不会执行
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
    }
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    //调度前取消
    println("协程取消 ${job.cancel()}")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程取消 kotlin.Unit

示例3：调度前挂起1s,让协程进入执行阶段，再取消。
结果：这个时候虽然能取消协程，但是已经没有意义了，协程已经执行完毕了

@Test
fun coroutineStartDefaultDelayCancel(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.DEFAULT) {
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
    }
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    delay(1)//调度是比较快的，1ms可能已经调度完成了
    println("协程取消 ${job.cancel()}")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5
协程取消 kotlin.Unit

示例4：调度前挂起1s,让协程进入执行阶段，然后再设置一个挂起点，然后再取消
结果：这个时候协程会执行到挂起点，后续的协程逻辑还是能取消的

@Test
fun coroutineStartDefaultDelayCancel2(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.DEFAULT) {
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        delay(300)//第一个挂起点
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    delay(1)//调度是比较快的，1ms可能已经调度完成了
    println("协程取消 ${job.cancel()}")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5
协程取消 kotlin.Unit

经过上面4个示例相信对DEFAULT模式已经有深刻的认识了

4、模式 CoroutineStart.ATOMIC

描述：协程创建后立即开始调度，协程执行到第一个挂起点之前不响应取消，因此协程也一定会执行第一个挂起点前的逻辑

这个模式创建后立即开始调度，跟DEFAULT一样，这部分不在做说明了，我们重点在不同点的说明

示例1：在调度前取消，协程会执行到第一个挂起点，挂起点后面的被取消了

@Test
fun coroutineStartAtomic(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.ATOMIC) {
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        delay(300)//第一个挂起点前，不响应取消操作
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    println("协程取消 ${job.cancel()}")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程取消 kotlin.Unit
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5

示例2：如果延迟1ms,让协程进入执行阶段协程体中挂起50ms，再取消
结果：在第一个挂起点后的协程被取消了，因为挂起50ms,足够协程取消

@Test
fun coroutineStartAtomic2(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.ATOMIC) {
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        //第一个挂起点前，不响应取消操作
        delay(50)
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    delay(1)
    println("协程取消 ${job.cancel()}")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5
协程取消 kotlin.Unit

示例3：如果延迟100ms,让协程进入执行阶段协程体中挂起50ms，再取消
结果：协程虽然能被取消，但是协程已经执行完毕了，取消没有实际意义

@Test
fun coroutineStartAtomic2(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.ATOMIC) {
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        //第一个挂起点前，不响应取消操作
        delay(50)
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    delay(100)
    println("协程取消 ${job.cancel()}")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5
协程调度后，执行阶段6
协程调度后，执行阶段7
协程调度后，执行阶段8
协程取消 kotlin.Unit

协程能否有效取消取决于本协程挂起时长与父协程挂起时长

这个模式有一个比较合适的使用场景：有过开发经验的人都知道我们的应用会经常进行网络请求前的一些数据的埋点，那么这个模式就很适合这个场景，比如就算是网络请求失败，我们也要对埋点数据进行处理，那我们就可以使用这个模式进行开发

5、模式 CoroutineStart.LAZY

描述：协程创建后等待调度，只有协程主动调用该协程的start、join或者await等函数时才会开始调度，如果调度前就被取消，就直接进入取消响应的状态

看名称就知道，这个模式跟懒加载类似，只有主动调度才会执行

lazy模式我们通常使用 start 进行主动调度，因为 start不是一个挂起函数

public interface Job : CoroutineContext.Element {
	//其他内容省略
	
    public fun start(): Boolean
}

示例1：不主动调度，协程不会执行

@Test
fun coroutineStartLazy(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.LAZY) {
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        delay(300)//第一个挂起点
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5

示例2：主动调用join进行调度，使用asyn的await也是一样的效果，可以自己测试
结果：join、await是挂起函数，挂起函数后面的代码需要等协程体执行完成再执行

@Test
fun coroutineStartLazyJoin(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.LAZY) {
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        delay(300)//第一个挂起点
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    //join是挂起函数，需要等待协程执行完后再恢复执行后续的代码
    println("协程join ${job.join()}")
    println("协程调度前6")
    println("协程调度前7")
    println("协程调度前8")
    println("协程调度前9")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5
协程调度后，执行阶段6
协程调度后，执行阶段7
协程调度后，执行阶段8
协程join kotlin.Unit
协程调度前6
协程调度前7
协程调度前8
协程调度前9

示例2：主动调用start进行调度
结果：start不是挂起函数，调度前的代码还是会执行

@Test
fun coroutineStartLazyStart(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.LAZY) {
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        delay(300)//第一个挂起点
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    //start 函数不是挂起函数，后面的代码还是会执行
    println("协程start ${job.start()}")
    println("协程调度前6")
    println("协程调度前7")
    println("协程调度前8")
    println("协程调度前9")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程start true
协程调度前6
协程调度前7
协程调度前8
协程调度前9
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5
协程调度后，执行阶段6
协程调度后，执行阶段7
协程调度后，执行阶段8

示例4：调度前就被取消，就直接进入取消响应的状态

@Test
fun coroutineStartLazyCancelStart(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.LAZY) {
        println("协程调度后，执行阶段1")
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        delay(300)//第一个挂起点
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")//先输出
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    println("协程cancel ${job.cancel()}")
    println("协程start ${job.start()}")
    println("协程调度前7")
    println("协程调度前8")
    println("协程调度前9")
}

//执行输出
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程cancel kotlin.Unit
协程start false
协程调度前7
协程调度前8
协程调度前9

6、模式 CoroutineStart.UNDISPATCHED

描述：协程创建后立即在当前函数调用栈中立即执行直到遇到第一个真正挂起的点，因此协程一定会执行

示例1：协程创建后立即执行，所以先执行协程，再执行调度前的代码

@Test
fun coroutineStartUnDispatched(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.UNDISPATCHED) {
        println("协程调度后，执行阶段1")//先输出
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")//后输出
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
}

//执行输出
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5
协程调度后，执行阶段6
协程调度后，执行阶段7
协程调度后，执行阶段8
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5

示例2：协程立即执行到第一个调度点，如果取消取决于协程体中的挂起时长

@Test
fun coroutineStartUnDispatchedCancel(): Unit = runBlocking {
    val job = launch(start = CoroutineStart.UNDISPATCHED) {
        println("协程调度后，执行阶段1")//先输出
        println("协程调度后，执行阶段2")
        println("协程调度后，执行阶段3")
        println("协程调度后，执行阶段4")
        println("协程调度后，执行阶段5")
        delay(300)//第一个挂起点，会影响
        println("协程调度后，执行阶段6")
        println("协程调度后，执行阶段7")
        println("协程调度后，执行阶段8")
    }
    println("协程调度前1")//后输出
    println("协程调度前2")
    println("协程调度前3")
    println("协程调度前4")
    println("协程调度前5")
    println("协程cancel ${job.cancel()}")
}

//执行输出
协程调度后，执行阶段1
协程调度后，执行阶段2
协程调度后，执行阶段3
协程调度后，执行阶段4
协程调度后，执行阶段5
协程调度前1
协程调度前2
协程调度前3
协程调度前4
协程调度前5
协程cancel kotlin.Unit

注意：这个模式不需要调度，立即执行，这个模式的线程由当前函数调用栈决定

下面用几个示例来说明

示例1：在主线程的环境中运行协程，并指定协程的调度器为IO
结果：协程还是运行在主线程

fun main() = runBlocking<Unit> {
    val job = launch(Dispatchers.IO,start = CoroutineStart.UNDISPATCHED) {
        println("协程调度后，执行阶段1 ${Thread.currentThread().name}")//先输出
        println("协程调度后，执行阶段2 ${Thread.currentThread().name}")
        println("协程调度后，执行阶段3 ${Thread.currentThread().name}")
        println("协程调度后，执行阶段4 ${Thread.currentThread().name}")
        println("协程调度后，执行阶段5 ${Thread.currentThread().name}")
    }
    println("协程调度前1 ${Thread.currentThread().name}")//后输出
    println("协程调度前2 ${Thread.currentThread().name}")
    println("协程调度前3 ${Thread.currentThread().name}")
    println("协程调度前4 ${Thread.currentThread().name}")
    println("协程调度前5 ${Thread.currentThread().name}")
}

//执行输入
协程调度后，执行阶段1 main
协程调度后，执行阶段2 main
协程调度后，执行阶段3 main
协程调度后，执行阶段4 main
协程调度后，执行阶段5 main
协程调度前1 main
协程调度前2 main
协程调度前3 main
协程调度前4 main
协程调度前5 main

示例2：在线程的环境中运行协程，并指定协程的调度器为Main
结果：协程还是运行在线程中

fun main() = runBlocking<Unit> {
    Thread{
        val job = launch(Dispatchers.Main,start = CoroutineStart.UNDISPATCHED) {
            println("协程调度后，执行阶段1 ${Thread.currentThread().name}")//先输出
            println("协程调度后，执行阶段2 ${Thread.currentThread().name}")
            println("协程调度后，执行阶段3 ${Thread.currentThread().name}")
            println("协程调度后，执行阶段4 ${Thread.currentThread().name}")
            println("协程调度后，执行阶段5 ${Thread.currentThread().name}")
        }
        println("协程调度前1 ${Thread.currentThread().name}")//后输出
        println("协程调度前2 ${Thread.currentThread().name}")
        println("协程调度前3 ${Thread.currentThread().name}")
        println("协程调度前4 ${Thread.currentThread().name}")
        println("协程调度前5 ${Thread.currentThread().name}")
    }.start()
}

//执行输入
协程调度后，执行阶段1 Thread-0
协程调度后，执行阶段2 Thread-0
协程调度后，执行阶段3 Thread-0
协程调度后，执行阶段4 Thread-0
协程调度后，执行阶段5 Thread-0
协程调度前1 Thread-0
协程调度前2 Thread-0
协程调度前3 Thread-0
协程调度前4 Thread-0
协程调度前5 Thread-0

看完这两个例子应该理解了上面那句话的含义，CoroutineStart.UNDISPATCHED 根本就不使用调度器，就算你指定了也没有用处的，他的运行线程只跟调用他的线程有关系

所以如果有面试官问你在协程中指定调度器为Dispatchers.IO情况下如何让协程在Main线程中运行，相信你应该有答案了吧

键盘書生
关注
专栏目录
【深入kotlin】 - 创建协程
kmyhy的专栏
04-02 2539
创建协程的方式主要有：launch()、async()、coroutineScope()、runBlocking() 。 launch() 创建一个异步协程（非阻塞），返回一个不带返回值的 job。 fun main(){ GlobalScope.launch{// 默认 CorutineDispatcher 为 Dispatchers.Default delay(1000) // 仅可用于协程，而非线程 println("Halloween Special") // 1 } println
Kotlin：Kotlin协程基础教程
kkchenjj的博客
08-06 1277
除了Kotlin提供的内置调度器，你还可以创建自定义的调度器，以满足特定的并发需求。自定义调度器通常用于控制协程的执行环境，例如，创建一个只在特定线程上运行的调度器，或者一个可以模拟不同并发模型的调度器。自定义调度器可以通过继承类并实现其方法来创建。主要的方法包括dispatch和等。在Kotlin协程中，Channel是一个用于在协程之间传递数据的通信机制。它类似于线程间的，但更轻量级，且与协程的调度紧密集成。Channel支持异步通信，允许生产者协程将数据发送到通道，而消费者协程从通道接收数据。
Kotlin 协程的四种启动模式
丿灬安之若死
06-12 1394
Default ：协程创建后立即开始调度。在调度前如果协程被取消。将其直接进入取消相应的状态。ATOMIC：协程创建后。立即开始调度。协程执行到第一个挂起点之前不相应取消。LAZY:只有协程被需要时，包括主动调协程的start、join或者await等函数时，才会开始调度，如果调度前就被取消。那么该协程将直接进入异常状态。UNDISPATCHED：协程创建后立即在当前函数调用栈中执行，直到遇到第一个真正挂起的点。CoroutineStart.DEFAULT代码案例 协程将不会执行因为在执行的时候给取消了
Android Kotlin 启动项目指南
最新发布
gitblog_00448的博客
09-08 1161
Android Kotlin 启动项目指南 android-kotlin-starterClean Android networking with local database offline caching app in 2019. Including Retrofit, Kotlin coroutines, MVVM, LiveData, Koin and ObjectBox.项目地址:ht...
Kotlin： 协程的四种启动模式（CoroutineStart）
ChinaDragon10的博客
03-14 2883
协程的四种启动模式： CoroutineStart.DEFAULT CoroutineStart.LAZY CoroutineStart.ATOMIC CoroutineStart.UNDISPATCHED
Kotlin实战指南十四：协程启动模式
赵彦军
07-15 1807
转载请标明出处：https://blog.csdn.net/zhaoyanjun6/article/details/95626034 本文出自【赵彦军的博客】 文章目录协程启动DEFAULTLAZYATOMICUNDISPATCHED附录参考资料 协程启动 说了这么多线程，原因嘛，毕竟大家对它是最熟悉的。协程的 API 设计其实也与之一脉相承，我们来看一段最简单的启动协程的方式： Globa...
Kotlin协程：启动协程
okclouderx的博客
05-01 2868
Kotlin 启动协程有 3 种方式：launch、async 和 runBlocking。 在使用协程之前需要引入协程库依赖。 "org.jetbrains.kotlinx:kotlinx-coroutines-core:$versions.coroutines" 在运行示例前，配置协程调试 VM 参数： Edit config -> VM options -Dkotlinx.coroutines.debug launch launch用来启动协程，但是不需要获取运行后的返回结果。它类似于”射箭
Kotlin协程：Flow 异步流
七夜聖君的博客
01-06 2174
Kotlin协程异步流 Flow
Kotlin协程学习之启动模式
且听真言
11-22 395
好文参考： https://juejin.cn/post/6893809019425816584 https://juejin.cn/entry/6844903854245412871 1.概念 Essentially, coroutines are light-weight threads. 协程是轻量级的线程。线程是由系统调度的，线程切换或线程阻塞的开销都比较大。而协程依赖于线程，但是协程挂起时不需要阻塞线程，几乎是无代价的，协程是由开发者控制的。所以协程也像用户态的线程，非常轻量级，一.
Kotlin协程：CoroutineScope 作用域
七夜聖君的博客
01-05 1801
Kotlin协程之作用域笔记
最全面的Kotlin协程: Coroutine/Channel/Flow 以及实际应用
肥宅
07-04 1856
协程这个概念在1958年就开始出现, 比线程更早, 目前很多语言开始原生支, Java没有原生协程但是可以大型公司都自己或者使用第三方库来支持协程编程, 但是Kotlin原生支持协程. 我认为协程的核心就是一个词: 作用域, 理解什么是作用域就理解协程了 什么是协程 协程是协作式任务, 线程是抢占式任务, 本质上两者都属于并发 Kotlin协程就是线程库不是协程? 内部代码用的线程池? 最知名的协程语言Go内部也是维护了线程, 他也不是协程了? 协程只是方便开发者处理异步, 线程才能提升性能效率, 两者本
Kotlin 协程基础入门：协程的三种启动方式和挂起函数
WriteBug001的博客
06-04 1254
通常，我们会在协程中使用挂起函数，并利用协程的上下文来管理执行环境。协程构建了一种轻量级的线程，将线程的状态保存在内存中，然后利用挂起函数实现了产生、挂起、恢复等机制，从而提供了非阻塞的多任务异步编程方式。withContext()是Kotlin协程库中的一个高级函数，它用于切换协程的执行上下文，例如在一个协程中切换到IO线程执行网络请求或者读写文件等操作。总之，挂起函数是 Kotlin 协程的重要概念，它本质是一种带有挂起（协程）能力的标记函数，它利用了协程和协程上下文机制来实现非阻塞式的异步编程。
Kotlin协程启动模式
大模型训练
01-22 816
有了前面的基础，`UNDISPATCHED` 就很容易理解了。协程在这种模式下会直接开始在当前线程下执行，直到第一个挂起点，这听起来有点儿像前面的 `ATOMIC`，不同之处在于 `UNDISPATCHED` 不经过任何调度器即开始执行协程体。当然遇到挂起点之后的执行就取决于挂起点本身的逻辑以及上下文当中的调度器了。
如何启动Kotlin协程
且听真言
09-04 1362
启动协程的基本方式。
activity 启动模式_Android中Activity启动模式详解
weixin_39753674的博客
11-27 235
在Android中每个界面都是一个Activity，切换界面操作其实是多个不同Activity之间的实例化操作。在Android中Activity的启动模式决定了Activity的启动运行方式。　　Android总Activity的启动模式分为四种：Activity启动模式设置： <activity android:name=".MainActivity" android:launchMod...
Kotlin 协程的启动
xiangxiongfly
03-25 2452
GlobalScope.launch launch源码 runBlocking async-await launch与async区别
Kotlin协程：创建、启动、挂起，Android开发知识体系
2401_83621095的博客
04-04 869
如果当前的block对象的类型为BaseContinuationImpl，则调用create方法，这里的create方法是编译器生成的类里的重写方法，它的内部就是通过我们传入的参数，创建并返回根据blcok生成的类的一个实例对象。在Kotlin协程中，很多方法都重载了带有receiver的方法和不带有receiver的方法。受限协程是指协程在运行过程中的，只能调用协程作用域中提供的挂起方法发生挂起，其他挂起方法不能调用，因为在挂起方法会对续体进行拦截，可能导致后续代码的执行变得无法预测。
【Kotlin 协程】协程启动 ④ ( 协程启动模式 | 协程构建器启动模式参数 | DEFAULT 模式 | ATOMIC 模式 | LAZY 模式 | UNDISPATCHED 模式 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-28 1693
一、协程构建器 CoroutineScope.async 函数 1、协程构建器 CoroutineScope.async 函数参数分析 2、协程构建器 CoroutineScope.async 函数参数原型 二、协程启动模式 1、DEFAULT 模式 2、ATOMIC 模式 3、LAZY 模式 4、UNDISPATCHED 模式 5、CoroutineStart 中定义的协程启动模式原型
Kotlin协程启动(2)
十一月Siy
09-10 469
在说协程启动之前来看看线程启动的代码： Thread { println("线程启动") }.start() 是不是和协程的启动很像： GlobalScope.launch { println("test continuation start") } 其实很多时候都可以用线程的特性来理解协程。 再...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值