Kevin Learn Kotlin：协程

什么是协程

协程就像非常轻量级的线程。线程是由系统调度的，线程切换或线程阻塞的开销都比较大。而协程依赖于线程，但是协程挂起时不需要阻塞线程，几乎是无代价的，协程是由开发者控制的。所以协程也像用户态的线程，非常轻量级，一个线程中可以创建任意个协程。
协程可以简化异步编程，可以顺序地表达程序，协程也提供了一种避免阻塞线程并用更廉价、更可控的操作替代线程阻塞的方法 – 协程挂起。

特点

• 轻量：您可以在单个线程上运行多个协程，因为协程支持挂起，不会使正在运行协程的线程阻塞。挂起比阻塞节省内存，且支持多个并行操作。
• 内存泄漏更少：使用结构化并发机制在一个作用域内执行多项操作。
• 内置取消支持：取消操作会自动在运行中的整个协程层次结构内传播。
• Jetpack 集成：许多 Jetpack 库都包含提供全面协程支持的扩展。某些库还提供自己的协程作用域，可供您用于结构化并发。

基本使用

1. 在 app/build.gradle 文件中添加如下依赖：

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9'

2. 创建一个 CoroutinesTest.kt 文件

• 最简单的案例代码

fun main() {
    GlobalScope.launch {
        println("codes run in coroutine scope")
    }
    Thread.sleep(1000L)
}

• 选择启动模式

fun main() {
    val job = GlobalScope.launch(start = CoroutineStart.LAZY) {
        delay(1500L)
        println("codes run in coroutine scope")
    }
    job.start()
}

• 协程中所有代码执行完后再结束

fun main() {
    runBlocking {
        println("code run in coroutine scope")
        delay(1500L)
        println("code run in coroutine scope finished")
    }
}

• 创建多个协程

fun main() {
    runBlocking {
        launch {
            println("launcher 01")
            delay(1000L)
            println("launcher 01 finished")
        }

        launch {
            println("launcher 02")
            delay(1500L)
            println("launcher 02 finished")
        }
    }
}

--------------------------------
launcher 01
launcher 02
launcher 01 finished
launcher 02 finished

• 10 万个协程耗时多少

fun main() {
    val start = System.currentTimeMillis()
    runBlocking {
        repeat(100000) {
            println("*")
        }
    }
    val end = System.currentTimeMillis()
    println(end - start)
}

• 控制台以 1s 的间隔依次输出1 - 10

fun main() {
    runBlocking {
        coroutineScope {
            for (i in 1..10) {
                println(i)
                delay(1000L)
            }
        }
        println("coroutineScope finished")
    }
    println("runBlocking finished")
}

---------------------------分隔线----------------------------------
1
2
3
4
5
6
7
8
9
10
coroutineScope finished
runBlocking finished

3. 协程 Job 类的操作

• 调用 launch，就启动了一个协程，launch 方法会返回一个 job
• job.cancel() 取消一个协程

fun main() {
    val job = GlobalScope.launch {
        delay(1000L)
        println("World!")
    }
    job.cancel()
    println("Hello,")

}

• join() 等待协程执行完毕

fun main() = runBlocking {
    val job = GlobalScope.launch {
        delay(1000L)
        println("World!")
        delay(1000L)
    }
    println("Hello,")
    job.join() 
    println("Good！")
}

---------------------------------------------
Hello,
World!
Good！

• job.cancelAndJoin()取消并且加入一个协程

public suspend fun Job.cancelAndJoin() {
    cancel()
    return join()
}