【备忘录】Kotlin协程（一）

《kotlin学习备忘录》
（1）

//CoroutineScope,协程本身
fun main() {
    //启动协程
    //在后台创建一个新的协程，不会堵塞当前线程
    GlobalScope.launch {
        delay(1000)
        println("kotlin Coroutine")
    }

    println("Hello")

    Thread.sleep(2000)

    println("World")

}

运行结果

Hello
kotlin Coroutine
World

（2）

fun main() {
    GlobalScope.launch {
        delay(1000)
        println("KOTLIN Coroutine")
    }

    println("HELLO")

    //创建一个新的协程，同时阻塞当前线程，直到协程结束
    runBlocking {
        delay(2000)
    }

    println("WORLD")
}

运行结果

HELLO
KOTLIN Coroutine
WORLD

（3）

fun main() = runBlocking {

    val myJob = GlobalScope.launch {
        delay(1000)
        println("MYJOB")
    }

    println("HELLO")

    //Suspends coroutine until this job is complete（暂停协程直到任务完成）
    //等待job所对应的协程执行完毕，然后在往下执行
    myJob.join()

    println("WORLD")
}

运行结果

HELLO
MYJOB
WORLD

(4)

//每一个协程构建器（包括runBlocking）都会向其代码块作用域中添加一个CoroutineScope实例，
//我们可以在该作用域中启动协程，而无需显式将其join到一起，这是因为外部协程会等待该作用域中的
//所有启动的协程全部完成后才会完成。
fun main() = runBlocking {

    launch {
        delay(1000)
        println("KOTLIN")
    }

    println("HELLO")
}

运行结果

HELLO
KOTLIN

(5)

/**
 * 除去不同的协程构建器所提供的协程作用域(Coroutine Scope)外，我们还可以通过Coroutine builder来声明自己的协程作用域。
 * 该构建器会创建一个协程作用域，并且会等待所有的启动的子协程全部完成自身才会完成。
 * runBlocking与CoroutineScope之间的主要区别在于，后者在等待所有子协程完后其任务时并不会阻塞当前的线程。
 *
 * 1.runBlocking并非挂起函数：也就是说，调用它的线程会一直位于该函数之中，知道协程执行完毕为止
 * 2.coroutineScope是挂起函数：也就是说，如果这其中的协程挂起，那么coroutineScope函数也会挂起。
 * 这样，创建coroutineScope的外层
 * 函数就可以继续在同一个线程中执行了，该线程会【逃离】coroutineScope之外，并且可以做其他事情。
 */
fun main() = runBlocking {
    launch {
        delay(10000)
        println("KOTLIN")
    }

    println("HELLO")

    coroutineScope {
        launch {
            delay(20000)
            println("my job2")
        }

        delay(5000)
        println("hello world")
    }

    println("welcome")
}

运行结果

HELLO
hello world
KOTLIN
my job2
welcome

(6)

/**
 * 被 suspend 关键字修饰的函数称为 挂起函数
 * 挂起函数 （suspending function）
 * 挂起函数可以像普通函数一样用在协程中，不过它的一个特性在于可以使用其他的挂起函数
 * *****挂起函数只能用在协程或者另外一个挂起函数中*****
 */

fun main() = runBlocking {
    launch {
        world()
    }
    println("调用了挂起函数")
}

suspend fun hello() {
    println("HELLO")
}

suspend fun world() {
    hello()
}

运行结果

调用了挂起函数
HELLO

(7)

/**
 *全局协程，类似守护线程（daemon thread）
 * 使用GlobalScope启动的活动协程并不会保持进程的生命，他们就像是守护线程一样
 * 守护线程特点：当主线程执行完毕之后，不管后台有多少守护线程，jvm都会结束自己的生命周期，那这些守护线程也都会被销毁
 */

fun main() {
    GlobalScope.launch {
        repeat(100) {
            println("I am sleeping $it")

            delay(400)
        }
    }

    Thread.sleep(2000)
}

运行结果

I am sleeping 0
I am sleeping 1
I am sleeping 2
I am sleeping 3
I am sleeping 4