美文网首页
简单的理解Kotlin for Java的协程

简单的理解Kotlin for Java的协程

作者: wenou | 来源:发表于2020-06-28 21:56 被阅读0次

    记录一下学习的知识

    1.什么是协程?
    • 广义的协程是一种在程序中处理并发任务的方案; 并且协程也是这种方案的一个组件
      例如:适配器模式是一种方案, 而项目中又存在具体的XxxAdapter,也是一个组件

    • 广义的协程和线程属于一个层级的概念,属于并列的关系
      例如:如果需要异步处理任务,你可以选择线程,也可以选择协程

    2.什么是Kotlin for Java的协程?

    Kotlin for Java的协程和广义的协程并不相同.
    Kotlin for Java的协程底层是基于线程,是一个线程框架,最终还是使用线程池来完成异步任务

    3.Android中的协程代码怎么写?
    • 用launch来开启一段协程
    • 把需要放在异步后台工作的函数,写成suspend函数,并且调用其他suspend函数来真正切换线程**
    • 最简单的使用GlobalScope.launch { ... }
    GlobalScope.launch {
         showLog("Current Thread name: ${Thread.currentThread().name}")
    }
    

    打印结果: Current Thread name: DefaultDispatcher-worker-1, 这里可以看到不是主线程Main了

    下面举个例子说明: 比如有几个函数

        fun ioCode1(){
            showLog("ioCode1 Thread name: ${Thread.currentThread().name}")
        }
        fun uiCode1(){
            showLog("uiCode1 Thread name: ${Thread.currentThread().name}")
        }
        fun ioCode2(){
            showLog("ioCode2 Thread name: ${Thread.currentThread().name}")
        }
        fun uiCode2(){
            showLog("uiCode2 Thread name: ${Thread.currentThread().name}")
        }
        fun ioCode3(){
            showLog("ioCode3 Thread name: ${Thread.currentThread().name}")
        }
        fun uiCode3(){
            showLog("uiCode3 Thread name: ${Thread.currentThread().name}")
        }
    

    我们希望ioCode的函数在异步执行,uiCode在主线程执行,并且按指定的顺序执行1,2,3

    如果不使用协程,我们可以这样写:

            thread {
                ioCode1()
                runOnUiThread {
                    uiCode1()
                    thread {
                        ioCode2()
                        runOnUiThread {
                            uiCode2()
                            thread {
                                ioCode3()
                                runOnUiThread {
                                    uiCode3()
                                }
                            }
                        }
                    }
                }
            }
    

    从这个简单的例子可以看出,嵌套层次有点多,如果业务逻辑比较复杂,不利于后期维护和修改

    使用Kotlin协程可以这样写:

    首先需要改造一下ioCode1(),ioCode2(),ioCode3()异步函数, 加上suspend标识为挂起函数, suspend并不会帮我们切换线程,需要加上withContext(Dispatchers.IO)来指定到IO线程

       GlobalScope.launch(Dispatchers.Main) {
            ioCode1()
            uiCode1()
            ioCode2()
            uiCode2()
            ioCode3()
            uiCode3()
        }
    
        suspend fun ioCode1() {
            withContext(Dispatchers.IO){
                showLog("ioCode1 Thread name: ${Thread.currentThread().name}")
            }
        }
        //同样的写法, 省略ioCode2() , ioCode3() 
        ...
    

    打印结果:
    D/ouwen: ioCode1 Thread name: DefaultDispatcher-worker-1
    D/ouwen: uiCode1 Thread name: main
    D/ouwen: ioCode2 Thread name: DefaultDispatcher-worker-3
    D/ouwen: uiCode2 Thread name: main
    D/ouwen: ioCode3 Thread name: DefaultDispatcher-worker-2
    D/ouwen: uiCode3 Thread name: main

    Dispatchers.Main : 把线程环境指定为Main主线程,当挂起函数ioCode1()执行完成后,会自动切换回到Main主线程环境

    GlobalScope.launch(Dispatchers.Main) {
        //运行在 Main主线程环境
    }
    
    4.协程有什么优势?

    a.性能的优势

    这是相对而言的,例如:
    Java: 当有某个函数方法存在耗时,但是调用的时候又不清楚这个函数耗时,而放在主线程调用,就存在性能问题
    Kotlin: 当有某个函数方法存在耗时,写成suspend函数,那么调用的时候,就必须开启协程来调用,更好的避免性能问题

    b.代码简洁的优势
    线性调用函数,可以用看起来同步的代码处理异步问题,不存在回调嵌套
    线程可以自动切回到原来的环境

    5.suspend关键字是什么?

    suspend关键作用: 标识和提醒,提醒suspend函数必须在协程里面调用

    如果一个函数有suspend关键字,那么该函数是挂起函数,并且这个函数必须在另外一个挂起函数或者协程里面被调用,否则代码就会提示报错,无法通过编译期

    suspend不会切换线程 ,真正切换线程的操作是调用其他函数来实现
    例如上面的: withContext(Dispatchers.IO)

    相关文章

      网友评论

          本文标题:简单的理解Kotlin for Java的协程

          本文链接:https://www.haomeiwen.com/subject/tpcgfktx.html