协程入门(四):启动模式

时间 2019-11-07

标签入门启动模式繁體版

原文原文链接

启动模式

模式	描述
缺省	默认为DEFAULT
DEFAULT	当即等待被调度执行()
ATOMIC	当即等待被调度执行，而且开始执行前没法被取消，直到执行完毕或者遇到第一个挂起点suspend
UNDISPATCHED	当即在当前线程执行协程体内容
LAZY	须要手动触发才会进入等待调度

示例

缺省

协程采用缺省的启动器, 当父协程执行完1,3后就会调度子协程执行2bash

/**
     * 启动模式, 缺省时
     *
     * 协程当即等待被调度执行(等待被调度，不是当即执行)
     *
     * 打印:
     * 1
     * 3
     * 2
     */
    @Test
    fun coroutineStart() = runBlocking {
        println("1")
        launch {
            println("2")
        }
        println("3")
        delay(3000)
    }
复制代码

DEFAULT

/**
     * DEFAULT启动模式，效果同缺省时一致
     */
    @Test
    fun default() = runBlocking {
        println("1")
        launch( start = CoroutineStart.DEFAULT) {
            println("2")
        }
        println("3")
        delay(3000)
    }
复制代码

UNDISPATCHED

UNDISPATCHED的协程会当即执行，因此1后先执行2完毕后才能执行到3微信

/**
     * UNDISPATCHED启动模式，当即运行该协程体内容(相比其它启动方式少了等待过程)
     *
     * 打印:
     * 1
     * 2
     * 3
     */
    @Test
    fun unDispatched() = runBlocking {
        println("1")
        launch(start = CoroutineStart.UNDISPATCHED) {
            //2优先于3执行
            println("2")
        }
        println("3")
    }
复制代码

LAZY

lazy如字面意思，懒惰，须要咱们主动触发才能进入等待调度阶段，不然不会有机会执行到。atom

调用 Job.start，主动触发协程的调度执行
调用 Job.join，隐式的触发协程的调度执行

/**
     * lazy启动方式，须要主动触发才能进入等待调度阶段
     *
     * - 调用 Job.start，主动触发协程的调度执行
     * - 调用 Job.join，隐式的触发协程的调度执行
     *
     * 使用start触发打印出:
     * 1
     * 3
     * 2
     * 使用join触发打印出:
     * 1
     * 2
     * 3
     * 若是下述例子去掉job.start(),则确定是:
     * 1
     * 3
     */
    @Test
    fun lazy() = runBlocking {
        println("1")
        val job = launch(start = CoroutineStart.LAZY) {
            //2优先于3执行
            println("2")
        }

        //lazy须要手动触发，让其协程进入等待调度阶段
        job.start()
        //join会堵塞当前协程等待job协程执行完毕
        //job.join()
        println("3")
    }

    /**
     * 注意一旦lazy协程体没有经过start执行完毕或者经过cancel取消掉，则runBlocking永远不会退出。
     * runBlocking会等到里面所有协程结束才退出
     *
     * 打印出:
     * 1
     * 3
     * 4
     */
    @Test
    fun lazy2() = runBlocking {
        println("1")
        val job = launch(start = CoroutineStart.LAZY) {
            println("2")
        }
        println("3")
        //job.start()
        //job.cancel()
        delay(3000)
        println("4")
    }
复制代码

ATOMIC

ATOMIC启动模式，与DEFAULT相似,当即等待被调度执行spa

区别在于: ATOMIC开始执行前没法被取消，直到执行完毕或者遇到第一个挂起点, DEFAULT执行前能够被取消。线程

/**
     * ATOMIC启动模式，当即等待被调度执行，而且开始执行前没法被取消，直到执行完毕或者遇到第一个挂起点。
     *
     * 该示例能够看出在一样通过cancel操做后，atomic协程依旧会被启动，而其它则不会启动了
     * 打印出:
     * 1
     * 3
     * atomic run
     */
    @Test
    fun atomic() = runBlocking {
        println("1")
        val job = launch(start = CoroutineStart.ATOMIC) {
            println("atomic run")
        }
        job.cancel()
        println("3")
    }

    /**
     *
     * 该示例演示atomic被cancel后遇到第一个挂起点取消运行的效果
     *
     * 打印出:
     *
     * 1
     * 2
     * atomic run
     * 3
     */
    @Test
    fun atomic2() = runBlocking {
        println("1")
        val job = launch(start = CoroutineStart.ATOMIC) {
            println("atomic run")
            //遇到了挂起点,cancel生效，不会再执行打印atomic end
            delay(3000)
            println("atomic end")
        }
        job.cancel()
        println("2")
        delay(5000)
        println("3")
    }

    /**
     * 该例子能够看出，在未运行前，default,lazy能够被cancel取消,
     * unDidpatcher由于会当即在当前线程执行，因此该例子中的cancel自己没啥意义了
     *
     * 输出:
     * 1
     * unDispatcherJob run
     * 2
     * atomic run
     */
    @Test
    fun atomic3() = runBlocking {
        println("1")
        val job = launch(start = CoroutineStart.ATOMIC) {
            println("atomic run")
        }
        job.cancel()

        val defaultJob = launch(start = CoroutineStart.DEFAULT) {
            println("default run")
        }
        defaultJob.cancel()

        val lazyJob = launch(start = CoroutineStart.LAZY) {
            println("lazyJob run")
        }
        lazyJob.start()
        lazyJob.cancel()

        val unDispatcherJob = launch(start = CoroutineStart.UNDISPATCHED) {
            println("unDispatcherJob run")
        }
        unDispatcherJob.cancel()

        println("2")
    }
复制代码