1.协程

协程?我们明确一下这篇文章,我们需要了解什么东西.

1.协程是什么东西
2.协程用来干什么
3.协程怎么写
~~> 4.你对我的爱有多深~~

在这里插入图片描述
根据大佬们的理解,协程大概可以理解为.
一种轻量级线程,协程类似于线程,但是它算是一种可以在单线程模式下模拟多线程编程的效果.里面状态中的挂起和恢复和我们的操作系统无关,只和函数有关
区别：线程运行在内核态,协程运行在用户态
总结:Android kotlin中协程是一个线程框架

根据定义得出作用:跟线程差不多的作用, 用来做异步/网络请求

2.协程域的定义

如果运行在Android上,请先引入依赖:

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9'

(1).GlobalScope.launch: 顶层协程域,任何地方都可以开始创建,但当应用程序结束时,协程也会跟着一起结束。(Android不常用)

很容易看出,下面的语句中,只有"initDebug 1"被打印,而"initDebug 2"因为程序已经结束而无法被打印出.

这里解释一下delay()函数,这里是让协程延迟指定时间后再运行,是协程特有的。

  fun main(){
        GlobalScope.launch {
            Log.d(TAG, "initDebug: 1")
            delay(1500)
            Log.d(TAG, "initDebug: 2")
        }
        Thread.sleep(1000)  
    }

(2)runBlocking: 协程域.但它可以保证在协程域内所有代码和子协程在没有执行完前一直阻塞当前线程. (相当不常用)
会发现,两条语句都被打印出来了.

  fun main(){
        runBlocking {
            Log.d(TAG, "initDebug: 1")
            delay(1500)
            Log.d(TAG, "initDebug: 2")
        }
        Thread.sleep(1000)  
    }

(3)coroutineScope:作用域。是一个挂起函数,它的作用就是继承外部协程作用于并创建一个子作用域,一般用作在挂起函数内,开启一个子协程域 (常用在于挂起函数内)
解释一下挂起函数,简单理解就是要求这个函数必须执行在协程中的函数

suspend fun oo(){
coroutineScope {
launch {
	}
}

(4).viewModel.viewModelScope.launch: 配合ViewModel使用上的,一个常用分配作用域,因其跟随着Activity/Fragment的生命周期 (非常推荐使用).
看其源码,你们可以看到CoroutineScope类,它返回的就是这么一个对象,这个对象可以使用.lanuch()去随意创建一个成协程

public val ViewModel.viewModelScope: CoroutineScope
    get() {
        val scope: CoroutineScope? = this.getTag(JOB_KEY)
        if (scope != null) {
            return scope
        }
        return setTagIfAbsent(
            JOB_KEY,
            CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
        )
    }

这里可以看到, 这里返回的是Job,这里可以通过cancle(),让协程进入cancle()状态,注意,是cancle状态,而不是直接取消掉这个协程,后面会说到这个点

    val Job = viewModel.viewModelScope.launch {
            oo()
        }
        Job.cancle()

累了吗?累了,来看看图。
在这里插入图片描述

3.协程域内的协程开启

(1).launch: 开启一个协程,返回一个Job对象.
我们这里只用在Androdi上最常用创建协程域的方法进行操作
我们可以来分析一下这里，这里相当于一个父协程内开启了另一个子协程

  val Job = viewModel.viewModelScope.launch {
            val JobChildren =launch {
                Log.d(TAG, "Job1: ")
            }
        }

(2).async: 开启一个线程,返回Deferred对象。会返回代码块内执行的结果.使用await(),获取结果
但它有一个更重要的特性,若代码块内还未执行完毕,await()方法获取结果时会将当前协程阻塞

      val Job = viewModel.viewModelScope.launch {
            val result =async {
                Log.d(TAG, "Time:${System.currentTimeMillis()}")
                //模拟网络请求数据
                delay(1000)
                5+5
            }.await()

            Log.d(TAG, "等待获取结果:${result}")
            Log.d(TAG, "Time:${System.currentTimeMillis()}")
        }

我们这里可以看到,我们在花时间请求数据后,协程会等待返回结果再继续执行下去.可以看到,这里可以说解决了我们痛恨的死亡后调地狱的问题.

D/NemoMainActivity: Time:1639619877149
D/NemoMainActivity: 等待获取结果:10
    Time:1639619878152

4.调度器

有了调度器之后,协程才真正意义上被赋予了灵魂.
这里实现一个功能。
我们知道一般的网络请求,我们会放到异步去执行, 执行完毕后,才回到主线程进行UI操作,那么我们的协程是如何实现的呢?
就是那么简单粗暴,我们可以在开启协程的时,添加线程参数.

Dispatchers.Default:默认的低并发线程策略。
Dispatchers.Main:Android主线程内执行
Dispatchers.IO:高并发线程策略.

 val Job = viewModel.viewModelScope.launch {
            val result =async(Dispatchers.IO) {
                Log.d(TAG, "Time:${System.currentTimeMillis()}")
                //模拟网络请求数据
                delay(1000)
                5+5
            }.await()

            launch(Dispatchers.IO) {
                binding.TestButton2.text = result
                
            }
        }

withContext(),这里提醒一个withContext,它类似于async(),但是这里强制要求我们指定一个线程参数。

 val Job = viewModel.viewModelScope.launch {
            val result =withContext(Dispatchers.IO) {
                Log.d(TAG, "Time:${System.currentTimeMillis()}")
                //模拟网络请求数据
                delay(1000)
                5+5
            }.await()

            launch(Dispatchers.IO) {
                binding.TestButton2.text = result
                
            }
        }