Kotlin 协程

协程

协程就像非常轻量级的线程。线程是由系统调度的，线程切换或线程阻塞的开销都比较大。而协程依赖于线程，但是协程挂起时不需要阻塞线程，几乎是无代价的，协程是由开发者控制的。所以协程也像用户态的线程，非常轻量级，一个线程中可以创建任意个协程。

非阻塞式挂起

协程很重要的一点就是当它挂起的时候，它不会阻塞其他线程。协程底层库也是异步处理阻塞任务，但是这些复杂的操作被底层库封装起来，协程代码的程序流是顺序的，不再需要一堆的回调函数，就像同步代码一样，也便于理解、调试和开发。它是可控的，线程的执行和结束是由操作系统调度的，而协程可以手动控制它的执行和结束

kotlin {
    experimental {
        coroutines 'enable'
    }
}
 
dependencies {
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7"
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.7'
}

协程的四种启动方式
runBlocking:T
launch:Job
async/await:Deferred
withContext

• runBlocking

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    Log.e(TAG, "主线程id：${mainLooper.thread.id}")
    test()
    Log.e(TAG, "协程执行结束")
}

private fun test() = runBlocking {
    repeat(8) {
        Log.e(TAG, "协程执行$it 线程id：${Thread.currentThread().id}")
        delay(1000)
    }
}
// 主线程id：**
// 协程执行0 线程id：1
// 协程执行1 线程id：1
// ……
// 协程执行8 线程id：1
// 协程执行结束

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

• launch:Job

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

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    Log.e(TAG, "主线程id：${mainLooper.thread.id}")
    val job = GlobalScope.launch {
        delay(6000)
        Log.e(TAG, "协程执行结束 -- 线程id：${Thread.currentThread().id}")
    }
    Log.e(TAG, "主线程执行结束")
}

//Job中的方法
job.isActive
job.isCancelled
job.isCompleted
job.cancel()
jon.join()

launch不会阻断主线程。
主线程id：1
主线程执行结束
协程执行结束-- 线程id：1

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
}

从方法定义中可以看出，launch() 是CoroutineScope的一个扩展函数，CoroutineScope简单来说就是协程的作用范围。launch方法有三个参数：1.协程下上文；2.协程启动模式；3.协程体：block是一个带接收者的函数字面量，接收者是CoroutineScope

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

• Dispatchers.Main：使用这个调度器在 Android 主线程上运行一个协程。可以用来更新UI 。在UI线程中执行
• Dispatchers.IO：这个调度器被优化在主线程之外执行磁盘或网络 I/O。在线程池中执行
• Dispatchers.Default：这个调度器经过优化，可以在主线程之外执行 cpu 密集型的工作。例如对列表进行排序和解析 JSON。在线程池中执行。
• Dispatchers.Unconfined：在调用的线程直接执行

2.启动模式

在Kotlin协程当中，启动模式定义在一个枚举类中：

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

一共定义了4种启动模式，下表是含义介绍：

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

2.协程体

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

• async

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

// 错误写法
suspend fun loadAndCombine(name1: String, name2: String): Image { 
    val deferred1 = async { loadImage(name1) }
    val deferred2 = async { loadImage(name2) }
    return combineImages(deferred1.await(), deferred2.await())
}

ansync 多层嵌套的的时候以上写法，loadAndCombine 本身已运行在一个挂起的协程之中，当loadAndCombine所在协程结束或取消无法控制async 的子协程。

将代码封装到 coroutineScope { ... } 块中，这个块为你的操作及其范围建立了边界。所有异步协程都成为这个范围的子协程，如果该作用域因为异常导致失败或被取消了，它所有的子协程也将被取消。

suspend fun loadAndCombine(name1: String, name2: String): Image =
    coroutineScope { 
        val deferred1 = async { loadImage(name1) }
        val deferred2 = async { loadImage(name2) }
        combineImages(deferred1.await(), deferred2.await())
    }

• withContext

withContext 与 async 都可以返回耗时任务的执行结果。 一般来说，多个 withContext 任务是串行的， 且withContext 可直接返回耗时任务的结果。 多个 async 任务是并行的，async 返回的是一个Deferred<T>，需要调用其await()方法获取结果。

• 线程调度

我们可以使用Dispatchers.Main ，Dispathers.IO 进行主线程和io线程切换

CoroutineScope(Dispatchers.Main).launch {
        val time1 = System.currentTimeMillis()
 
        val task1 = withContext(Dispatchers.IO) {
            delay(2000)
            Log.e("TAG", "1.执行task1.... [当前线程为：${Thread.currentThread().name}]")
            "one"  //返回结果赋值给task1
        }
                
        val task2 = withContext(Dispatchers.IO) {
            delay(1000)
            Log.e("TAG", "2.执行task2.... [当前线程为：${Thread.currentThread().name}]")
            "two"  //返回结果赋值给task2
        }
 
        Log.e("TAG", "task1 = $task1  , task2 = $task2 , 耗时 ${System.currentTimeMillis()-time1} ms  [当前线程为：${Thread.currentThread().name}]")
    }

• CommonPool

我理解是线程池，看之前别人分享的文章中有涉及到lunch(CommonPool) 这样的操作。用新版不能这样写，看了一下源码

在使用lunch 或者async 的时候若果没有指定调度器，它由JVM上的共享线程池支持。默认情况下，使用的最大并行级别通过这个调度程序等于CPU核心的数量，但至少是两个。
并行级别X保证在这个调度程序中并行执行的任务不能超过X个。

internal actual fun createDefaultDispatcher(): CoroutineDispatcher =
    if (useCoroutinesScheduler) DefaultScheduler else CommonPool