Kotlin学习笔记之 28 协程基础

首发于公众号: DSGtalk1989

28.协程基础

• 准备工作

  如果你使用的是Android studio，在build.gradle文件中，添加协程依赖。

 dependencies {
           implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1'
}

在intelliJ IDEA中需要进入到module setting的dependency添加maven依赖同上

• 最常用的协程启动

  CoroutineScope.launch，我们可以看一下这个方法，有三个参数。

  public fun CoroutineScope.launch(
        context: CoroutineContext = EmptyCoroutineContext,
        start: CoroutineStart = CoroutineStart.DEFAULT,
        block: suspend CoroutineScope.() -> Unit
    ): Job {
        val newContext = newCoroutineContext(context)
        val coroutine = if (start.isLazy)
            LazyStandaloneCoroutine(newContext, block) else
            StandaloneCoroutine(newContext, active = true)
        coroutine.start(start, coroutine, block)
        return coroutine
    }
  

  三个参数分别代表着，协程的上下文，启动模式和挂起的函数。

  协程的上下文和启动模式都有默认值，不填写直接走默认。并且该方法最终会返回一个Job对象，我们点进去看一下。

  方法和参数不多，我们逐个的去看。

  • cancel取消一个协程

    fun main() {
           val job = GlobalScope.launch {
               delay(1000L)
               println("World!")
           }
           job.cancel()
           println("Hello,")
       }
    

    只有Hello,，没有World!。因为协程被取消了。

  • join等待协程执行完毕

    fun main() = runBlocking {
           val job = GlobalScope.launch {
               delay(1000L)
               println("World!")
               delay(1000L)
           }
           println("Hello,")
           job.join() 
           println("Good！")
       }
    

    和java中的Thread.join比较像，都是会阻塞当前线程，所以最终打印出来的是

    Hello,
    World!
    Good！
    

    这里需要注意，join方法用suspend修饰，是个挂起函数，挂起函数必须只能在协程中进行使用，所以外面包裹了一个runBlocking，具体runBlocking的含义我们之后分析。

  • cancelAndJoin取消一个任务并且等到他彻底结束

    public suspend fun Job.cancelAndJoin() {
       cancel()
       return join()
    }
    

  OK，我们回过来继续看一下协程的概念，本身的协程是非常的轻量级的线程。一开始我们就可以把它理解成一个与当前线程区别开来的线程。

• runBlocking

  很明显，GlobalScope的生命周期是全局的，即，完全起了一个线程，什么时候走完完全取决于整个应用程序的生命周期。我们来看这样一个效果

  fun main() {
        println("ready") 
        GlobalScope.launch {
            println("GlobalScope.launch go!")
            delay(5000L) 
            println("GlobalScope.launch end!")
        }
        println("end")
    }
  

  由于主线程很快的就结束掉，我们完全没有给到协程启动的机会，jvm迅速的完成了主线程的任务。导致我们看到的控制台输出是这样的

  ready
  end
  

  实际上这里面我们希望的是能够让main方法把协程里面的内容跑完再结束的，这个时候就轮到我们的runBlocking登场。

  Runs new coroutine and blocks current thread interruptibly until its completion.

  即起一个新的协程，并且立马阻塞当前的线程，直到协程完毕。

  这里我们需要来认识一下，协程中的sleep函数delay，该函数只能用在挂起函数中，会让协程暂停一段时间。

  那么这样一来，我们结合起来看

  fun main() {
        println("ready") // 当协程在后台等待时, 主线程继续执行
  
        runBlocking {     // 但是这个表达式阻塞了主线程
            println("runBlocking start")
            delay(2000L)  // ……我们延迟 2 秒来保证 JVM 的存活
            println("runBlocking  end")
        }
    
        println("end")
    }
  

  能够很清晰的看到，主线程被阻塞了，因为runBlocking的概念，这样一来就可以达到delay阻塞了主线程的效果。

• 协程中叠协程

  协程中我们可以再起协程，举个例子，我们瞎看如下代码。

  fun main() {
        println("ready") // 当协程在后台等待时, 主线程继续执行
        runBlocking {
            // 但是这个表达式阻塞了主线程
            GlobalScope.launch {
                // 在后台启动新的协程, 然后继续执行当前程序
                println("GlobalScope.launch go!")
                delay(5000L) // 非阻塞, 等待 1 秒 (默认的时间单位是毫秒)
                println("GlobalScope.launch end!")
            }
            println("runBlocking start")
            delay(1000L)  // ……我们延迟 2 秒来保证 JVM 的存活
        }
        println("end")
    }
  

  经过上文的分析，我们知道runBlocking会阻塞当前的线程，直到运行完它自己的协程，结果现在我们在协程中又通过GlobalScope.launch起了一个全局的协程。考虑到前面讲到的生命周期问题，我们猜测runBlocking不会去等GlobalScope.launch，事实也确实如此。

  ready
    runBlocking start
    GlobalScope.launch go!
    end
  

  我们现在去掉GlobalScope，直接走launch。发现明显不同的生命周期，直接launch的话，这个协程的生命周期就是runBlocking，也就是说，哪怕launch里面消耗的时间再长，main函数也需要等到整个的runBlocking生命周期走完即launch里面的协程也结束才行。

• 协程到底如何轻量

  repeat(10_000) {
        // 启动大量的协程
        runBlocking {
            launch {
                print(".")
            }
        }
    }
  

  启动一万个协程，轻飘飘的完成了打点的任务。

---

Kotlin学习笔记之 1 基础语法

Kotlin学习笔记之 2 基本数据类型

Kotlin学习笔记之 3 条件控制

Kotlin学习笔记之 4 循环控制

Kotlin学习笔记之 5 类和对象

Kotlin学习笔记之 6 继承

Kotlin学习笔记之 7 接口

Kotlin学习笔记之 8 扩展

Kotlin学习笔记之 9 数据类与密封类

Kotlin学习笔记之 10 泛型

Kotlin学习笔记之 11 枚举类

Kotlin学习笔记之 12 对象表达式和对象声明

Kotlin学习笔记之 13 基础操作符run、with、let、also、apply

Kotlin学习笔记之 14 包与导入

Kotlin学习笔记之 15 伴生对象

Kotlin学习笔记之 16 委托

Kotlin学习笔记之 17 可观察属性

Kotlin学习笔记之 18 函数

Kotlin学习笔记之 19 高阶函数与 lambda 表达式

Kotlin学习笔记之 20 内联函数

Kotlin学习笔记之 21 解构声明

Kotlin学习笔记之 22 集合

Kotlin学习笔记之 23 相等判断

Kotlin学习笔记之 24 操作符重载

Kotlin学习笔记之 25 异常捕捉

Kotlin学习笔记之 26 反射

Kotlin学习笔记之 27 类型别名

Kotlin学习笔记之 28 协程基础

Kotlin学习笔记之 29 上下文与调度器

Kotlin学习笔记之 30 协程取消与超时

Kotlin学习笔记之 31 协程挂起函数的组合

Kotlin学习笔记之 32 协程异常处理

Kotlin学习笔记之 33 协程 & Retrofit