Kotlin协程基础

Kotlin协程基础知识

前言：其实以前学习C#也了解过协程的概念，但是在深入学习Kotlin的时候准备系统的认识一下协程，同时与Java的线程进行一个对比。

主要参考：https://www.jianshu.com/p/6e6835573a9c 结合实际代码做了修改并且附带运行结果，使用IDEA的gradle构建项目方便添加相应依赖，至于gradle如何构建项目，请看我前面的内容。

---

目录

Kotlin协程基础知识

一、协程的概念

二、协程的简单测试

1.使用runBlocking:T创建协程

2.使用launch:Job创建协程

3.使用async创建协程

---

 

一、协程的概念

在写协程代码之前，我们得先了解什么是协程，以及协程和线程的区别。

官方语言：协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、订阅相关事件、在不同线程（甚至不同机器）上调度执行，而代码则保持如同顺序执行一样简单。

说人话：协程依赖于线程，并且内部实现了相关异步操作。

再具体点：协程就像非常轻量级的线程。线程是由系统调度的，线程切换或线程阻塞的开销都比较大。而协程依赖于线程，但是协程挂起时不需要阻塞线程。所以协程也像用户态的线程，非常轻量级，一个线程中可以创建任意个协程。协程很重要的一点就是当它挂起的时候，它不会阻塞其他线程。协程底层库也是异步处理阻塞任务，但是这些复杂的操作被底层库封装起来，协程代码的程序流是顺序的，不再需要一堆的回调函数，就像同步代码一样，也便于理解、调试和开发。它是可控的，线程的执行和结束是由操作系统调度的，而协程可以手动控制它的执行和结束。

二、协程的简单测试

首先需要在IDEA gradle中添加依赖：

implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1")

1.使用runBlocking:T创建协程

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

fun main(args: Array<String>) {
    println("主线程开始")
    test()
    println("主线程结束")
}
private fun test() = runBlocking {
    repeat(8) {
        println("协程："+Thread.currentThread())
        delay(1000)
    }
}

运行结果：

从结果可以看出：runBlocking启动的协程任务会阻断当前线程，直到该协程执行结束。当协程执行结束之后，页面才会被显示出来。

2.使用launch:Job创建协程

这是最常用的用于启动协程的方式，它最终返回一个Job类型的对象，这个Job类型的对象实际上是一个接口，它包涵了许多我们常用的方法。下面先看一下简单的使用：

fun main(args: Array<String>) {
    println("主线程开始")
    val job = GlobalScope.launch {
        delay(3000)
        println("协程结束")
    }
    println("主线程结束")
    Thread.sleep(4000)
}

运行结果：

可以看出，launch不会阻断主线程，在主线程中睡眠是因为保证协程的活性，因为协程是依赖于线程，如果线程先结束，则协程就没有输出了。

我们来看一下launch方法的源码，可以看出launch是CoroutineScope的扩展函数，其中有三个参数：

1.协程下上文；2.协程启动模式；3.协程体

 * @param context additional to [CoroutineScope.coroutineContext] context of the coroutine.
 * @param start coroutine start option. The default value is [CoroutineStart.DEFAULT].
 * @param block the coroutine code which will be invoked in the context of the provided scope.
 **/
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
}

CoroutineContext：

上下文可以有很多作用，包括携带参数，拦截协程执行等等，只需要使用默认的就好。上下文有一个重要的作用就是线程切换，Kotlin协程使用调度器来确定哪些线程用于协程执行，Kotlin提供了调度器给我们使用：

• Dispatchers.Main：使用这个调度器在 Android 主线程上运行一个协程。可以用来更新UI 。在UI线程中执行

• Dispatchers.IO：这个调度器被优化在主线程之外执行磁盘或网络 I/O。在线程池中执行

• Dispatchers.Default：这个调度器经过优化，可以在主线程之外执行 cpu 密集型的工作。例如对列表进行排序和解析 JSON。在线程池中执行。

• Dispatchers.Unconfined：在调用的线程直接执行。

CoroutineStart ：

在Kotlin源码中，启动模式定义成一个枚举类型:

public enum class CoroutineStart {
    DEFAULT,
    LAZY,
    @ExperimentalCoroutinesApi
    ATOMIC,
    @ExperimentalCoroutinesApi
    UNDISPATCHED;
}

启动模式	作用
DEFAULT	默认的模式，立即执行协程体
LAZY	只有在需要的情况下运行
ATOMIC	立即执行协程体，但在开始运行之前无法取消
UNDISPATCHED	立即在当前线程执行协程体，直到第一个 suspend 调用

suspend CoroutineScope.() -> Unit：

协程体是一个用suspend关键字修饰的一个无参，无返回值的函数类型。被suspend修饰的函数称为挂起函数,与之对应的是关键字resume（恢复），注意：挂起函数只能在协程中和其他挂起函数中调用，不能在其他地方使用。suspend函数会将整个协程挂起，而不仅仅是这个suspend函数，也就是说一个协程中有多个挂起函数时，它们是顺序执行的：

fun main(args: Array<String>) {
    println("主线程开始")
    GlobalScope.launch {
        val token = getToken()//两秒时间
        val userInfo = getUserInfo(token)//两秒时间
        setUserInfo(userInfo)
    }
    repeat(8){
        println("主线程执行 $it 次")
    }
    Thread.sleep(6000)//确保协程中代码能有时间执行
    println("主线程结束")
}

private fun setUserInfo(userInfo:String){
    println("userInfo: $userInfo")
}

private suspend fun getToken():String{
    delay(2000)
    return "token"
}

private suspend fun getUserInfo(token:String):String{
    delay(2000)
    return "$token==userInfo"
}

运行结果：

从结果可以看出，getToken有suspend修饰，所以方法将协程挂起，协程中其后面的代码永远不会执行，只有等到getToken挂起结束恢复后才会执行。同时协程挂起后不会阻塞其他线程的执行。

3.使用async创建协程

async跟launch的用法基本一样，区别在于：async的返回值是Deferred，将最后一个封装成了该对象。async可以支持并发，此时一般都跟await一起使用，看下面的例子。

@Volatile var flag = true//@Volatile 注解保证flag参数的线程可见性
fun main(args: Array<String>) {
    println("程序开始")
    var start = System.currentTimeMillis()
    GlobalScope.launch {
        val result1 = GlobalScope.async { getResult1() }
        val result2 = GlobalScope.async { getResult2() }
        val result = result1.await()+result2.await()//await保证都能返回结果
        println("result=$result")
        flag = false
    }
    while (flag){}
    var end = System.currentTimeMillis()
    val time = end-start
    println("程序结束，共用了$time 毫秒")
}
private suspend fun getResult1():Int{
    delay(3000)
    return 1
}
private suspend fun getResult2():Int{
    delay(4000)
    return 2
}

运行结果：async是不阻塞线程的,也就是说getResult1和getResult2是同时进行的，所以获取到result的时间是4s，而不是7s。

我们来看看async的源码：

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T> {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyDeferredCoroutine(newContext, block) else
        DeferredCoroutine<T>(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

 可以看到async确实和launch相似，Deferred实现Job接口，里面有“public suspend fun await(): T”，所以在协程中，执行时间就是耗时较长的方法的时间，所以最终是4s并不是7s。