Kotlin—Coroutine(协程)的基本使用

什么是协程

在java中异步都会使用到线程，在kotlin中引入了协程的概念。与线程类似，协程也是用于处理异步的，不过与线程相比更加轻巧。协程完全通过编译技术实现，使用挂起机制来实现异步，而不会阻塞线程。协程是一种避免线程阻塞、开销更小且更加可控的异步操作。

协程的基础使用

创建协程，有三种方式runBlocking、launch、async。

• runBlocking 创建一个阻塞的协程，当协程内部代码执行完毕后才会执行后面的代码。

  fun main() {
      println("Hello")
      runBlocking {
          delay(1000)
          println("World")
      }
      println("---end---")
  }
  

  在 runBlocking 创建的协程里面，调用 delay让此协程挂起1秒。执行代码，首先打印Hello,1秒后打印World，最后打印—end—。注意delay挂起函数只有在协程内部才能调用。

• launch 在当前协程作用域下面创建一个非阻塞子协程，同时返回个 Job 对象，用来控制当前协程。

  fun main() = runBlocking {
      println("hello")
      launch {
          delay(1000)
          println("world")
      }
      println("---end---")
  }
  

  使用 runBlocking 来包裹 main 函数，函数整体都处于runBlocking创建的协程作用域下面，然后通过launch 创建一个子协程，挂起1秒之后打印输出。执行代码发现首先输出hello和—end—，等待一秒之后打印world，如何让他按顺序执行。

  fun main() = runBlocking {
      println("hello")
      val job = launch {
          delay(1000)
          println("world")
      }
      job.join()
      println("---end---")
  }
  

  修改代码，拿到 launch 返回的job对象，调用 join() 函数，此时会等待job协程内部的代码执行完毕后才会往后执行。执行代码，先打印hello，然后1秒后打印world和—end—。

• Job 常用方法

  • isActive
  • isCompleted
  • isCanceledstart
  • cancel
  • join

• GlobalScope.launch 创建一个全局非阻塞协程，

  fun main() {
      println("hello")
      GlobalScope.launch {
            delay(1000)
          println("world")
      }
      Thread.sleep(1500)
      println("---end---")
  }
  

  使用 GlobalScope.launch 在任何地方都能创建一个全局的协程，由于 launch 创建的协程是非阻塞的，所以让当前线程睡眠1.5秒等待协程执行完毕。与上面代码打印结果一样。由于使用 GlobalScope.launch 时，会创建一个顶层协程。虽然很轻量，但它运行时仍会消耗一些内存资源，所以通常是在协程内部作用域下使用launch创建协程，而不是使用GlobalScope来创建全局协程。

• async 创建一个非阻塞协程，同时返回Deferred ，可通过 await() 函数获取协程返回的具体值；

  fun main() = runBlocking {
      println("hello")
      val def = async {
          delay(1000)
          "world"
      }
      println(def.await())
      println("---end---")
  }
  

• 挂起函数

  接着上面例子，将 launch 协程内部的代码封装为一个函数，使用suspend关键，这个函数就叫 挂起函数，上面的 delay 就是一个封装好的挂起函数。

  fun main() = runBlocking {
      println("hello")
      val job = launch {
          delay1000()
      }
      job.join()
      println("---end---")
  }
  
   suspend fun delay1000(){
      delay(1000)
      println("world")
  }
  

• 调度器

  上面提到三种创建协程的方式都有一个选填参数 CoroutineContext，协程的上下文环境。也就是协程调度器，调度器确定了协程执行的线程环境。

  • Dispatchers.Default 默认后台线程池里的线程 ;
  • Dispatchers.Main Android主线程;
  • Dispatchers.IO 后台线程池里的IO线程 ;
  • Dispatchers.Unconfined 不限制，使用父协程所属的线程;
  • newSingleThreadContext 使用新的线程。

  如需要在协程中切换调度器可使用withContext，withContext返回最后一行代码的返回值。

• Android中的使用

  简单了介绍了协程的基本使用，写个小demo，模拟网络请求然后再界面展示数据。在activity中首先要实现CoroutineScope 接口，然后通过by关键字将接口的具体实现委托给 MainScope，这样当前activity就是一个协程作用域了。

  class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
  
      override fun onCreate(savedInstanceState: Bundle?) {
          super.onCreate(savedInstanceState)
          setContentView(R.layout.activity_main)
          button.setOnClickListener {
              showData()
          }
      }
    // 创建协程，默认在当前线程，也就是UI线程
      private fun showData() = launch {
          progress.visibility = View.VISIBLE
          textView.text = loadData()
          progress.visibility = View.GONE
      }
  
    //网络请求 切换为IO线程
      private suspend fun loadData()= withContext(Dispatchers.IO) {
          delay(2000)//挂起2秒 模拟网络请求
          "假装这是网络请求到的数据" //返回请求到的数据
      }
  }
  

基本介绍完了协程的最最最基础的使用，相比于线程除了内存开销更小、不会造成线程阻塞的优点之外之外，个人觉得在没有用RxJava的情况下可以少写很多线程的创建、切换、异步接口的回调。让代码更加干净清爽。
个人学习笔记，如有错误不对的地方欢迎各位大佬指出。