Kotlin之协程（一）初识

简介

介绍

    协程是一种并发设计模式，您可以在 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等，记录自己的学习与理解的相关内容，当然希望也能对大家有
那么一点点的帮助或者启发，我就很开心了。当然了本人也是在学习与理解的过程中记录与理解
难免有一定的认知局限性，如果发现有什么问题，欢迎指正，谢谢。