一、什么是协程

官方给的解释：一种轻量级的线程。
普遍的解释：协程就是协同程序，而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")
    }

执行结果

image.png

值得注意的是，两个协程是异步的，执行的先后顺序不能确定，也有可能先执行第二个，比如：

image.png

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")
    }

执行结果：

image.png

从结果我们可以可看到它是可以阻塞当前线程的。简单地说就是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")
    }

执行效果：

image.png

从结果中可以看出，由于加入了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")
    }

执行结果：

image.png

从结果中可以看出，我们在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")
    }

执行结果：

image.png

以上图结果来看，我们在两个线程中都模仿了耗时操作，当它并没有先执行下面的语句，而是在两个协程都获得返回结果之后才继续往下执。

值得注意的是，很多人就会想，这样用join()也可以实现啊，分别调用两个协程的join()不就可以实现了吗？但是如果那样做的话总耗时就变成了两个协程耗时的时间总和，也就是5000，但我们可以看到总耗时是3000多一点，因为用await两个协程是异步的，所以总耗时只是约等于耗时较长那个协程的执行时间。（类似于物理中电阻的串联和并联）

最后说一下，很多人觉得协程和线程基本差不多，那为啥还要多此一举呢，前面已经说过了，主要就是两点，一个是它可以减少资源损耗，第二个是它可以完美配合jackpet组件使用，比如监听生命周期，避免内存溢出等问题，反正也不能用语言描述，就像开发Android用Java还是用kotlin，肯定是kotlin，具体原因也说不出来，谁用谁知道，还在杠kotlin可读性差的人证明你还不熟悉kotlin，就像解数学题一样，巴不得老师把每一个步骤都写出来，其实高手往往可以一步到位。