一、什么是协程
官方给的解释：一种轻量级的线程。
普遍的解释：协程就是协同程序，而kotlin协程就是基于java thread api封装的工具包，帮助我们轻松的写出复杂的并发代码。
二、为什么要使用协程，协程的优点是什么？
我们先看一下没有协程之前处理异步的方式有哪些，无非就是四个方式：
1、线程
缺点：
- 资源消耗
- 数量受限
- 平台支持（js不支持线程）
- 调试使用不便
2、回调
缺点：
- 多层嵌套
- 错误处理麻烦
3、Futures、Promise（第三方开源框架）
缺点：
- 改变编程方式，如处理异常与循环作用等，在其中无效
- api学习，平台差异
- 返回限定promise
- 异常处理复杂
4、Rx响应式扩展（比较流行的处理异步的框架）
缺点：
- 学习曲线比较长
- 行为难估
- api多、繁杂
最后就是我们的主角协程了，相比较而言，协程易学易用，但是要想用的溜一点，还是要花时间好好学习的。最主要的是协程与jetpack、kotlin、AAC、MVVM可以完美结合，毕竟是官方主推的一个系列开发方式。
特别是协程中的scope和MVVM结合使用感知生命周期可以有效避免内存泄漏的问题。
三、协程的具体使用
首先导入协程：
// Coroutines
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2'
启动协程的几种方法
Launch
先写一个测试函数
fun testLaunch() {
val time: Long = measureTimeMillis {
GlobalScope.launch {
Thread.sleep(1000)
Log.d("hhh","testLaunch的launch1中，${Thread.currentThread()} 我很好")
}
GlobalScope.launch {
Thread.sleep(1000)
Log.d("hhh","testLaunch的launch2中，${Thread.currentThread()} 嘿嘿嘿")
}
Log.d("hhh","你好么？ ${Thread.currentThread()} ")
Thread.sleep(22000)//这里需要等待，否则代码函数生命周期结束就销毁了函数栈，导致两个协程没有执行
}
Log.d("hhh","函数总耗时: $time")
}
执行结果
值得注意的是，两个协程是异步的，执行的先后顺序不能确定，也有可能先执行第二个，比如：
runBlocking
关于上面的测试方法，我们可以知道，由于GlobalScope.launch是不阻塞线程，为了等待协程完毕再销毁函数栈，还得让线程等待，也就是：
Thread.sleep(22000)//这里需要等待，否则代码函数生命周期结束就销毁了函数栈，导致两个协程没有执行
怎样让他们变成阻塞式的呢，所以就说到线程的另一个方法runBlocking，这个是阻塞线程的，我们写一个方法来测试一下
fun testRunBlocking() {
val time = measureTimeMillis {
runBlocking {
GlobalScope.launch {
Thread.sleep(1000)
Log.d("hhh", "launch1 ${Thread.currentThread()} ")
}
GlobalScope.launch {
Thread.sleep(1000)
Log.d("hhh", "launch2 ${Thread.currentThread()}")
}
}
Log.d("hhh", "testRunBlocking ${Thread.currentThread()} hello!!")
}
Log.d("hhh", "线程总耗时: $time")
}
执行结果：
从结果我们可以可看到它是可以阻塞当前线程的。简单地说就是runBlocking会等待内部所有协程结束以后才会结束函数栈，但是它内部协程的执行顺序依然不会阻塞。
协程中的join和cancle方法
- jion():将两个异步协程定位顺序执行，比如先执行玩T1线程再执行T2线程
- cancle():取消某个线程的执行
说再多不如看代码，一个个来，先看jion()
fun testJoin()= runBlocking {
val time= measureTimeMillis {
val a1=async {//async也是开启协程的一种方式，和launch一样，只是返回结果不同
repeat(10){//循环20次
Log.d("hhh","a1")
delay(200)
}
}
a1.join()
val a2=async {
Log.d("hhh","a2")
}
}
Log.d("hhh","线程总耗时: $time")
}
执行效果：
从结果中可以看出，由于加入了join函数，它会执行完a1协程之后才往下执行。这个其实就和线程的join()方法一样。
再来看看cancle()方法，cancle()方法其实就是取消一个协程的执行，一样的，来看看例子：
fun testJoin()= runBlocking {
val time= measureTimeMillis {
val a1=async {
repeat(10){//循环20次
Log.d("hhh","a1")
delay(200)
}
}
val a2=async {
Log.d("hhh","a2")
a1.cancel()//取消a1线程
}
}
Log.d("hhh","线程总耗时: $time")
}
执行结果：
从结果中可以看出，我们在a2协程中调用了a1.cancle()，也就达到了取消a1协程的效果，本来该打印10次的协程a1打印一次之后就被终止了。
协程中的await方法
我们现在都知道了runBlocking只是启动一个协程块，保证里面所有协程执行完毕后才会结束函数栈，协程块内部依然是异步的，在开发中往往需要在所有协程得到结果之后再进行下一步操作，这就需要用到await()了，他能保证在所有协程结束并获得返回结果之后再执行下一步。
注意：使用await时，协程启动方式只能用async(),因为launch()和async()虽然都是启动协程，但是返回结果不一样，launch()返回的是Job类型，async()返回的是Deferred<T>类型，所以async()能够接受各种返回值类型，而launch()不可以。
看例子，看例子
fun testAwait()= runBlocking {
val time= measureTimeMillis {
val a1=async {
Log.d("hhh","hello a1")
delay(2000)
300//返回结果
}
val a2=async {
Log.d("hhh","hello a2")
delay(3000)
400
}
Log.d("hhh","a1结果: ${a1.await()}---a2结果：${a2.await()}")
}
Log.d("hhh","函数总耗时：$time")
}
执行结果：
以上图结果来看，我们在两个线程中都模仿了耗时操作，当它并没有先执行下面的语句，而是在两个协程都获得返回结果之后才继续往下执。
值得注意的是，很多人就会想，这样用join()也可以实现啊，分别调用两个协程的join()不就可以实现了吗？但是如果那样做的话总耗时就变成了两个协程耗时的时间总和，也就是5000，但我们可以看到总耗时是3000多一点，因为用await两个协程是异步的，所以总耗时只是约等于耗时较长那个协程的执行时间。（类似于物理中电阻的串联和并联）
最后说一下，很多人觉得协程和线程基本差不多，那为啥还要多此一举呢，前面已经说过了，主要就是两点，一个是它可以减少资源损耗，第二个是它可以完美配合jackpet组件使用，比如监听生命周期，避免内存溢出等问题，反正也不能用语言描述，就像开发Android用Java还是用kotlin，肯定是kotlin，具体原因也说不出来，谁用谁知道，还在杠kotlin可读性差的人证明你还不熟悉kotlin，就像解数学题一样，巴不得老师把每一个步骤都写出来，其实高手往往可以一步到位。
