kotlin协程原理分析

使用kotlin的协程一段时间后,我们或多或少会产生一些疑问:协程和线程有什么关系?协程之间到底怎么来回传递的?协程真的比线程(池)好吗?

初窥

首先我们从最简单协程开始:

fun main() {
    runBlocking {
        val aaa = async {
            println("aaa-")
        }
        aaa.await()
        println("bbb-")
    }
}

我们遵循“如果看不懂,那就看一下字节码或者转成java”的套路,看一下java代码大概的样子:

public static final void main() {
    //协程开始
    BuildersKt.launch$default((CoroutineScope) GlobalScope.INSTANCE, (CoroutineContext) Dispatchers.getIO(), (CoroutineStart)null,
    //这里传了个回调(续体)
     (Function2)(new Function2((Continuation)null) {
        int label;
        @Nullable
        public final Object invokeSuspend(@NotNull Object $result) {
            //很明显,这是协程刚开始执行的代码
            Object var5 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            switch(this.label) {
                case 0:
                    //label默认是0,所以走初始化和创建aaa的回调(续体)
                    ResultKt.throwOnFailure($result);
                    CoroutineScope $this$launch = (CoroutineScope)this.L$0;
                    System.out.println("开始");
                    Deferred aaa = BuildersKt.async$default($this$launch, (CoroutineContext)null, (CoroutineStart)null, (Function2)(new Function2((Continuation)null) {
                        int label;
                        @Nullable
                        public final Object invokeSuspend(@NotNull Object var1) {
                            Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
                            switch(this.label) {
                                case 0:
                                    //aaa的代码执行
                                    ResultKt.throwOnFailure(var1);
                                    System.out.println("aaa-");
                                    return Unit.INSTANCE;
                                default:
                                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                            }
                        }
                        ...

                    }), 3, (Object)null);
                    //label赋值1,如果下次再调用就会走case 1了
                    this.label = 1;
                    //获取aaa的实时结果,并且把自己(回调)传了进去
                    if (aaa.await(this) == var5) {
                        //如果aaa告诉你等一会再给结果(参考var5赋值),则代码结束
                        return var5;
                    }
                    break;
                case 1:
                    ResultKt.throwOnFailure($result);
                    break;
            }
            //上面相当于传给了aaa一个回调(续体),当aaa执行完成后会再次调用invokeSuspend
            //在case 1里,如果aaa正常完成,则会进到这里
            //最终结束
            System.out.println("结束");
            return Unit.INSTANCE;
        }
        ...
    }), 2, (Object)null);
    Thread.sleep(100000L);
}

因为上面有label这种状态机制(状态机),不方便理解,我们画成流程图

 依据上面也能很轻松就能推理出,如果我需要await aaa、bbb、ccc三个,我们只需要在“准备执行结束代码”前面塞上和aaa一样的bbb、ccc逻辑即可,如下

 如果想深入查看了解源码请移步:Kotlin协程实现原理 - Giagor - 博客园 (cnblogs.com)

困境

看了上面的基本原理,有没有产生个疑问:它和线程池有什么区别?

我们先仿照上面用线程池实现一下:

//线程池版
fun main2() {
    //ThreadPool为线程池
    ThreadPool.run {
        println("开始")
        ThreadPool.run {
            println("aaa-")
            ThreadPool.run {
                println("结束")
            }
        }
    }

    //sleep只是防止main挂掉
    Thread.sleep(100_000)
}

 当然如果涉及到aaa、bbb、ccc都并发的情况下,我们需要重新革命一下代码逻辑

//线程池版
fun main2() {
    //ThreadPool为线程池
    ThreadPool.run {
        println("开始")
        ThreadPool.run {
            println("aaa-")
            callEnd()
        }
        ThreadPool.run {
            println("bbb-")
            callEnd()
        }
        ThreadPool.run {
            println("ccc-")
            callEnd()
        }
    }

    //sleep只是防止main挂掉
    Thread.sleep(100_000)
}

val callCount = AtomicInteger(0)
fun callEnd() {
    val count = callCount.incrementAndGet()
    //用count来计数,当三个都成功时结束
    if (count == 3) {
        ThreadPool.run {
            println("结束")
        }
    }
}

虽然代码可能比协程多了一点,但它丝毫不影响我对协程的推测:协程是一个共用线程池。翻开“Dispatchers.IO”的源码——没错它就是一个公共线程池。

是不是有一种:把协程吹得那么高大尚,就这?

破局

还记得近期大火的“三体”吗,汪淼花了大量时间破解三体的太阳之谜,而最终的答案在哪里呢?没错“三体”就是三个物体因力学关系互相影响而无法归纳他们的运动轨迹。而我们协程的全称叫“协同程序”,所以作为协同程序它的目标是:

1. 轻量:协程全局共享线程,消耗资源较少

2.灵活:轻松编写非阻塞式异步代码

3.简洁:避免回调地狱,避免过多改动代码,更友好简单的代码

4.可控:启动、暂停、恢复、异常等均可自行管理控制

此处顺便欣赏一下aaa、bbb、ccc都并发的kotlin代码吧:

fun main() {
    runBlocking {
        println("开始")
        listOf(
            async {
                println("aaa-")
            },
            async {
                println("bbb-")
            },
            async {
                println("ccc-")
            }
        )
            .awaitAll()
        println("结束")
    }
}

释然

协程和线程池它们各自目标群体不同,并且各有所长,只不过大部分情况下协程比较占优罢了。

提示:线程是cpu执行的基本单元,和上面两个是完全不同的概念。并且多cpu架构的协程必然存在线程池,没有哪个语言的协程格调比其他语言高的说法。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值