协程的作用

官方描述：协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、订阅相关事件、在不同线程（甚至不同机器）上调度执行，而代码则保持如同顺序执行一样简单。kotlin 官方中文详细文档

协程最大的作用就是切换线程。Rxjava也可以线程切换，所以协程与Rxjava切换线程类似的，Rxjava切换是线程，而Kotlin的协程与Rxjava是不同的，协程和线程又有不同的，一个协程是一块块，每一块都有一个上下文Context，通过上下文做桥接来切换。

比如：有A线程和B线程，有三个代码块C1、C2、C3，这些代码块在执行时，在那个线程（A线程或B线程）上切换呢，那么就由协程去控制了，如A线程执行C1、C2代码块，B线程执行C3代码块。执行的单元以协程上下文Context，这么一块一块为单位来切换的。

可以简单地理解为，协程封装好一块块的代码在线程上执行，如封装好的一块块执行单元C1、C2在A线程上，如果要切换到B线程上，那么C1或C2的结果就以条件参数方式传入到C3中在B线程上执行。

协程的使用

1、添加依赖

//协程相关的核心库
  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2'
  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2'

2、创建协程

在 kotlin 里面提供了大量的高阶函数，kotlin 中 GlobalScope 类提供了几个携程构造函数。
runBlocking - 不是 GlobalScope 的 API，可以独立使用，区别是 runBlocking 里面的 delay 会阻塞线程，而 launch 创建的不会。
launch- 创建协程。
async - 创建带返回值的协程，返回的是 Deferred 类。
withContext - 不创建新的协程，在指定协程上运行代码块。

kotlin 在 1.3 之后要求协程必须由 CoroutineScope 创建，CoroutineScope 不阻塞当前线程，在后台创建一个新协程，也可以指定协程调度器。

3、runBlocking:T

class MainActivity : AppCompatActivity(){
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    tv_name.text = "learning kotlin"

    Log.e("lu","主线程——${Thread.currentThread().name}_id_${Thread.currentThread().id}")
    test()
    Log.e("lu","协程执行结束。")
}
  private fun test() = runBlocking {
    //循环10次
    repeat(10){
        Log.e("lu","协程执行$it——${Thread.currentThread().name}_id_${Thread.currentThread().id}")
        //挂起2秒
        delay(2000)
        }
      }
  }

  打印的结果
E/lu: 主线程——main_id_1
E/lu: 协程执行0——main_id_1
E/lu: 协程执行1——main_id_1
E/lu: 协程执行2——main_id_1
E/lu: 协程执行3——main_id_1
E/lu: 协程执行4——main_id_1
E/lu: 协程执行5——main_id_1
E/lu: 协程执行6——main_id_1
E/lu: 协程执行7——main_id_1
E/lu: 协程执行8——main_id_1
E/lu: 协程执行9——main_id_1
E/lu: 协程执行结束。

得出结论：

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

4、launch:Job

   class MainActivity : AppCompatActivity(){
   override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   setContentView(R.layout.activity_main)
   tv_name.text = "learning kotlin"
​
   Log.e("lu","主线程——${Thread.currentThread().name}_id_${Thread.currentThread().id}")
  //        test()
   var job = GlobalScope.launch {
   //挂起5秒
   delay(5_000)
   Log.e("lu","协程执行——${Thread.currentThread().name}_id_${Thread.currentThread().id}")
   }
   Log.e("lu","主线程执行结束。")

   //另一种写法   指定调度器
   Log.e("lu","主线程——${Thread.currentThread().name}_id_${Thread.currentThread().id}")
  //        test()
   var job = GlobalScope.launch(Dispatchers.Unconfined) {
   //挂起5秒
   delay(5_000)
   Log.e("lu","协程执行——${Thread.currentThread().name}_id_${Thread.currentThread().id}")
   }
   Log.e("lu","主线程执行结束。")

   }
  }

    打印的结果
 E/lu: 主线程——main_id_1
 E/lu: 主线程执行结束。
 E/GED: Failed to get GED Log Buf, err(0)
 E/lu: 协程执行——DefaultDispatcher-worker-1_id_2664

launch:Job是最常用的用于启动协程的方式，它最终返回一个Job类型的对象，这个对象实际上是一个接口，它包涵了许多我们常用的函数和变量。

  //Job中的常用方法
  job.isActive//是否激活
  job.isCancelled//是否取消
  job.isCompleted//是否完成
  job.start()//启动协程，除了LAZY模式，协程都不需要手动启动
  job.cancel()//调用取消函数，取消一个协程
  job.join()//阻塞,直到某个协程执行完毕
  job.cancelAndJoin()//等待协程执行完毕，然后再取消

得出结论:

从执行结果看出，launch不会阻断主线程。

5、async

 class MainActivity : AppCompatActivity(){
 override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   setContentView(R.layout.activity_main)
   tv_name.text = "learning kotlin"
   GlobalScope.launch {
       var result1 = GlobalScope.async {
           getResult1()
       }
       var result2 = GlobalScope.async {
           getResult2()
       }

       var result = result1.await()+result2.await();
       Log.e("lu","result——${result}")
   }
 }

 private suspend fun getResult1():String{
   delay(3_000)
   return "返回结果1"
 }
 private suspend fun getResult2():String{
   delay(3_000)
   return "返回结果2"
 }
 }

打印的结果
E/lu: result——返回结果1返回结果2
E/lu: 执行时间 3 秒

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

得出结论:

async是不阻塞线程的,也就是说getResult1和getResult2是同时进行的，所以获取到result的时间是3s，而不是6s。

async 返回的是 Deferred 类型，Deferred 继承自 Job 接口，Job有的它都有，增加了一个方法 await ，这个方法接收的是 async 闭包中返回的值，async 的特点是不会阻塞当前线程，但会阻塞所在协程，也就是挂起。

注意：async 并不会阻塞线程，只是阻塞锁调用的协程。