kotlin学习笔记之协程

前言

整理了协程的基本使用，不深入，适合入门。刚接触协程，不必过于关注定义。协程的生命周期是需要留意的点。

学习资料

• 掘金小册（付费）-Android 进阶：基于 Kotlin 的 Android App 开发实践
• 郭霖公众号-超长文，带你全面了解Kotlin的协程
• 第一行代码（第三版）
• GDG上海实录回顾，带你快速上手Kotlin协程
• 扔物线
• kotlin语言中文站-协程

添加依赖

在项目中使用或者学习协程需要添加相应的依赖（对kotlin插件的版本也是有要求的），需要了解详细的配置可以点击传送门-添加协程依赖

以下是在as的配置信息

// 协程核心库
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.8'
// Android平台下对应的协程库
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.8'

创建

使用GlobalScope会创建一个顶级协程，当程序结束了，它也会结束，即使其代码还没执行完毕，所以在写测试代码时会让主线程sleep几秒。注意：新创建出来的协程并不一定可以用来进行耗时操作，比如在主线程创建的，它依旧运行在主线程。
launch

// launch
fun main() {
    GlobalScope.launch {
        delay(2000)
        println("launch1-name:${Thread.currentThread().name}")
    }

    // 指定协程运行在IO线程
    GlobalScope.launch(Dispatchers.IO) {
        println("launch2-name:${Thread.currentThread().name}")
    }

    // launch函数会返回Job对象
    var job = GlobalScope.launch {
        print("job")
        delay(1000)
        println("launch3-name:${Thread.currentThread().name}")
    }
    Thread.sleep(1000)
    job.cancel() // 取消

    Thread.sleep(3000)
}

async
对于请求3依赖于请求1和请求2的结果的场景，借助await函数可以很容易实现

fun main() {
    GlobalScope.async {
        delay(2000)
        println("async1-name:${Thread.currentThread().name}")
    }

    // 指定在IO线程执行
    GlobalScope.async(Dispatchers.IO) {
        println("async2-name:${Thread.currentThread().name}")
    }

    GlobalScope.launch {
        // 返回一个Deferred对象
        val name = GlobalScope.async {
            delay(1000)
            "张三"
        }

        val age = GlobalScope.async {
            delay(2000)
            20
        }

        // await获取结果，若多个await被调起，执行快的会等待慢的执行完
        println("name:${name.await()},age:${age.await()}")
    }

    Thread.sleep(5000)
}

runBlocking
它可以用来写测试代码，写launch、async时可以不用写delay

fun main() {
    // 会阻塞当前线程
    runBlocking {
        coroutineScope {
            for (i in 1..10) {
                println(i)
            }
        }
        println("coroutineScope is finish")
    }
    println("runBlocking is finish")
}

若项目中拥有多个协程，且使用GlobalScope来创建的，那么管理的难度会很大。一种方式是创建一个全局的Job对象，通过它进行统一管理：

fun main() {
    val job = Job()
    val scope = CoroutineScope(job)
    scope.launch { 
        println("CoroutineScope")
    }
    // 会统一取消
    job.cancel()
}

jetpack
jetpack的一些组件对协程作了支持，如ViewModel，Room等等，且对协程的作用域也作了管理（跟着组件的生命周期），添加依赖和示例直接看Androi KTX官网就ok了

协程切换

kotlin提供的withContext函数可以优雅实现协程之间的的自动切换

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    // 很挫的写法
    GlobalScope.launch(Dispatchers.Main) {
        println("main1")

        launch(Dispatchers.IO) {
            println("io")

            launch(Dispatchers.Main) {
                println("main2")
            }
        }
    }

    // withContext函数里的代码执行完了可以自动切换回原来的线程
    GlobalScope.launch(Dispatchers.Main) {
        println("main")

        val name = withContext(Dispatchers.IO) {
            println("io1")
            "张三"
        }

        val age = withContext(Dispatchers.IO) {
            println("io2")
            "20"
        }

        println("name:${name},age${age}")
    }
}

suspend

suspend是协程里的核心关键字，用于修饰方法，被修饰过的方法需要在另一个suspend执行，提醒该方法需要在那个协程中执行。

suspend fun getName(): String = withContext(Dispatchers.IO) {
    "李四"
}

fun main() {
    GlobalScope.launch {
        println(getName())
    }
    Thread.sleep(1000)
}

Retrofit从2.6.0开始支持协程

异常处理

要捕获异常需要在协程的作用域里进行try-catch，不然会捕获不了

// 可以分别运行起来看下效果
fun main() {
    lateinit var a: String

    GlobalScope.launch {
        // 在launch的作用域内可以捕获异常
        try {
            println("前")
            println("len:${a.length}")
            println("后")
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    // 捕获不了
    try {
        GlobalScope.launch {
            println("len:${a.length}")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }

    println("结束了")

    Thread.sleep(2000)
}

以下这种方式，不一定能捕获到，要看情况：

try {
    val deferred = async {
        // do something
        throw Exception("unhandled exception")
    }
    deferred.await()
} catch (e: Exception) {
    // caught exception
}

以下是一种全局捕获方式，但不能应用到子协程里（嵌套里的协程），要放在顶层协程，阅读起来更加舒适：

fun main() {
    lateinit var a: String

    val h = CoroutineExceptionHandler { coroutineContext, throwable ->
        println("捕获到了")
        throwable.printStackTrace()
    }

    GlobalScope.launch(h) {
        println("前")
        println("len:${a.length}")
        println("后")
    }

    println("结束了")

    Thread.sleep(2000)
}

总结

在实际中还是很少应用，但demo还是需要写一写，实践实践。