kotlin协程并发/并行与串行互相切换，CoroutineScope与await

「爱情、让人受尽委屈。」 2023-10-10 19:32 52阅读 0赞

import kotlinx.coroutines.CoroutineScope
    import kotlinx.coroutines.Dispatchers
    import kotlinx.coroutines.delay
    import kotlinx.coroutines.launch
    import java.time.LocalTime
    
    fun main(args: Array<String>) {
        println("${LocalTime.now()} - main start")
    
        CoroutineScope(Dispatchers.Default).launch {
            // 并发执行
            this.launch {
                println("${LocalTime.now()} A start")
                delay(1000)
                println("${LocalTime.now()} A end")
            }
    
            this.launch {
                println("${LocalTime.now()} B start")
                delay(1500)
                println("${LocalTime.now()} B end")
            }
        }
    
        println("${LocalTime.now()} - main end")
    }

![87f9d76084ad4426bafefd397bbdf68a.png][]

输出表明main退出后，A,B均没有输出。CoroutineScope(Dispatchers.IO).launch新起的任务不阻塞主main任务执行流程。

如果换成runBlocking(Dispatchers.IO)：

import kotlinx.coroutines.*
    import java.time.LocalTime
    
    fun main(args: Array<String>) {
        println("${LocalTime.now()} - main start")
    
        runBlocking(Dispatchers.IO) {
            // 并发执行
            this.launch {
                println("${LocalTime.now()} A start")
                delay(1000)
                println("${LocalTime.now()} A end")
            }
    
            this.launch {
                println("${LocalTime.now()} B start")
                delay(1500)
                println("${LocalTime.now()} B end")
            }
        }
    
        println("${LocalTime.now()} - main end")
    }

![1f6b5f0d021045d7893676b304f93a40.png][]

看一下async

import kotlinx.coroutines.*
    import java.time.LocalTime
    
    fun main(args: Array<String>) {
        println("${LocalTime.now()} - main start")
    
        CoroutineScope(Dispatchers.IO).launch() {
            // 并发执行
            this.async {
                println("${LocalTime.now()} A start")
                delay(1000)
                println("${LocalTime.now()} A end")
            }
    
            this.async {
                println("${LocalTime.now()} B start")
                delay(1500)
                println("${LocalTime.now()} B end")
            }
        }
    
        println("${LocalTime.now()} - main end")
    }

![b2bbb1a5826f4435b74dd643b3b9eabc.png][]

如果main线程休息1000ms:

![bc1857a373b2488da03f53447e70202b.png][]

import kotlinx.coroutines.*
    import java.time.LocalTime
    
    fun main(args: Array<String>) {
        println("${LocalTime.now()} - main start")
    
        runBlocking {
            CoroutineScope(Dispatchers.IO).launch() {
                val task1 = this.async {
                    println("${LocalTime.now()} A start")
                    delay(1000)
                    println("${LocalTime.now()} A end")
    
                    "task1 return"
                }
    
                val task2 = this.async {
                    println("${LocalTime.now()} B start")
                    delay(1500)
                    println("${LocalTime.now()} B end")
    
                    "task2 return"
                }
    
                val t1 = task1.await()
                println("${LocalTime.now()} $t1")
    
                val t2 = task2.await()
                println("${LocalTime.now()} $t2")
            }
        }
    
        println("${LocalTime.now()} - main end")
    }

![39e1e4a2e3e3478da0ef690db39afe19.png][]

总体上CoroutineScope(Dispatchers.IO).launch()的意义在于新起一个线程，不阻塞主main线程，由于

理解await

import kotlinx.coroutines.*
    import java.time.LocalTime
    
    fun main(args: Array<String>) {
        println("${LocalTime.now()} - main start")
    
        runBlocking {
            //launch() {
                val task1 = this.async {
                    println("${LocalTime.now()} A start")
                    delay(3000)
                    println("${LocalTime.now()} A end")
    
                    "task1 return"
                }
    
                val task2 = this.async {
                    println("${LocalTime.now()} B start")
                    delay(1000)
                    println("${LocalTime.now()} B end")
    
                    "task2 return"
                }
    
                val t1 = task1.await()
                println("${LocalTime.now()} $t1")
    
                val t2 = task2.await()
                println("${LocalTime.now()} $t2")
            //}
        }
    
        println("${LocalTime.now()} - main end")
    }

![1ec6b998a72b411fab336c7ce142b909.png][]

虽然task2很快就完成，因为await，所以必须等待task1返回。

[kotlin协程async与await\_zhangphil的博客-CSDN博客runBlocking 内部启动的3个协程做耗时操作，从输出可以看到3个协程交叉并发执行，runBlocking 会等到3个协程执行结束后才退出，输出结果有明确先后顺序。一般编程的技法，比如，在Android中，假设在主线程中实现了一个函数，但该函数是耗时操作，毫无疑问，需要将这个函数的实现切入非主线程中操作，那么可以设计一种托管的函数，在托管的函数里面干脏活，处理完成后，把结果抛到主线程。结果1-a: 5 - tid:22。结果1-b: 5 - tid:24。结果2-a: 9 - tid:22。![favicon32.ico][]https://blog.csdn.net/zhangphil/article/details/129268399][kotlin_async_await_zhangphil_-CSDN_runBlocking _3_3_runBlocking _3_Android_1-a_ 5 - tid_22_1-b_ 5 - tid_24_2-a_ 9 - tid_22_favicon32.ico_https_blog.csdn.net_zhangphil_article_details_129268399]

[https://zhangphil.blog.csdn.net/article/details/129265638![icon-default.png_t_N4HB][]https://zhangphil.blog.csdn.net/article/details/129265638][https_zhangphil.blog.csdn.net_article_details_129265638_icon-default.png_t_N4HB_https_zhangphil.blog.csdn.net_article_details_129265638]

[kotlin协程、线程切换，函数方法委托\_zhangphil的博客-CSDN博客runBlocking 内部启动的3个协程做耗时操作，从输出可以看到3个协程交叉并发执行，runBlocking 会等到3个协程执行结束后才退出，输出结果有明确先后顺序。一般编程的技法，比如，在Android中，假设在主线程中实现了一个函数，但该函数是耗时操作，毫无疑问，需要将这个函数的实现切入非主线程中操作，那么可以设计一种托管的函数，在托管的函数里面干脏活，处理完成后，把结果抛到主线程。结果1-a: 5 - tid:22。结果1-b: 5 - tid:24。结果2-a: 9 - tid:22。![favicon32.ico][]https://blog.csdn.net/zhangphil/article/details/130161705][kotlin_zhangphil_-CSDN_runBlocking _3_3_runBlocking _3_Android_1-a_ 5 - tid_22_1-b_ 5 - tid_24_2-a_ 9 - tid_22_favicon32.ico_https_blog.csdn.net_zhangphil_article_details_130161705]

[https://zhangphil.blog.csdn.net/article/details/129250518![icon-default.png_t_N4HB][]https://zhangphil.blog.csdn.net/article/details/129250518][https_zhangphil.blog.csdn.net_article_details_129250518_icon-default.png_t_N4HB_https_zhangphil.blog.csdn.net_article_details_129250518]

[87f9d76084ad4426bafefd397bbdf68a.png]: https://img-blog.csdnimg.cn/87f9d76084ad4426bafefd397bbdf68a.png
[1f6b5f0d021045d7893676b304f93a40.png]: https://img-blog.csdnimg.cn/1f6b5f0d021045d7893676b304f93a40.png
[b2bbb1a5826f4435b74dd643b3b9eabc.png]: https://img-blog.csdnimg.cn/b2bbb1a5826f4435b74dd643b3b9eabc.png
[bc1857a373b2488da03f53447e70202b.png]: https://img-blog.csdnimg.cn/bc1857a373b2488da03f53447e70202b.png
[39e1e4a2e3e3478da0ef690db39afe19.png]: https://img-blog.csdnimg.cn/39e1e4a2e3e3478da0ef690db39afe19.png
[1ec6b998a72b411fab336c7ce142b909.png]: https://img-blog.csdnimg.cn/1ec6b998a72b411fab336c7ce142b909.png
[favicon32.ico]: https://g.csdnimg.cn/static/logo/favicon32.ico
[kotlin_async_await_zhangphil_-CSDN_runBlocking _3_3_runBlocking _3_Android_1-a_ 5 - tid_22_1-b_ 5 - tid_24_2-a_ 9 - tid_22_favicon32.ico_https_blog.csdn.net_zhangphil_article_details_129268399]: https://blog.csdn.net/zhangphil/article/details/129268399
[icon-default.png_t_N4HB]: https://csdnimg.cn/release/blog_editor_html/release2.2.8/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=N4HB
[https_zhangphil.blog.csdn.net_article_details_129265638_icon-default.png_t_N4HB_https_zhangphil.blog.csdn.net_article_details_129265638]: https://zhangphil.blog.csdn.net/article/details/129265638
[kotlin_zhangphil_-CSDN_runBlocking _3_3_runBlocking _3_Android_1-a_ 5 - tid_22_1-b_ 5 - tid_24_2-a_ 9 - tid_22_favicon32.ico_https_blog.csdn.net_zhangphil_article_details_130161705]: https://blog.csdn.net/zhangphil/article/details/130161705
[https_zhangphil.blog.csdn.net_article_details_129250518_icon-default.png_t_N4HB_https_zhangphil.blog.csdn.net_article_details_129250518]: https://zhangphil.blog.csdn.net/article/details/129250518