Kotlin协程：启动模式

已于 2023-01-08 21:27:46 修改
阅读量845 收藏 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协程指南
07-26
在本文档中，我们将探讨Kotlin协程的基本概念以及如何应用这些概念来编写有效的程序。协程是一种轻量级的线程，它们在程序中的使用能够极大地简化异步编程，提高代码的可读性和性能。 首先，协程的基础概念是轻量级...
Kotlin 协程的四种启动模式
丿灬安之若死
06-12 1380
Default ：协程创建后立即开始调度。在调度前如果协程被取消。将其直接进入取消相应的状态。ATOMIC：协程创建后。立即开始调度。协程执行到第一个挂起点之前不相应取消。LAZY:只有协程被需要时，包括主动调协程的start、join或者await等函数时，才会开始调度，如果调度前就被取消。那么该协程将直接进入异常状态。UNDISPATCHED：协程创建后立即在当前函数调用栈中执行，直到遇到第一个真正挂起的点。CoroutineStart.DEFAULT代码案例 协程将不会执行因为在执行的时候给取消了
Kotlin协程：启动协程
okclouderx的博客
05-01 2806
Kotlin 启动协程有 3 种方式：launch、async 和 runBlocking。 在使用协程之前需要引入协程库依赖。 "org.jetbrains.kotlinx:kotlinx-coroutines-core:$versions.coroutines" 在运行示例前，配置协程调试 VM 参数： Edit config -> VM options -Dkotlinx.coroutines.debug launch launch用来启动协程，但是不需要获取运行后的返回结果。它类似于”射箭
Kotlin： 协程的四种启动模式（CoroutineStart）
ChinaDragon10的博客
03-14 2753
协程的四种启动模式： CoroutineStart.DEFAULT CoroutineStart.LAZY CoroutineStart.ATOMIC CoroutineStart.UNDISPATCHED
Kotlin 协程基础入门：协程的三种启动方式和挂起函数
WriteBug001的博客
06-04 1177
通常，我们会在协程中使用挂起函数，并利用协程的上下文来管理执行环境。协程构建了一种轻量级的线程，将线程的状态保存在内存中，然后利用挂起函数实现了产生、挂起、恢复等机制，从而提供了非阻塞的多任务异步编程方式。withContext()是Kotlin协程库中的一个高级函数，它用于切换协程的执行上下文，例如在一个协程中切换到IO线程执行网络请求或者读写文件等操作。总之，挂起函数是 Kotlin 协程的重要概念，它本质是一种带有挂起（协程）能力的标记函数，它利用了协程和协程上下文机制来实现非阻塞式的异步编程。
kotlin协程的详细介绍和六种启动方式与挂起函数原理
UrasakiNakajima的博客
07-02 3801
（1）协程与线程的关系：协程是轻量级线程可以说，协程不是线程，而是一个特殊的函数，这个函数可以在某个地方挂起，并且可以恢复继续运行。所以说，协程和线程相比并不是一个维度的概念。函数调用当然比线程切换轻量；而封装成类线程的API后，它形似线程（可手动启动、有各种运行状态、能够协作工作、能够并发执行）。协程（Coroutines）是一种比线程更加轻量级的存在，正如一个进程可以拥有多个线程一样，一个线程可以拥有多个协程。协程比线程更高效，可以挂起和恢复而不会产生上下文切换的开销；
kotlin协程
12-13
9. Actors和select表达式：Kotlin协程还提供了Actor模式，可以用来构建并发的状态机，它通过消息传递而非共享状态来实现并发。select表达式则提供了一种在多个挂起函数中选择执行的模式匹配方式。 10. 协程在实际...
kotlin101:修改Kotlin语言的基础知识
04-03
使用`launch`或`async`启动协程，配合`suspend`函数来控制挂起与恢复。 第七部分：Android开发 Kotlin在Android开发中的应用极大地改善了代码质量。它可以简化Android的生命周期管理，提供Anko库进行DSL（领域特定...
coroutines-examples:Kotlin中的协程设计示例
04-14
在"coroutines-examples"项目中，我们可以看到一系列针对Kotlin协程设计的示例，这将有助于深入理解和实践协程的使用。 **一、协程基础概念** 1. **什么是协程**：协程不同于传统的线程，它们是轻量级的执行单元，...
Kotlin+MVVM+Retrofit+协程+ViewBinding+EventBus
05-21
在Android上，协程解决了回调地狱问题，通过`launch`或`async`启动协程，使用`suspend`函数处理异步操作。配合`coroutineScope`或`SupervisorJob`管理协程生命周期，避免内存泄漏。 **ViewBinding** ViewBinding是...
Android Kotlin之Coroutine(协程)详解
蜗牛快跑
12-29 5540
协程Coroutine是一种并发设计模式，您可以在 Android 平台上(Kotlin)使用它来简化异步执行的代码。在 Android Kotlin 上，协程Coroutine有助于管理长时间运行的任务，如果管理不当，这些任务可能会阻塞主线程并导致应用无响应。协程可以类似于RxJava那样，做到异步任务同步化，避免可能出现的回调地狱。同时，通过关键字来标识函数，称为挂起函数，该函数，只能在协程或其他的suspend函数中执行，从而保证主线程的安全。下面，我们先写个简单协程。协程多了2个状态。
【Kotlin 协程】协程启动 ④ ( 协程启动模式 | 协程构建器启动模式参数 | DEFAULT 模式 | ATOMIC 模式 | LAZY 模式 | UNDISPATCHED 模式 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-28 1640
一、协程构建器 CoroutineScope.async 函数 1、协程构建器 CoroutineScope.async 函数参数分析 2、协程构建器 CoroutineScope.async 函数参数原型 二、协程启动模式 1、DEFAULT 模式 2、ATOMIC 模式 3、LAZY 模式 4、UNDISPATCHED 模式 5、CoroutineStart 中定义的协程启动模式原型
Kotlin 协程解析
yuhang01的博客
11-09 408
最近刚刚接触到协程，网上也翻阅了大量其他作者的博文来看，总感觉越看越不透彻，所以特此记录自己对于kotlin协程的理解和认识，如果有误，望指正 协程定义 协程（英语：coroutine）是计算机程序的一类组件，推广了协作式多任务的子程序，允许执行被挂起与被恢复。相对子例程而言，协程更为一般和灵活，但在实践中使用没有子例程那样广泛。协程更适合于用来实现彼此熟悉的程序组件，如协作式多任务、异常处理、事件循环、迭代器、无限列表和管道。 ...
关于kotlin coroutine的一些个人理解
最新发布
2401_84149814的博客
04-19 994
最后小编想说：不论以后选择什么方向发展，目前重要的是把Android方面的技术学好，毕竟其实对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！这里附上我整理的几十套腾讯、字节跳动，京东，小米，头条、阿里、美团等公司19年的Android面试题。把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。由于篇幅有限，这里以图片的形式给大家展示一小部分。
Kotlin协程：创建、启动、挂起，Android开发知识体系
2401_83621095的博客
04-04 847
如果当前的block对象的类型为BaseContinuationImpl，则调用create方法，这里的create方法是编译器生成的类里的重写方法，它的内部就是通过我们传入的参数，创建并返回根据blcok生成的类的一个实例对象。在Kotlin协程中，很多方法都重载了带有receiver的方法和不带有receiver的方法。受限协程是指协程在运行过程中的，只能调用协程作用域中提供的挂起方法发生挂起，其他挂起方法不能调用，因为在挂起方法会对续体进行拦截，可能导致后续代码的执行变得无法预测。
三分钟开启第一个 Kotlin 工程
WillFlow的博客
08-08 1030
联系方式： 简书：WillFlow CSDN：WillFlow 微信公众号：WillFlow 写在前面：Kotlin介绍1、Kotlin是什么？在正式搭建环境之前，我想有必要先和大家介绍下Kotlin，以免第一次接触的同学一头雾水不知道我在说什么。Kotlin是由JetBrains创建的基于JVM的编程语言，我们众所周知的Android Studio 是基于IntelliJ修改
如何启动Kotlin协程
且听真言
09-04 1351
启动协程的基本方式。
Android 使用Kotlin语言实现开机自启功能
m0_50774720的博客
04-11 555
二、在AndroidManifest.xml文件的标签中写入下列代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值