Androdi kotlin Coroutines(协程)详解（一）
Androdi kotlin Coroutines(协程)详解（二）
Androdi kotlin Coroutines(协程)详解（三）
Androdi kotlin Coroutines(协程)详解（四）

一、协程

1.1 什么是协程

Kotlin官网对协程的定义是：本质上，协程是轻量级的线程。

协程——可挂起计算的实例。它在概念上类似于线程，在这个意义上，它需要一个代码块运行，并具有类似的生命周期 —— 它可以被创建与启动，但它不绑定到任何特定的线程。它可以在一个线程中挂起其执行，并在另一个线程中恢复。而且，像 future 或promise 那样，它在完结时可能伴随着某种结果

1.2 协程与线程

线程会阻塞，而协程不会阻塞，协程是轻量级的线程
协程是可控的，可随时取消，而线程的执行和结束是操作系统调度的，不可控
协程上依赖于线程，没有线程，协程也执行不了
一个线程可以创建任意个协程，而一个程序创建的线程数有限

1.3 Suspend挂起函数

带有suspend修饰符的函数为挂起函数
挂起函数不能在常规代码中被调用，只能在其他挂起函数或挂起 lambda 表达式中
挂起函数挂起协程时，不会阻塞协程所在的线程。
挂起函数执行完成后会恢复协程，后面的代码才会继续执行。
suspend 修饰符可以用于任何函数：顶层函数、扩展函数、成员函数、局部函数或操作符函数。

1.4 CPS

挂起函数通过Continuation passing style（CPS）来实现。当挂起函数被调用的时候，会有一个额外的Continuation参数传递给它。
比如我们定义一个suspend函数：

suspend fun <T> CompletableFuture<T>.await(): T

经过CPS转换后是

fun <T> CompletableFuture<T>.await(continuation: Continuation<T>): Any?

1.5 续体与续体拦截器

是挂起的协程在挂起点时的状态。它在概念上表示在挂起点之后的剩余应执行的代码。在编译的过程中，一个完整的协程被分割切块成一个又一个续体。

续体接口的定义如下，类似于一个通用的回调接口：

@SinceKotlin("1.3")
public interface Continuation<in T> {
  public val context: CoroutineContext
  public fun resumeWith(result: Result<T>)
}

ContinuationInterceptor拦截器接口

@SinceKotlin("1.3")
public interface ContinuationInterceptor : CoroutineContext.Element {
  companion object Key : CoroutineContext.Key<ContinuationInterceptor>
  public fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T>
  public fun releaseInterceptedContinuation(continuation: Continuation<*>) {
  /* do nothing by default */
}
...
}

1.6 State machines（状态机）

很多语言使用状态机来实现协程，Kotlin也是使用状态机的方式来实现的。对于Kotlin，这种方式导致编译器为每个包含挂起函数的lambda表达式生成一个类，包含挂起函数的lambda表达式中可以有任意数量的挂起点。
核心思想：一个包含挂起函数的lambda表达式被编译成了一个状态机，状态对应挂起点，例如下面的这个lambda表达式体内有两个挂起点。

GlobalScope.launch {
  val a = a()
  val y = foo(a).await() // 挂起点1
  val z = bar(a, y).await() // 挂起点2
}

CPS(Continuation Passing Style) 代码为

// 编译后生成的内部类大致如下
public final Object invokeSuspend(Object result) {
...
  switch (this.label) {
  case 0:
    this.label = 1;
    a = a()
    break;
  case 1:
    this.label = 2;
    val a = result;
    y = foo(a).await()
    break;
  case 2:
    val y = result;
    val z = bar(a, y).await()
    break;
  }
}

1.7 CoroutineScope

CoroutineScope，可以理解为协程本身，包含了 CoroutineContext协程上下文。CoroutineContext，协程上下文，是一些元素的集合，主要包括 Job 和 CoroutineDispatcher 元素，可以代表一个协程的场景。EmptyCoroutineContext 表示一个空的协程上下文。

public interface CoroutineScope {
  /**
  * The context of this scope.
  * Context is encapsulated by the scope and used for implementation of coroutine builders that are         
     extensions on th
  * Accessing this property in general code is not recommended for any purposes except accessing the [Job]     
    instance f
  *
  * By convention, should contain an instance of a [job][Job] to enforce structured concurrency.
  */
  public val coroutineContext: CoroutineContext
}

1.8 CoroutineContext协程上下文

从概念上讲，协程上下文是一组索引元素，其中每个元素有唯一的键。它是 set 与 map 的混合体。它的元素有像在 map 中的那样的键，但它的键直接与元素关联，更像是 set。

interface CoroutineContext {
  operator fun <E : Element> get(key: Key<E>): E?
  fun <R> fold(initial: R, operation: (R, Element) -> R): R
  operator fun plus(context: CoroutineContext): CoroutineContext
  fun minusKey(key: Key<*>): CoroutineContext
  interface Element : CoroutineContext {
  val key: Key<*>
}
interface Key<E : Element>
}

Androdi kotlin Coroutines(协程)详解 （一）