简介

介绍
协程是一种并发设计模式，您可以在 Android 平台上使用它来简化异步执行的代码。
简单来说就是执行异步任务。
参考文档
  1. 谷歌开发者
  2. Kotlin文档
文章目录

Kotlin之协程（一）初识Kotlin之协程（二）取消

优点

  1. 轻量：您可以在单个线程上运行多个协程，因为协程支持挂起，不会使正在运行协程的线程阻塞。挂起比阻塞节省内存，且支持多个并行操作。
  2. 内存泄漏更少：使用结构化并发机制在一个作用域内执行多项操作。
  3. 内置取消支持：取消操作会自动在运行中的整个协程层次结构内传播。
  4. Jetpack 集成：许多 Jetpack 库都包含提供全面协程支持的扩展。某些库还提供自己的协程作用域，可供您用于结构化并发。

协程之HelloWorld实现

依赖引入
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0'
   implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.0'
代码实现
GlobalScope.launch {
    delay(1000)
    Log.d(Constants.TAG,"World")
}
Log.d(Constants.TAG,"Hello")
效果

先输出Hello，协程延迟一秒输出World，打印日志如下：

2021-08-26 13:50:00.207 26316-26316/demo.demo.democoroutines D/Coroutines: Hello
2021-08-26 13:50:01.230 26316-26754/demo.demo.democoroutines D/Coroutines: World

协程之结构化的并发

结构化并发，听起来感觉不是太好理解，其实主要是为了实现对协程的管理。如果我们任意地
	去启动协程而不做管理会出现如我们不需要了，但是我们没有引用与取消，协程还在运行等
	诸如此类的问题。结构化并发主要是通过创建顶级协程进行协程任务的统一管理，当然这属
	于个人通俗的理解，如有问题或者有什么其他的看法，欢迎指出与讨论。
代码实现

主要是通过 runBlocking等协程构建器将函数转换为协程，方法的调用和常规调用一直

private fun test()= runBlocking {

      val job = GlobalScope.launch {
          repeat(100){
              delay(1000)
              Log.d(Constants.TAG,"协程打印：$it")
          }
      }
        delay(5*1000)
        job.cancel()

    }

协程之取消

进行循环一百次打印（每次延迟1s），在5s之后取消。

代码实现
private fun test()= runBlocking {
      val job = GlobalScope.launch {
          repeat(100){
              delay(1000)
              Log.d(Constants.TAG,"协程打印：$it")
          }
      }
        delay(5*1000)
        job.cancel()
    }
效果

可以看到打印了4次，到第5次打印的时候取消了任务不能再进行打印

2021-08-26 14:20:50.853 29331-29384/demo.demo.democoroutines D/Coroutines: 协程打印：0
2021-08-26 14:20:51.855 29331-29384/demo.demo.democoroutines D/Coroutines: 协程打印：1
2021-08-26 14:20:52.858 29331-29384/demo.demo.democoroutines D/Coroutines: 协程打印：2
2021-08-26 14:20:53.865 29331-29384/demo.demo.democoroutines D/Coroutines: 协程打印：3

协程之Join

join函数作用
主要是实现占用执行，执行完毕之后再进行其他协程任务的执行
下面对比两种效果看下join的作用
代码实现1
private fun test()= runBlocking {
        
        GlobalScope.launch {
            delay(500)
            Log.d(Constants.TAG,"job-test")
        }

        GlobalScope.launch {
            delay(1000)
            Log.d(Constants.TAG,"World")
        }
        Log.d(Constants.TAG,"Hello")

    }
效果1

打印日志如下(可以看出job-test穿插在helloworld中间执行)：

2021-08-26 14:06:08.607 27747-27747/demo.demo.democoroutines D/Coroutines: Hello
2021-08-26 14:06:09.133 27747-27807/demo.demo.democoroutines D/Coroutines: job-test
2021-08-26 14:06:10.578 27747-27807/demo.demo.democoroutines D/Coroutines: World
代码实现2
private fun test()= runBlocking {
        
        val job = GlobalScope.launch {
            delay(500)
            Log.d(Constants.TAG,"job-test")
        }
        job.join()

        GlobalScope.launch {
            delay(1000)
            Log.d(Constants.TAG,"World")
        }
        Log.d(Constants.TAG,"Hello")

    }
效果

打印日志如下(可以看出helloworld在job-test执行完毕之后才进行执行)：

2021-08-26 14:16:01.914 28884-28927/demo.demo.democoroutines D/Coroutines: job-test
2021-08-26 14:16:01.916 28884-28884/demo.demo.democoroutines D/Coroutines: Hello
2021-08-26 14:16:02.919 28884-28927/demo.demo.democoroutines D/Coroutines: World

总结

本文主要对协程的概念、优点及使用做了相关的介绍，实现了简单的协程编程，如HelloWorld
、结构化编程、取消、Join等，记录自己的学习与理解的相关内容，当然希望也能对大家有
那么一点点的帮助或者启发，我就很开心了。当然了本人也是在学习与理解的过程中记录与理解
难免有一定的认知局限性，如果发现有什么问题，欢迎指正，谢谢。