Kotlin 协程使用

基本用法

• GlobalScope.launch{} 创建一个顶级协程 //不阻塞当前线程
• runBlocking{} 创建一个协程作用域 //阻塞当前线程
• launch{} 在协程作用域内创建一个协程
• coroutineScope{} 在协程作用域内创建一个子协程作用域 //阻塞当前协程
• async{}.await() 代码块中的代码会立刻执行，当调用await()时，会阻塞当前协程，直到获取结果
• withContext(Dispatchers.Default){} 代码块会立即执行，同时阻塞协程，知道获取结果

//协程作用域的常用创建方式(实际项目中)
    val job = Job()
    val scope = CoroutineScope(job)
    scope.launch {//不阻塞线程
        //
    }
    job.cancel()

• suspendCoroutine{continuation -> } 必须在挂起函数或协程作用域中才可调用，将当前协程挂起，然后在普通线程中执行lambda表达式中的代码，再调用resume() 或 resumeWithException(e)让协程恢复

示例代码

/**
 * Created by guc on 2020/7/9.
 * Description：Kotlin 协程使用
 */
private const val TAG = "coroutine"
fun main() {
    println("$TAG main-thread-start")
    GlobalScope.launch {//不阻塞当前线程，一般不用
        println("$TAG GlobalScope-start")
        delay(2000)
        println("$TAG GlobalScope-end")
    }
    Thread.sleep(1000)
    println("$TAG main-thread-end")

    runBlocking {//阻塞线程
        println("$TAG runBlocking-start")
        printDot()
        println("$TAG runBlocking-end")
    }

    runBlocking {
        val start = System.currentTimeMillis()
        val resut1 = async {
            delay(1000)
            2
        }
        val resut2 = async { // 立即执行
            delay(1000)
            8
        }
        println("result is ${resut1.await() * resut2.await()}") //await() 等待执行结果，若已执行完，立即返回结果
        val end = System.currentTimeMillis()
        println("cost ${end - start}")
        println("result is ${resut1.await() * resut2.await()}")
        val end2 = System.currentTimeMillis()
        println("cost ${end2 - end}")
    }

    val job = Job()
    val scope = CoroutineScope(job)
    scope.launch {//不阻塞线程
        val result = withContext(Dispatchers.Default) {//基本等价于async{}.await()
            println("----------withContext-----------")
            delay(1000)
            5 + 5
        }
        println("result $result")
    }
    scope.launch {//不阻塞线程
        val result = withContext(Dispatchers.Default) {//基本等价于async{}.await()
            println("----------withContext-----------")
            delay(1000)
            5 + 6
        }
        println("result $result")
    }
    Thread.sleep(2000)
    println("----------suspendCoroutine-----------")
    scope.launch {
        try {
            val result = request(10)
            println(result)
        } catch (e: Exception) {
            println(e.message)
        }
    }
    scope.launch {
        try {
            val result = request(10)
            println(result)
        } catch (e: Exception) {
            println(e.message)
        }
    }
    Thread.sleep(2000)

}

suspend fun printDot() = coroutineScope {//只阻塞当前协程
    launch {
        for (i in 1..3) {
            println(".")
            delay(1000)
        }
    }
}

suspend fun request(param: Int): String {
    return suspendCoroutine { c ->
        val num = (1..20).random()
        if (param > num) {
            c.resume("成功 $param > $num")
        } else {
            c.resumeWithException(Exception("失败$param <= $num"))
        }
    }
}