Kotlin-＞Kotlin协程构建器

Yang-Never

已于 2024-05-06 15:48:03 修改

阅读量430

点赞数 10

分类专栏： Kotlin Kotlin协程文章标签： kotlin android 开发语言 android studio

于 2024-05-06 14:43:45 首次发布

本文链接：https://blog.csdn.net/sunshine_guo/article/details/138486938

版权

Kotlin 同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

Kotlin协程

5 篇文章 0 订阅

订阅专栏

`Kotlin`的两种协程构建器

launch：返回Job对象，启动协程没有返回值
async：返回Deferred对象，启动协程有返回值，使用Deferred.await()获取返回值

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    return coroutine
}
public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T> {
    return coroutine
}

协程构建器参数
- CoroutineContext：上下文，launch和async在协程作用域CoroutineScope中启动，协程作用域{}持有的this就是CoroutineScope，launch和async是CoroutineScope的扩展函数
- CoroutineStart：启动模式，决定了协程体中业务逻辑代码何时被执行
- suspend CoroutineScope.() -> T：在{}中写入的业务逻辑代码

`Kotlin`结构化并发

单个线程，不依赖线程池的多线程方式，能够同一时间启动多个协程构建器执行，实现单线程的结构化并发
① 串行执行多个协程构建器

class MainActivity : AppCompatActivity() {
    private var mainScope = MainScope()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        Log.e(TAG, "onCreate start ${Thread.currentThread().name}")
        mainScope.launch {
            val time = measureTimeMillis {
                val job1 = launch {
                    Log.e(TAG, "job1 start ${Thread.currentThread().name}")
                    delay(1000)
                    Log.e(TAG, "job1 end ${Thread.currentThread().name}")
                }.join()
                val job2 = launch {
                    Log.e(TAG, "job2 start ${Thread.currentThread().name}")
                    delay(1000)
                    Log.e(TAG, "job2 end ${Thread.currentThread().name}")
                }.join()
                val job3 = launch {
                    Log.e(TAG, "job3 start ${Thread.currentThread().name}")
                    delay(1000)
                    Log.e(TAG, "job3 end ${Thread.currentThread().name}")
                }.join()
            }
            Log.e(TAG, "time:$time")
        }
        Log.e(TAG, "onCreate end ${Thread.currentThread().name}")

    }

    override fun onDestroy() {
        super.onDestroy()
        mainScope?.cancel()
    }
}

// log result
2024-05-06 14:06:58.067 19543-19543 Yang                    E  onCreate start main
2024-05-06 14:06:58.071 19543-19543 Yang                    E  onCreate end main
2024-05-06 14:06:58.219 19543-19543 Yang                    E  job1 start main
2024-05-06 14:06:59.220 19543-19543 Yang                    E  job1 end main
2024-05-06 14:06:59.221 19543-19543 Yang                    E  job2 start main
2024-05-06 14:07:00.222 19543-19543 Yang                    E  job2 end main
2024-05-06 14:07:00.223 19543-19543 Yang                    E  job3 start main
2024-05-06 14:07:01.224 19543-19543 Yang                    E  job3 end main
2024-05-06 14:07:01.225 19543-19543 Yang                    E  time:3080

② 并行执行多个协程构建器

class MainActivity : AppCompatActivity() {
    private var mainScope = MainScope()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        Log.e(TAG, "onCreate start ${Thread.currentThread().name}")
        mainScope.launch {
            val time = measureTimeMillis {
                val job1 = launch {
                    Log.e(TAG, "job1 start ${Thread.currentThread().name}")
                    delay(1000)
                    Log.e(TAG, "job1 end ${Thread.currentThread().name}")
                }
                val job2 = launch {
                    Log.e(TAG, "job2 start ${Thread.currentThread().name}")
                    delay(1000)
                    Log.e(TAG, "job2 end ${Thread.currentThread().name}")
                }
                val job3 = launch {
                    Log.e(TAG, "job3 start ${Thread.currentThread().name}")
                    delay(1000)
                    Log.e(TAG, "job3 end ${Thread.currentThread().name}")
                }
                job1.join()
                job2.join()
                job3.join()
            }
            Log.e(TAG, "time:$time")
        }
        Log.e(TAG, "onCreate end ${Thread.currentThread().name}")
    }

    override fun onDestroy() {
        super.onDestroy()
        mainScope?.cancel()
    }
}

// log result
2024-05-06 14:30:03.132 31986-31986 Yang                    E  onCreate start main
2024-05-06 14:30:03.136 31986-31986 Yang                    E  onCreate end main
2024-05-06 14:30:03.271 31986-31986 Yang                    E  job1 start main
2024-05-06 14:30:03.272 31986-31986 Yang                    E  job2 start main
2024-05-06 14:30:03.273 31986-31986 Yang                    E  job3 start main
2024-05-06 14:30:04.274 31986-31986 Yang                    E  job1 end main
2024-05-06 14:30:04.274 31986-31986 Yang                    E  job2 end main
2024-05-06 14:30:04.274 31986-31986 Yang                    E  job3 end main
2024-05-06 14:30:04.275 31986-31986 Yang                    E  time:1071

val job1 = launch {}.join()这一句启动协程后，launch{}花括号中的内容会包装为挂起函数，此时不会阻塞线程，让出线程使用权，但这个协程构建器之前无任何代码执行，线程会阻塞等到llaunch{}花括号中内容执行完成，每个协程构建器耗时1s，三个job执行耗时3s，为串行执行
job1.join()这一句启动协程后，launch{}花括号中的内容会包装为挂起函数，此时不会阻塞线程，让出线程使用权，协程构建器之前还有代码未执行，掉头回去执行绑定在job2和job3上的协程构建器，job2和job3遇到delay挂起函数，又会让出线程使用权，执行其他协程构建器的代码。过了1s，三个job的delay时间都到了，三个job执行耗时1s，为并行执行