android中kotlin协程和线程的关系

一.子线程和主线程的频繁切换

假设现在有这样的一个业务逻辑,有3个耗时操作,耗时1函数执行完毕后,我们需要调用函数1更新UI,再执行耗时2函数,执行完毕后我们在调用函数2更新UI,最后执行耗时3函数,再调用函数3更新UI。

1.定义3个不同的耗时操作函数和3个更新UI的函数
    fun ioCode1() {
        println("我是IO线程1==${Thread.currentThread().name}")
    }

    fun ioCode2() {
        println("我是IO线程2==${Thread.currentThread().name}")
    }

    fun ioCode3() {
        println("我是IO线程3==${Thread.currentThread().name}")
    }

    fun uiCode1() {
        println("我是UI线程1==${Thread.currentThread().name}")
    }

    fun uiCode2() {
        println("我是UI线程2==${Thread.currentThread().name}")
    }

    fun uiCode3() {
        println("我是UI线程3==${Thread.currentThread().name}")
    }
2.使用线程来实现耗时函数和更新UI函数的相互切换
override fun initData() {
        thread {
            ioCode1()  //执行耗时操作1
            activity?.runOnUiThread {
                uiCode1()  //更新UI1
                thread {
                    ioCode2() //执行耗时操作2
                    activity?.runOnUiThread {
                        uiCode2()  //更新UI2
                        thread {
                            ioCode3()  //执行耗时操作3
                            activity?.runOnUiThread {
                                uiCode3()  //更新UI3
                            }
                        }
                    }
                }
            }
        }
    }

运行结果:

I: 我是IO线程1==Thread-5
I: 我是UI线程1==main
I: 我是IO线程2==Thread-6
I: 我是UI线程2==main
I: 我是IO线程3==Thread-7
I: 我是UI线程3==main

从上面代码可以看出,当频繁的切换线程不仅会陷入回调地狱,看上去很难受,而且还会导致性能问题。如果业务逻辑很复杂的话,就会导致我们下次看自己写的代码可能会很难看懂,这里还是用到来kotlin的线程语法,简化来代码,实际开发的话,肯定不会是这么简单的逻辑。

二.使用kotlin协程来实现子线程和主线程的切换

Android kotlin协程实际上是一个线程框架,底层是通过线程池来实现的,但是比线程更加灵活,由于比线程多了一个上下文,所以后台任务执行完毕后可以自动的切换回上下文协程中。这是线程比较难实现的。

    override fun initData() {
        GlobalScope.launch(Dispatchers.Main) {
            ioCode1() //耗时操作1
            uiCode1() //更新UI操作1
            ioCode2() //耗时操作2
            uiCode2() //更新UI操作2
            ioCode3() //耗时操作3
            uiCode3() //更新UI操作3
        }
    }


    suspend fun  ioCode1(){
        withContext(Dispatchers.IO){
            println("我是IO线程1==${Thread.currentThread().name}")
        }
    }

    suspend fun ioCode2(){
        withContext(Dispatchers.IO) {
            println("我是IO线程2==${Thread.currentThread().name}")
        }
    }

    suspend fun ioCode3(){
        withContext(Dispatchers.IO) {
            println("我是IO线程3==${Thread.currentThread().name}")
        }
    }

这里要注意的是在suspend关键字标记的函数要在suspend关键字标记的函数或者协程中调用,这也使协程在性能上优于直接使用线程的一个重要的一点,通过suspend关键字标记,可以提醒我们这里使一个耗时操作,需要放在后台运行,从而可以提升软件性能。
运行结果:

I: 我是IO线程1==DefaultDispatcher-worker-2
I: 我是UI线程1==main
I: 我是IO线程2==DefaultDispatcher-worker-2
I: 我是UI线程2==main
I: 我是IO线程3==DefaultDispatcher-worker-2
I: 我是UI线程3==main

三.kotlin协程相较于线程的优势

可以看出这里和上面用线程实现的打印结果是完全一样的,和线程比较kotlin协程的优势也很明显。
1.在不使用回调的前提下完成来线程的切换,代码看上亲也是干净整洁很多。
2.因为线程没有上下文,不能控制线程执行完成后应该回到哪里,但是协程完全帮我们实现自动化,执行完毕自动回到上下文线程中,一般情况下是主线程,可以通过设置来决定要回到哪个线程中。
3.协程可以通过suspend关键字来标志耗时操作,通过编译器来帮助我们避免一些性能上的问题