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关键字来标志耗时操作，通过编译器来帮助我们避免一些性能上的问题