Android Kotlin中协程详解


前言
Kotlin协程介绍:
Kotlin 协程是 Kotlin 语言中的一种用于处理异步编程的机制。它提供了一种轻量级的线程替代方案,允许你以更简洁和可读的方式编写并发代码。

使用Kotlin协程需要引入Kotlin协程依赖包,这里引入的Kotlin核心依赖包,需要根据当前项目使用的Kotlin版本来引入,我使用的Kotlin版本为1.4.32所以引入的Kotlin核心依赖包版本为:1.4.3

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.3'

具体可以去到Maven Repository去查找使用对应的版本。

Android Kotlin中协程详解_开发语言


一、GloabalScope

1、使用GlobalScope构建协程。

GlobalScope.launch {
            Log.d("协程 当前线程:", Thread.currentThread().name)
        }

输出日志

Android Kotlin中协程详解_Kotlin协程_02

2、launch中的代码段是执行在子线程中的,如果需要在开启协程的时候指定线程,
可以设置Dispatchers参数值。下面以开启协程并使其在I/O线程中执行为例。

GlobalScope.launch(Dispatchers.IO) {
            Log.d("Dispatchers.IO 当前线程:", Thread.currentThread().name)
        }

输出日志

Android Kotlin中协程详解_开发语言_03

3、取消协程 launch()返回一个Job对象,如果协程执行了一个耗时任务,如果耗时任务还未执行完,这是Activity被销毁,这是需要执行job.cancel(),来取消协程。终止后续代码的执行。

val job = GlobalScope.launch(Dispatchers.IO) {
            Log.d("Dispatchers.IO 当前线程:", Thread.currentThread().name)
        }
        //取消协程应该放在恰当的位置
        job.cancel()

二、CoroutineScope
1、通过CoroutineScope创建协程在实际项目中,用的较为广泛。

val job = Job()
        CoroutineScope(job).launch {
            //逻辑处理
        }
        job.cancel()

2、async,使用async来获取协程的执行结果。
详解async函数
aysnc函数同样可以构建一个协程作用域,并返回Deferred对象。但是与Coroutine-Scope函数不同的
是,async函数必须在协程作用域中才能调用

val job = Job()
        CoroutineScope(job).launch {
            //逻辑处理
            val result = async {
                //模拟耗时操作
                delay(3000)
                "操作成功"
            }.await()
            Log.d(TAG, result)
        }

输出日志,通过delay()函数,让协程延迟3秒执行。
实际使用过程中,可能会出现各种意外的情况,导致发生异常。这里举一个例子。
这里报的异常想必大家都知道 java.lang.ArithmeticException: divide by zero,不能除以0
但是我下面的做法并不能正确的捕获异常依然会报错,导致程序异常退出。

//错误写法
		val job = Job()
        CoroutineScope(job).launch {
            try {
                //逻辑处理
                val result = async {
                    //模拟耗时操作
                    delay(3000)
                    "操作成功" + 6 / 0
                }.await()
                Log.d(TAG, result)
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }

这是因为在协程作用域外层是无法捕获到协程异常的,这是因为已
经超出了协程作用域的范围,try catch必须包裹ascync函数开启的协程作用域。

val job = Job()
        CoroutineScope(job).launch {

            //逻辑处理
            val result = async {
                try {
                    //模拟耗时操作
                    delay(3000)
                    "操作成功" + 6 / 0
                } catch (e: Exception) {
                    "结果异常"
                }
            }.await()
            Log.d(TAG, result)
        }

3.await()方法,await()方法会阻塞当前协程(launch启动的外层协程),而不是 async 启动的内部协程,

/**
           启动 launch 协程。
           在 launch 协程中,首先启动第一个 async 协程,开始耗时操作。
           调用 await() 时,launch 协程会被暂停,直到第一个 async 协程完成。
           之后,继续执行外层 launch 协程,并启动第二个 async 协程。
           调用第二个 async 的 await(),再次暂停外层的 launch 协程,直到第二个 async 协程完成。
           一旦两个 async 协程都完成,launch 协程继续执行剩余逻辑。
         */
        val job = Job()
        CoroutineScope(job).launch {
            val startTime = System.currentTimeMillis()
            //逻辑处理
            val result = async {
                //模拟耗时操作
                delay(3000)
                "操作成功"
            }.await()
            //逻辑处理
            val result2 = async {
                //模拟耗时操作
                delay(3000)
                "获取成功"
            }.await()
            Log.d(TAG, "执行结果:$result - $result2")
            val endTime = System.currentTimeMillis()
            Log.d(TAG, "执行时间: ${endTime - startTime}")
        }

输出结果

Android Kotlin中协程详解_kotlin_04


针对上述情况,我们可以在用到执行结果的时候调用wait()方法,这样就可以让result和result2同时执行了。

val job = Job()
        CoroutineScope(job).launch {
            val startTime = System.currentTimeMillis()
            //逻辑处理
            val result = async {
                //模拟耗时操作
                delay(3000)
                "操作成功"
            }
            //逻辑处理
            val result2 = async {
                //模拟耗时操作
                delay(3000)
                "获取成功"
            }
            Log.d(TAG, "执行结果:${result.await()} - ${result2.await()}")
            val endTime = System.currentTimeMillis()
            Log.d(TAG, "执行时间: ${endTime - startTime}")
        }

输出结果:

Android Kotlin中协程详解_android_05


执行时间节省了3秒左右,因为程序同时调用了result和result2的await方法,这样result和result2相当于并行的关系,在实际项目中常有需要合并不同接口执行结果的需求,这时就 可以采用这种方式来提高运行效率。

三、withContext
1、通过withContext来构建协程作用域,withCotext是一个挂起函数。
首先来讲一下挂起函数。
在CoroutineScope(job).launch开启的协程中,通过会进行IO操作,或者网络请求的操作,为方便阅读通过会抽取到一个方法中,这里我声明了loadData()

val job = Job()
        CoroutineScope(job).launch {
            loadData()
        }
        
        fun loadData() {
        delay(2000)
        Log.d(TAG, "--loadData--")
   		}

delay(2000)这个函数会报一个错误,Suspend function ‘delay’ should be called only from a coroutine or another suspend function。意思就是挂起函数delay()应该在协程作用域,或者另一个挂起函数中被调用。因此这里的loadData()函数,必须加上suspend。
那么这里可能就有人要问了,这个挂起函数有什么用呢,在实际项目中,我们可以封装一些网络请求,IO操作等耗时的功能封装在挂起函数,这样别人看到之后也能明白,这些挂起函数是要在协程中进行使用的。
所以suspend在Kotlin协程中起到的仅仅是提醒作用。

2、withCotext函数用法

val job = Job()
        CoroutineScope(job).launch {
            val result = withContext(Dispatchers.IO) {
            	delay(2000)
                "获取成功"
            }
            Log.d(TAG, "$result")
        }

输出日志

Android Kotlin中协程详解_协程_06

withContext函数同样是一个挂起函数,需要在协程中或者另一个挂起函数中调用,withCotext函数会将最后一行执行结果作为返回值。

与async函数不同的是,withContext函数会强制要求传入一个线程参数,参数值类型有
Dispatchers.Default、Dispatchers.IO、Dispatchers.Main这三种,Dispatchers.Default常用于计算密集
型任务,Dispatchers.IO常用于网络请求、文件读写等操作,Dispatchers.Main则表示程序在主线程
中执行,所以当开启协程的时候,协程作用域中的代码不一定是执行在子线程的,这取决于这个线
程参数的值。
现在我们如何使用协程更优雅的操作UI呢
这里使用CoroutineScope开启Main协程,通过withContext开启I/O协程,当withContext协程作用域代码执行结束时,会继续回到Main协程执行UI的代码逻辑。示例代码如下:

val job = Job()
        CoroutineScope(job).launch(Dispatchers.Main) {
            val result = getResult()
            showUI(result)
            val result2 = getResult2()
            showUI(result2)
        }

    private suspend fun getResult(): String {
        return withContext(Dispatchers.IO) {
            delay(2000)
            "操作成功"
        }
    }

    private suspend fun getResult2(): String {
        return withContext(Dispatchers.IO) {
            delay(4000)
            "获取成功"
        }
    }

    private fun showUI(result: String) {
        Log.d(TAG, "showUI: ")
        tv_result.text = result
    }

输出日志:

Android Kotlin中协程详解_开发语言_07


从上述代码中可以看出,即使程序需要多次切换协程,也不需要像使用线程一样层层嵌套,这样就

实现了使用协程更优雅地实现异步任务。


上一篇:【Web前端】JavaScript 对象原型与继承机制


下一篇:点云标注工具开发记录(三)之框选点云与渲染颜色