kotlin--协程入门

协程到目前为止没有一个具体的定义，但很多语言都有协程，但每个语言又有所不同，官方说协程基于线程，是轻量级的线程。在我看来，协程是一种趋势，它让我们从繁琐的多线程中释放出来，提高我们的编写代码的效率。

为什么说这是一种趋势，就像我们之前学习的函数式编程，从最开始的面向方法编程，到面向对象编程，再到函数式编程，程序员们经历了造轮子，用轮子，再最后到的“指挥”。我把函数式编程理解为面向管理编程，因为我从中感受到，我使用函数式编程时，不再像是以前照顾小孩一般写代码了，而是代码“长大了”，我们可以对它发号施令，让它自己完成某些事，使得我们从一个实施者摇身称为一个管理者

俗话说的好：不会偷懒的程序员不是一个好的程序员，能复制粘贴的绝对不会手写。人类的懒惰有了现在各种便利的东西，协程也不例外。说到多线程，大多数程序员都会觉得头疼，因为要考虑的东西太多了，我们的计算机就像小孩，不考虑周全，它就随时可能摔跤

多线程的逻辑是反人类的，因为每个人的思考行为也是单线程的，所以多线程更像是多人协作，一旦手忙脚乱，就容易出错，这个时候就需要有一个合格的管理者。以前的管理者很累，每个人手头上的事情做完了都会通知管理者，然后再由管理者分配新的任务，有时候太忙了，管理者自己都会被搞晕。协程更像是一个管理者的秘书，它让我们从复杂的逻辑中得到解放，只需要告诉秘书执行流程，其他的都交由秘书安排

以上就是我对协程的理解，接下来来学习如何使用kotlin的协程

一、实现异步任务相同功能

如果说我们有一个耗时操作，并且完成后更新ui界面，我们以前会考虑使用异步任务，我这里模拟了一个耗时操作，点击TextView，然后开启一个异步任务，最后更新ui

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val helloTextview = findViewById<TextView>(R.id.tv_hello)
        //点击TextView
        helloTextview.setOnClickListener {
            object : AsyncTask<Void, Void, String>() {
                override fun doInBackground(vararg p0: Void?): String {
                    Thread.sleep(2000)

                    //2秒后返回一个字符串
                    return "doInBackground complete"
                }

                override fun onPostExecute(result: String?) {
                    //将返回的字符串设置到TextView上
                    helloTextview.text = result ?: ""
                }
            }.execute()
        }
    }
}

使用时，我们会发现as工具给出了AsyncTask过时的提示，说明以后会渐渐被协程取代

接下来是协程的写法：
首先需要gradle里添加下协程的依赖

dependencies {
    //依赖协程核心库 ，提供Android UI调度器
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.2.1"
    //依赖当前平台所对应的平台库 (必须)
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1'
}

协程代码：

        //点击TextView
        helloTextview.setOnClickListener {
            GlobalScope.launch(Dispatchers.Main) {
                val result = withContext(Dispatchers.IO) {
                    Thread.sleep(2000)
                    "doInBackground complete"
                }

                helloTextview.text = result
            }
        }

相比于异步任务，协程的写法更加符合我们的逻辑了，协程的代码很容易理解，就是等待耗时任务返回结果，然后将结果设置到TextView上
协程的核心就是函数或一段程序能够被挂起，稍后再在挂起的位置恢复。玩过单片机的同学，肯定会觉得这个和“中断”很像，理解起来是差不多的，当然这两个是完全不同的层级了

二、协程的挂起与恢复

常规函数基础操作除了的invoke（或call）和return，协程新增了suspend和resume
suspend：也称为挂起或暂停，用于暂停执行当前协程，并保存所有局部变量
resume：用于让已暂停的协程从其暂停出继续执行

1.挂起函数

使用suspend关键字修饰的函数叫做挂起函数
挂起函数只能在协程体内或其他挂起函数内调用

挂起主要是和阻塞进行对比，挂起函数调用时并不会阻塞当前线程
挂起：

class MainActivity : AppCompatActivity() {
    private var helloTextview: Button? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        helloTextview = findViewById<Button>(R.id.tv_hello)

        //点击TextView
        helloTextview?.setOnClickListener {
            GlobalScope.launch(Dispatchers.Main) {
                getInfo()
            }
        }
    }

    suspend fun getInfo() {
        //延迟2秒后得到info
        val info = getInfoBackground()

        helloTextview?.text = info
    }

    suspend fun getInfoBackground() = withContext(Dispatchers.IO) {
        //延迟2秒
        Thread.sleep(2000)
        "abc"
    }
}

效果：

挂起函数.gif

阻塞：

       //点击TextView
       helloTextview?.setOnClickListener {
           GlobalScope.launch(Dispatchers.Main) {
               //                getInfo()
               Thread.sleep(2000)
               helloTextview?.text = "sleep"
           }
       }

效果：

阻塞.gif

很明显我们的主线程阻塞了，但挂起不会，并且挂起函数执行完后，自动执行下面的更新ui的代码，我们再也不用写回调函数了

三、调度器

所有的协程必须运行在调度器中，也就是我们之前代码指定的Dispatchers，即使在主线程也是如此
官方提供的调度器为以下三种：

调度器

四、协程的两部分

kotlin的协程实现分为两个层次，我们之前使用的都是业务框架层
1.基础设施层，标准库的协程API，主要对协程提供了概念和语义上最基本的支持
2.业务框架层，协程的上层框架支持

基础设施写法：

fun main() {
    val corountine = suspend {
        //协程体里做耗时操作
        Thread.sleep(100)
        10
    }.createCoroutine(object : Continuation<Int> {
        override val context: CoroutineContext = EmptyCoroutineContext

        //执行完成后，回调resumeWith函数
        override fun resumeWith(result: Result<Int>) {
            println(result)
        }

    })


    //开始执行
    corountine.resume(Unit)

    println("main执行完成")
}

实际上协程也是用的回调，是不过业务框架层已经做了封装

五、结构化并发

当某个协程任务丢失，无法追踪，会导致资源浪费，甚至发送一个无用的网络请求，这种情况称为任务泄漏
为了解决任务泄漏，kotlin引入了结构化并发机制
使用结构化并发可以做到
1.取消任务，当某项任务不需要执行了，取消它
2.追踪任务，某项任务正在执行，追踪它
3.发出错误信号，当协程失败时，发出错误信号表明有错误产生

CoroutineScope

定义协程必须指定其CoroutineScope，它会跟踪所有协程，同样它还可以取消由它所启动的所有协程
常用的相关API有：
1.GlobalScope：生命周期是process级别，即使Activity或Fragment销毁，协程还是会运行
2.MainScope：在Activity中使用，可以在onDestroy中取消
3.ViewModelScope：只能在ViewModel中使用，绑定ViewModel的生命周期
4.LifecycleScope，只能在Activity、Fragment中使用，绑定它们的生命周期