manymore13'notes

协程使用指南

协程介绍

协程是一种并发设计模式，是一套基于线程来实现的API，可以看作是轻量级线程。协程的一个好处是，当涉及到开发人员时，编写非阻塞代码与编写阻塞代码基本相同。编程模型本身并没有真正改变。

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1'
// 可选 Android中使用协程
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1'

协程的用法

创建一个协程，并执行

import kotlinx.coroutines.*

fun main() {
    // 在后台启动一个新的协程并执行
    GlobalScope.launch { 
        // 非阻塞的等待 1 秒钟（默认时间单位是毫秒）
        delay(1000L) 
        // 在延迟后打印输出
        println("World!") 

    }
    // 协程已在等待时主线程还在继续
    println("Hello,") 
    // 阻塞主线程 2 秒钟来保证 JVM 存活
    Thread.sleep(2000L) 
}

代码运行的结果：

Hello,
World!

我们使用GlobalScope.launch创建一个协程，并执行它，后面大括号里包着的是协程要执行的内容，类似于线程中的run方法体。

delay方法只能在协程内部使用，它用于挂起协程，但是不会阻塞当前协程所在的线程。
Thread.sleep会阻塞当前线程，也就是说当前线程被阻塞在那暂时不能做别的事情了

关于协程的方法只能在协程体里面执行，所以为了方便测试协程代码，我准备使用runBlocking把main方法包起来。

/*
 *显式指定了其返回类型 Unit，
 * 因为在 Kotlin 中 main 函数必须返回 Unit 类型。
 */
fun main()= runBlocking<Unit> {
    // 打印当前线程名称
    println(Thread.currentThread().name)
}

执行结果：

main

runBlocking方法运行一个新的协程并且阻塞当前线程，上面的代码中包裹的是main方法，所以阻塞的是main线程

协程挂起

我们用suspend修饰符来标记函数挂起函数只被允许在协程或另一个挂起函数中调用

我们先看一个先获取token，再登录的例子，里面用到挂起函数

import kotlinx.coroutines.*
import kotlin.system.measureTimeMillis

/*
 * main函数
 */
fun main()= runBlocking<Unit> {
    var time = measureTimeMillis{
        val token = getToken()
        val loginInfo = login(token)
        println(loginInfo)
    }
    println("Completed in $time ms")
}

/**
 * 模拟接口获取token
 */
suspend fun getToken():String{
    delay(1000L)
    return "woshitoken"
}

/**
 * 模拟接口登录
 */
suspend fun login(token:String):String {
    delay(1000L)
    return "my token is: $token , login success"
}

执行结果：

my token is: woshitoken , login success
Completed in 2012 ms

我对挂起的理解：

在上面的代码中有两个挂起函数getToken和login，当程序逻辑走到挂起函数getToken()那里，当前协程被挂起,getToken()被抛出去执行，你可以指定在哪一个线程池中执行，当getToken在外部执行完后再恢复刚才挂起的协程，协程代码继续执行。

async 并发

在概念上，async 就类似于 launch。它启动了一个单独的协程，这是一个轻量级的线程并与其它所有的协程一起并发的工作。不同之处在于 launch 返回一个 Job 并且不附带任何结果值，而 async 返回一个 Deferred —— 一个轻量级的非阻塞 future，这代表了一个将会在稍后提供结果的 promise。你可以使用 .await() 在一个延期的值上得到它的最终结果，但是 Deferred 也是一个 Job，所以如果需要的话，你可以取消它。转自 kotlincn.net

import kotlinx.coroutines.*
import kotlin.system.*

fun main() = runBlocking<Unit> {
    val time = measureTimeMillis {
        val one = async { doSomethingUsefulOne() }
        val two = async { doSomethingUsefulTwo() }
        println("The answer is ${one.await() + two.await()}")
    }
    println("Completed in $time ms")    
}

suspend fun doSomethingUsefulOne(): Int {
    // 假设我们在这里做了些有用的事
    delay(1000L) 
    return 13
}

suspend fun doSomethingUsefulTwo(): Int {
    // 假设我们在这里也做了些有用的事
    delay(1000L) 
    return 29
}

运行结果：

The answer is 42
Completed in 1055 ms

两个协程是并发执行。惰性启动的-async

Flow

参考链接

官方协程指南 kaixue 如何正确的在 Android 上使用协程？协程博客

links

social