阅读 250

Android kotlin中协程的使用(Couroutines)

一、什么是协程

官方给的解释:一种轻量级的线程。
普遍的解释:协程就是协同程序,而kotlin协程就是基于java thread api封装的工具包,帮助我们轻松的写出复杂的并发代码。

二、为什么要使用协程,协程的优点是什么?

我们先看一下没有协程之前处理异步的方式有哪些,无非就是四个方式:
1、线程
缺点:

  • 资源消耗
  • 数量受限
  • 平台支持(js不支持线程)
  • 调试使用不便

2、回调
缺点:

  • 多层嵌套
  • 错误处理麻烦

3、Futures、Promise(第三方开源框架)
缺点:

  • 改变编程方式,如处理异常与循环作用等,在其中无效
  • api学习,平台差异
  • 返回限定promise
  • 异常处理复杂

4、Rx响应式扩展(比较流行的处理异步的框架)
缺点:

  • 学习曲线比较长
  • 行为难估
  • api多、繁杂

最后就是我们的主角协程了,相比较而言,协程易学易用,但是要想用的溜一点,还是要花时间好好学习的。最主要的是协程与jetpack、kotlin、AAC、MVVM可以完美结合,毕竟是官方主推的一个系列开发方式。
特别是协程中的scope和MVVM结合使用感知生命周期可以有效避免内存泄漏的问题。

三、协程的具体使用

首先导入协程:

    // Coroutines
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2'
复制代码

启动协程的几种方法

Launch

先写一个测试函数

fun testLaunch() {
        val time: Long = measureTimeMillis {
            GlobalScope.launch {
                Thread.sleep(1000)
                Log.d("hhh","testLaunch的launch1中,${Thread.currentThread()} 我很好")
            }
            GlobalScope.launch {
                Thread.sleep(1000)
                Log.d("hhh","testLaunch的launch2中,${Thread.currentThread()} 嘿嘿嘿")
            }
            Log.d("hhh","你好么? ${Thread.currentThread()} ")
            Thread.sleep(22000)//这里需要等待,否则代码函数生命周期结束就销毁了函数栈,导致两个协程没有执行
        }
        Log.d("hhh","函数总耗时: $time")
    }
复制代码

执行结果

image.png

值得注意的是,两个协程是异步的,执行的先后顺序不能确定,也有可能先执行第二个,比如:

image.png

runBlocking

关于上面的测试方法,我们可以知道,由于GlobalScope.launch是不阻塞线程,为了等待协程完毕再销毁函数栈,还得让线程等待,也就是:

Thread.sleep(22000)//这里需要等待,否则代码函数生命周期结束就销毁了函数栈,导致两个协程没有执行
复制代码

怎样让他们变成阻塞式的呢,所以就说到线程的另一个方法runBlocking,这个是阻塞线程的,我们写一个方法来测试一下

    fun testRunBlocking() {
        val time = measureTimeMillis {
            runBlocking {
                GlobalScope.launch {
                    Thread.sleep(1000)
                    Log.d("hhh", "launch1 ${Thread.currentThread()} ")
                }

                GlobalScope.launch {
                    Thread.sleep(1000)
                    Log.d("hhh", "launch2 ${Thread.currentThread()}")
                }
            }
            Log.d("hhh", "testRunBlocking ${Thread.currentThread()} hello!!")
        }
        Log.d("hhh", "线程总耗时: $time")
    }
复制代码

执行结果:

image.png

从结果我们可以可看到它是可以阻塞当前线程的。简单地说就是runBlocking会等待内部所有协程结束以后才会结束函数栈,但是它内部协程的执行顺序依然不会阻塞。

协程中的join和cancle方法

  • jion():将两个异步协程定位顺序执行,比如先执行玩T1线程再执行T2线程
  • cancle():取消某个线程的执行

说再多不如看代码,一个个来,先看jion()

  fun testJoin()= runBlocking {
        val time= measureTimeMillis {
            val a1=async {//async也是开启协程的一种方式,和launch一样,只是返回结果不同
                repeat(10){//循环20次
                    Log.d("hhh","a1")
                    delay(200)
                }
            }
            a1.join()
            val a2=async {
                Log.d("hhh","a2")
            }
        }
        Log.d("hhh","线程总耗时: $time")
    }
复制代码

执行效果:

image.png

从结果中可以看出,由于加入了join函数,它会执行完a1协程之后才往下执行。这个其实就和线程的join()方法一样。

再来看看cancle()方法,cancle()方法其实就是取消一个协程的执行,一样的,来看看例子:

fun testJoin()= runBlocking {
        val time= measureTimeMillis {
            val a1=async {
                repeat(10){//循环20次
                    Log.d("hhh","a1")
                    delay(200)
                }
            }

            val a2=async {
                Log.d("hhh","a2")
                a1.cancel()//取消a1线程
            }
        }
        Log.d("hhh","线程总耗时: $time")
    }
复制代码

执行结果:

image.png

从结果中可以看出,我们在a2协程中调用了a1.cancle(),也就达到了取消a1协程的效果,本来该打印10次的协程a1打印一次之后就被终止了。

协程中的await方法

我们现在都知道了runBlocking只是启动一个协程块,保证里面所有协程执行完毕后才会结束函数栈,协程块内部依然是异步的,在开发中往往需要在所有协程得到结果之后再进行下一步操作,这就需要用到await()了,他能保证在所有协程结束并获得返回结果之后再执行下一步。
注意:使用await时,协程启动方式只能用async(),因为launch()和async()虽然都是启动协程,但是返回结果不一样,launch()返回的是Job类型,async()返回的是Deferred类型,所以async()能够接受各种返回值类型,而launch()不可以。

看例子,看例子

fun testAwait()= runBlocking {
        val time= measureTimeMillis {
            val a1=async {
                Log.d("hhh","hello a1")
                delay(2000)
                300//返回结果
            }
            val a2=async {
                Log.d("hhh","hello a2")
                delay(3000)
                400
            }
            Log.d("hhh","a1结果: ${a1.await()}---a2结果:${a2.await()}")
        }
        Log.d("hhh","函数总耗时:$time")
    }
复制代码

执行结果:

image.png

以上图结果来看,我们在两个线程中都模仿了耗时操作,当它并没有先执行下面的语句,而是在两个协程都获得返回结果之后才继续往下执。

值得注意的是,很多人就会想,这样用join()也可以实现啊,分别调用两个协程的join()不就可以实现了吗?但是如果那样做的话总耗时就变成了两个协程耗时的时间总和,也就是5000,但我们可以看到总耗时是3000多一点,因为用await两个协程是异步的,所以总耗时只是约等于耗时较长那个协程的执行时间。(类似于物理中电阻的串联和并联)

最后说一下,很多人觉得协程和线程基本差不多,那为啥还要多此一举呢,前面已经说过了,主要就是两点,一个是它可以减少资源损耗,第二个是它可以完美配合jackpet组件使用,比如监听生命周期,避免内存溢出等问题,反正也不能用语言描述,就像开发Android用Java还是用kotlin,肯定是kotlin,具体原因也说不出来,谁用谁知道,还在杠kotlin可读性差的人证明你还不熟悉kotlin,就像解数学题一样,巴不得老师把每一个步骤都写出来,其实高手往往可以一步到位。

文章分类
Android
文章标签