kotlin协程详解，不可能学不懂

本文介绍: 首先还是先抛出一系列的问题，大家搞清楚这些问题后学习 Ko t lin 协程可能会轻松一点：1、什么是并发？什么是并行？2、什么是多任务？什么是协作式多任务？什么是抢占式多任务？3、什么是同步？什么是异步？4、什么是非阻塞式？什么是阻塞式？5、什么是挂起？6、什么是非阻塞式挂起？7、什么是协程？

一、协程 简介

首先还是先抛出一系列的问题，大家搞清楚这些问题后学习 Ko t lin 协程可能会轻松一点：

1、什么是并发？什么是并行？

2、什么是多任务？什么是协作式多任务？什么是抢占式多任务？

3、什么是同步？什么是异步？

4、什么是非阻塞式？什么是阻塞式？

5、什么是挂起？

6、什么是非阻塞式挂起？

7、什么是协程？

8、什么是 Ko t lin 协程？

9、Ko t lin 协程有什么用？

1、什么是并发？什么是并行？

1）、并发就是同一时刻只有一条指令在执行，但是因为 CPU 时间片非常的小，多个指令间能够快速的切换，使得我们看起来拥有同时执行的效果，存在于单核或多核 CPU 系统中

2）、并行就是同一时刻有多条指令同时在执行，存在于多核 CPU 系统中

举个生活中人吃馒头的例子：一个人买了 3 个馒头，那么他同一时刻只能在吃一个馒头，这是并发。而 3 个人每人买了一个馒头，那么同一时刻他们能同时吃馒头，这是并行。并发和并行的区别在于同一时刻是否在同时进行

2、什么是多任务？什么是协作式多任务？什么是抢占式多任务？

1）、多任务就是操作系统能够同时处理多个任务，例如我可以使用笔记本电脑打开 And roi dStud io 和网易云音乐，一边撸码一边听歌

2）、协作式多任务就是一个任务得到了 CPU 时间，除非它自己放弃使用 CPU ，否则将完全霸占 CPU ，所以任务之间需要协作，使用一段时间的 CPU 后，放弃使用，其它的任务也如此，才能保证系统的正常运行。一般出现在早期的操作系统中，如 Win d o ws 3.1

3）、抢占式多任务就是由操作系统来分配每个任务的 CPU 使用时间，在一个任务使用一段时间 CPU 后，操作系统会剥夺当前任务的 CPU 使用权，把它排在询问队列的最后，再去询问下一个任务。一般出现在现在使用的操作系统，如 Win d ow 95及之后的 Win d o ws 版本

协作式多任务和抢占式多任务区别：在协作式多任务中，如果一个任务死锁，则系统也会死锁。而抢占式多任务中，如果一个任务死锁，系统仍能正常运行

3、什么是同步？什么是异步？

计算机领域中的同步和异步和我们平时生活中的同步和异步是不一样的，这就让很多人难以理解

1）、计算机领域中的同步就是当调用者发送一个调用指令，需等待该指令执行完，在继续往下执行，是一种串行的处理方式

2）、计算机领域中的异步就是当调用者发送一个调用指令，无需等待该指令执行完，继续往下执行，是一种并行的处理方式

4、什么是阻塞？什么是非阻塞？

阻塞很简单，就是字面意思，在 Android 中的体现，其实就是阻塞了主线程的运行，那么非阻塞就是没有卡住主线程的运行

5、什么是挂起？

挂起就是保存当前状态，等待恢复执行，在 Android 中的体现，挂起就是不影响主线程的工作，更贴切的说法可以理解为切换到了一个指定的线程，

6、什么是非阻塞式挂起？

通过上面概念的解释，非阻塞式挂起就是不会卡住主线程且将程序切换到另外一个指定的线程去执行

7、什么是协程？

协程，英文名 Co r out in e，源自 Si mula 和 Modula-2 语言，它是一种协作式多任务实现，是一种编程思想，并不局限于特定的语言。协程设计的初衷是为了解决并发问题，让协作式多任务实现起来更加方便

8、什么是 Kotlin 协程？

Kotlin 协程简单来说是一套线程操作框架，详细点说它就是一套基于线程而实现的一套更上层的工具 API，类似于 Ja va 的线程池，你可以理解 Kotlin 新造了一些概念用来帮助你更好地使用这些 API，仅此而已

9、Kotlin 协程有什么用？

1）、Kotlin 协程可以用看起来同步的方式写出异步的代码，帮你优雅的处理回调地狱。

清楚了上面这些问题后，我们接着往下看

二、 Kotlin 协程的基本使用

讲概念之前，先讲用法。

场景：开启工作线程执行一段耗时任务，然后在主线程对结果进行处理。

常见的处理方式：

自己定义回调，进行处理
使用线程/线程池， Callable
线程 Th read(Fe atureTa sk(Callable)).start
线程池 su b m it(Callable)
Android: Handler、 AsyncTask、 Rx java

使用协程：

coroutineScope.launch(Dispatchers.Main) { // 在主线程启动一个协程
    val result = withContext(Dispatchers.Default) { // 切换到子线程执行
        doSomething()  // 耗时任务
    }
    handResult(result)  // 切回到主线程执行
}

这里需要注意的是： Dispatchers.Main 是 Andro id 里面特有的，如果是java 程序里面是用则会抛出异常。

2.1 创建协程的三种 方式

使用 runBlock ing 顶层函数创建：

runBlocking {
    ...
}

使用 Glo balScope 单例对象创建

GlobalScope.launch {
    ...
}

自行通过 CoroutineCon text 创建一个 CoroutineScope 对象

val coroutineScope = CoroutineScope(context)
coroutineScope.launch {
    ...
}

方法一通常适用于单元测试的场景，而业务开发中不会用到这种方法，因为它是线程阻塞的。
方法二和使用 runBlocking 的区别在于不会阻塞线程。但在 Andro id 开发中同样不推荐这种用法，因为它的生命周期会只受整个应用程序的生命周期限制，且不能取消。
方法三是比较推荐的使用方法，我们可以通过 context 参数去管理和控制协程的生命周期（这里的 context 和 Andro id 里的不是一个东西，是一个更通用的概念，会有一个 Andro id 平台的封装来配合使用）。

2.2 等待一个作业

先看一个示例：

fun main() = runBlocking {
    launch {
        delay(100)
        println("hello")
        delay(300)
        println("world")
    }
    println("test1")
    println("test2")
}

执行结果如下：

test1
test2
hello
world

我们启动了一个协程之后，可以保持对它的引用，显示地等待它执行结束，注意这里的等待是非阻塞的，不会将当前线程挂起。

fun main() = runBlocking {
    val job = launch {
        delay(100)
        println("hello")
        delay(300)
        println("world")
    }
    println("test1")
    job.join()
    println("test2")
}

输出结果:

test1
hello
world
test2

类比 java 线程，也有 join 方法。但是线程是操作系统界别的，在某些 cpu 上，可能 join 方法不生效。

2.3 协程的取消

与线程类比，java 线程其实没有提供任何机制来安全地终止线程。
Th read 类提供了一个方法 int err upt() 方法，用于中断线程的执行。调用 int err upt（）方法并不意味着立即停止目标线程正在进行的工作，而只是传递了请求中断的消息。然后由线程在下一个合适的时机中断自己。

但是协程提供了一个 cancel() 方法来取消作业。

fun main() = runBlocking {
    val job = launch {
        repeat(1000) { i -&gt;
            println("job: test $i ...")
            delay(500L)
        }
    }
    delay(1300L) // 延迟一段时间
    println("main: ready to cancel!")
    job.cancel() // 取消该作业
    job.join() // 等待作业执行结束
    println("main: Now cancel.")
}

输出结果：

job: test 0 ...
job: test 1 ...
job: test 2 ...
main: ready to cancel!
main: Now cancel.

也可以使用函数 cancelAndJoin, 它合并了对 cancel 以及 join 的调用。

问题：
如果先调用 job.join() 后调用 job.cancel() 是是什么情况？

取消是协作的
协程并不是一定能取消，协程的取消是协作的。一段协程代码必须协作才能被取消。
所有 kotlin x.coroutine s 中的挂起函数都是可被取消的。它们检查协程的取消，并在取消时抛出 CancellationExc eption。
如果协程正在执行计算任务，并且没有检查取消的话，那么它是不能被取消的。

fun main() = runBlocking {
    val startTime = System.currentTimeMillis()
    val job = launch(Dispatchers.Default) {
        var nextPrintTime = startTime
        var i = 0
        while (i < 5) { // 一个执行计算的循环，只是为了占用 CPU
            // 每秒打印消息两次
            if (System.currentTimeMillis() >= nextPrintTime) {
                println("job: hello ${i++} ...")
                nextPrintTime += 500L
            }
        }
    }
    delay(1300L) // 等待一段时间
    println("main: ready to cancel!")
    job.cancelAndJoin() // 取消一个作业并且等待它结束
    println("main: Now cancel.")
}

此时的打印结果：

job: hello 0 ...
job: hello 1 ...
job: hello 2 ...
main: ready to cancel!
job: hello 3 ...
job: hello 4 ...
main: Now cancel.

可见协程并没有被取消。为了能真正停止协程工作，我们需要定期检查协程是否处于 active 状态。

检查 job 状态
一种方法是在 while(i<5) 中添加检查协程状态的代码
 代码如下：

while (i < 5 &amp;&amp; isActive)

这样意味着只有当协程处于 active 状态时，我们工作的才会执行。

另一种方法使用协程标准库中的函数 ensureActive()，它的实现是这样的：

public fun Job.ensureActive(): Unit {
    if (!isActive) throw getCancellationException()
}

代码如下：

while (i < 5) { // 一个执行计算的循环，只是为了占用 CPU
    ensureActive()
    ...
}

ensu reActive() 在协程不在 active 状态时会立即抛出异常。

使用 yield()
yield() 和 ensureActive 使用方式一样。
yield 会进行的第一个工作就是检查任务是否完成，如果 Job 已经完成的话，就会抛出 CancellationExc eption 来结束协程。yield 应该在定时检查中最先被调用。

while (i < 5) { // 一个执行计算的循环，只是为了占用 CPU
    yield()
    ...
}

2.4 等待协程的执行的结果

对于无返回值的的协程使用 launch 函数创建，如果需要返回值，则通过 async 函数创建。
使用 async 方法启动 Deferred （也是一种 job），可以调用它的 await() 方法获取执行的结果。
形如下面代码：

val asyncDeferred = async {
    ...
}

val result = asyncDeferred.await()

defer red 也是可以取消的，对于已经取消的 deferred 调用 await() 方法，会抛出
JobCancellationException 异常。

同理，在 deferred.await 之后调用 deferred.cancel(), 那么什么都不会发生，因为任务已经结束了。

关于 async 的具体用法后面异步任务再讲。

2.5 协程的异常 处理

由于协程被取消时会抛出 CancellationException ，所以我们可以把挂起函数包裹在 try/catch 代码块中，这样就可以在 finally 代码块中进行资源清理操作了。

fun main() = runBlocking {
    val job = launch {
        try {
            delay(100)
            println("try...")
        } catch (e: Exception) {
            println("exception: ${e.message}")
        } finally {
            println("finally...")
        }
    }
    delay(50)
    println("cancel")
    job.cancel()
    print("Done")
}

结果：

cancel
Doneexception: StandaloneCoroutine was cancelled
finally...

2.6 协程的超时

在实践中绝大多数取消一个协程的理由是它有可能超时。当你手动追踪一个相关 Job 的引用并启动，使用 withTimeout 函数。

fun main() = runBlocking {
    withTimeout(300) {
        println("start...")
        delay(100)
        println("progress 1...")
        delay(100)
        println("progress 2...")
        delay(100)
        println("progress 3...")
        delay(100)
        println("progress 4...")
        delay(100)
        println("progress 5...")
        println("end")
    }
}

结果：

start...
progress 1...
progress 2...
Exception in thread "main" kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 300 ms

withTimeout 抛出了 TimeoutCancellationException，它是 CancellationException 的子类。我们之前没有在控制台上看到堆栈跟踪信息的打印。这是因为在被取消的协程中 CancellationException 被认为是协程执行结束的正常原因。然而，在这个示例中我们在 main 函数中正确地使用了 withTimeout。如果有必要，我们需要主动 catch 异常进行处理。