Kotlin中的协程通俗理解

What?

维基百科

协程是计算机程序的一类组件，推广了协作式多任务的子程序，允许执行被挂起与被恢复

自己的理解（要写出定义需要理解很深。理解不深，模糊一看哈）

协程是一种通过中断机制实现替代回调机制的子程序

Why?

和RxJava（不懂的请看之前写的Rxjava文章）比较的优点

• 使用协程能让代码更加简洁，极大避免回调方法
• 避免了耗费资源的线程切换（核心优势呀）

缺点

• 较少的语言支持协程，比如Java
• 对各种控制流的支持应该还没有全覆盖，RxJava几乎全搞定
• 似乎没有了。。。。。

When?

在需要执行耗时操作的时候用，如果懂RxJava的，就可以说能够替代大部分简单的用RxJava写的代码。但是你如果之前是用Java写的Rx,那还是洗洗睡吧。

How?

这里用代码形式介绍使用协程的三种控制流的写法，具体细节会在代码中展示

• 第一种控制流：在子线程中执行耗时操作，在UI线程中更新View
• 第二种控制流：两个耗时任务task1,task2有依赖，task2必须等待task1执行完成后才能执行.
• 第三种控制流：同时开两个线程执行耗时任务，两个都执行完成后，UI线程加载返回的数据

package com.yueyue_projects.demo.coroutines

import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import com.yueyue_projects.demo.R
import com.yueyue_projects.demo.utils.MyLog
import kotlinx.android.synthetic.main.activity_coroutines.*
import kotlinx.coroutines.*

class CoroutinesActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_coroutines)
        // 第一种控制流
        requestDataAndUpdateUI()
        // 第二种控制流
        requestTwoDependencyDataAndReturn()
        // 第三种控制流
        requestDirectTwoDataAndUpdateUI()
        // 中断发送后，主线程来执行其他事情了
        tv_1.text = "data is loading please wait"
        tv_2.text = "data is loading please wait"
        tv_3.text = "data is loading please wait"
    }
   // 通过launch在主线程中创建一个协程，Dispatchers.Main表示在主线程中启动，默认是在IO线程中启动
    // 等待子线程执行完成更新UI
    private fun requestDataAndUpdateUI() = GlobalScope.launch(Dispatchers.Main) {
        tv_1.visibility = View.VISIBLE
        // 获取数据,async默认的启动模式是在IO线程中
        val deferred = async {
            delay(2000)
            "data loading has finished"
        }
        // deferred.await()子线程给主线程发送中断,中断现在的事情，去做其他事情
        tv_1.text = deferred.await()
    }
     private fun requestTwoDependencyDataAndReturn() = GlobalScope.launch(Dispatchers.Main) {
        // 进入协程
        tv_2.visibility = View.VISIBLE
        // withContext相当于async{}.await()
        // await底层原理即给Main线程发送中断不要干这件事情了，去干其他的，即在这里协程挂起
        tv_2.text = withContext(Dispatchers.Default) {
            delay(2000)
            "task1 has finished, task2 is starting"
        }
        // 第一个任务执行返回后，继续执行第二个任务
        tv_2.text = withContext(Dispatchers.Default) {
            delay(2000)
            "task2 has finished"
        }
    }
    
    /**
     * 并发请求两条数据
     */
    private fun requestDirectTwoDataAndUpdateUI() = GlobalScope.launch(Dispatchers.Main){
        // 进入协程
        tv_3.visibility = View.VISIBLE
        val task1 = async(Dispatchers.Default) {
            delay(2000)
            "task1 has finished"
        }
        val task2 = async(Dispatchers.Default) {
            delay(2000)
            "task2 has finished"
        }
        tv_3.text = "${task1.await()} + ${task2.await()}"
    }
}