Kotlin协程

1、协程的概念

相当于轻量级线程，线程的切换需要操作系统进行调度，而协程在编译语言层面就能实现自由切换，开销比线程要小的多，这种特性使得高并发程序的执行效率得到了极大的提升

2、协程的优点

可控制、开销小、语法糖（减少回调，已同步的写法代替之前异步的写法）
协程与线程是属于一个层级的，但是却又和线程处理并行任务有着不同的解决方案，协程可以在处理完并发任务之后，自动切回UI（mian/主）线程；线程处理完并发任务默认是不会直接切回UI（mian/主）线程，需要我们手动去切回UI（mian/主）线程，因此，协程不仅切换成本小，还可以避免回调地狱

3、协程的用法

首先引入依赖

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1"

GlobalScope.launch

class ExampleUnitTest {
    @Test
    fun addition_isCorrect() {
        GlobalScope.launch {
            delay(1500)
            println("codes run in coroutine scope")
        }
        sleep(1000)
    }
}

GlobalScope.launch创建的协程是顶层协程，返回值时Job，会随着线程的销毁而销毁，因此需要sleep 1s，delay只能用于协程作用域或挂起函数里，delay在协程中调用时只会阻塞当前协程，不会影响其它协程

runBlocking

class ExampleUnitTest {
    @Test
    fun addition_isCorrect() {
        runBlocking {
            launch {
                delay(1000)
                println("codes run in runblocking")
            }
        }
    }
}

runBlocking 可以阻塞当前线程直到其中的所有协程全部执行完成，一般在测试环境使用

挂起函数和coroutineScope

当协程内代码过多时，我们可以把其中一部分代码抽出来写成一个方法，但如果需要在方法中使用delay方法时，需要把这个方法声明成挂起函数，用suspend修饰，不过现在还是不能使用launch，因为挂起函数不是协程作用域，如果想在挂起函数中使用launch方法，可以用coroutineScope函数使挂起函数拥有协程作用域，如下：

//挂起函数中使用delay方法
suspend fun method1(){
        delay(1000)
        println("test  fdfda")
    }
//使用coroutineScope声明一个带协程作用域的方法
suspend fun method2()= coroutineScope{
        launch {
            println("method2")
        }
    }

coroutineScope会阻塞当前协程，直到它内部的所有协程都执行完
在实际项目中，由于runBlocking可能会阻塞当前线程，一般不用，而Global.launch这种顶层协程每个会返回一个Job，管理起来比较麻烦，所以一般也不使用，下面介绍一种项目中常用的协程使用

        val job=Job()
        val scope= CoroutineScope(job)
        scope.launch {
            println("111111")
            delay(100)
            println("111111")
        }
        scope.launch {
            println("22222")
            delay(100)
            println("22222")
        }
        //job.cancel()
        sleep(1000)

使用Job可统一取消所有通过CoroutineScope启动的协程（这种和顶层协程一样，不会阻塞线程，随线程销毁而结束），因为launch函数只能返回job对象，那么如果我们需要获取一个协程的返回结果时，就得使用async函数了

能获取协程结果的async函数

async必须在协程作用域才能调用，它会创建一个新的协程并返回一个Deferred对象，调用Deferred对象的await方法即可获取协程的结果，如下：

//能获取协程结果的async函数
        runBlocking {
            val result=async {
                5+6
            }.await()
            println(result)
        }
//await会阻塞当前协程（不影响其它协程），直到可以获取到async的结果
        runBlocking {
            val result=async {
                sleep(1000)
                println("第一个async函数")
                5+6
            }.await()
            async {
                println("第二个async函数")
            }.await()
            println(result)
        }
//async函数同时执行
        runBlocking {
            val start=System.currentTimeMillis()
            val deferred1=async {
                delay(1000)
                println("第一个async函数")
            }
            val deferred2=async {
                delay(1000)
                println("第二个async函数")
            }
            deferred1.await()
            deferred2.await()
            println(System.currentTimeMillis()-start)

强制要求指定线程参数的协程

       //强制要求指定线程的协程
        runBlocking {
            withContext(Dispatchers.Default){
                delay(1000)
                println("withContext"+Thread.currentThread().id)
            }
        }
        println("主线程id=${Thread.currentThread().id}")

共有三种类型，分别是Dispatchers.Default（适用于低并发）、Dispatchers.IO（适用于高并发）、Dispatchers.Main（不会开启子线程，会在主线程执行）

协程简化回调

    //常见的网络请求回调
    HttpUtil.sendHttpRequest(url,object:HttpCallbackListener{
        override fun onFinish(response:String){
            //得到服务器返回的具体内容
        }
        override fun onError(e:Exception){
            //异常情况处理
        }
    })
    //使用协程简化回调
    suspend fun request(url:String):String{
        return suspendCoroutine { continuation ->
            HttpUtil.sendHttpRequest(url,object:HttpCallbackListener{
                override fun onFinish(response:String){
                    //得到服务器返回的具体内容
                    continuation.resume(response)
                }
                override fun onError(e:Exception){
                    //异常情况处理
                    continuation.resumeWithException(e)
                }
            })
        }
    }
    //后续网络请求可直接这么写
    try{
        val response=request("xxxx")
        //对服务器响应的数据进行处理
    }catch(e:Exception){
        //对异常情况进行处理
    }

4、协程的原理