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

一、 协程简介

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

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

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

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

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

5、什么是挂起？

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

7、什么是协程？

8、什么是 Kotlin 协程？

9、Kotlin 协程有什么用？

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5、什么是挂起？

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

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

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

7、什么是协程？

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

8、什么是 Kotlin 协程？

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

9、Kotlin 协程有什么用？

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

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

史上最详Android版kotlin协程入门进阶实战

Kotlin协程的基础介绍

二、 Kotlin 协程的基本使用

讲概念之前，先讲用法。

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

常见的处理方式：

• 自己定义回调，进行处理
• 使用 线程/线程池， Callable

  线程 Thread(FeatureTask(Callable)).start

  线程池 submit(Callable)

• Android: Handler、 AsyncTask、 Rxjava

  使用协程：

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

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

  2.1 创建协程的三种方式

  1. 使用 runBlocking 顶层函数创建：

  runBlocking {    ...}

  1. 使用 GlobalScope 单例对象创建

  GlobalScope.launch {    ...}

  1. 自行通过 CoroutineContext 创建一个 CoroutineScope 对象

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

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

    2.2 等待一个作业

    先看一个示例：

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

    执行结果如下：

    test1test2helloworld

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

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

    输出结果:

    test1helloworldtest2

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

    2.3 协程的取消

    与线程类比，java 线程其实没有提供任何机制来安全地终止线程。

    Thread 类提供了一个方法 interrupt() 方法，用于中断线程的执行。调用interrupt（）方法并不意味着立即停止目标线程正在进行的工作，而只是传递了请求中断的消息。然后由线程在下一个合适的时机中断自己。

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

    fun main() = runBlocking {    val job = launch {        repeat(1000) { i ->            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() 是是什么情况？

    取消是协作的

    协程并不是一定能取消，协程的取消是协作的。一段协程代码必须协作才能被取消。

    所有 kotlinx.coroutines 中的挂起函数都是 可被取消的 。它们检查协程的取消， 并在取消时抛出 CancellationException。

    如果协程正在执行计算任务，并且没有检查取消的话，那么它是不能被取消的。

    fun main() = runBlocking {    val startTime = System.currentTimeMillis()    val job = launch(Dispatchers.Default) {        var nextPrintTime = startTime        var i = 0        while (i = 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 if (!isActive) throw getCancellationException()} 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")} 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") }}