【Kotlin 协程】协程启动 ① ( 协程构建器 | launch 构建器 | async 构建器 | runBlocking 函数 | Deferred 类 )

文章目录

• ​​一、协程构建器​​

• ​​1、协程构建器概念​​
• ​​2、runBlocking 函数​​
• ​​3、launch 构建器示例​​
• ​​4、Deferred 类​​
• ​​5、async 构建器示例​​

• ​​二、协程构建器示例​​

一、协程构建器

1、协程构建器概念

协程 需要 协程构建器 来启动 , 协程构建器 就是 CoroutineScope 协程作用域的两个扩展函数 ;

协程构建器 : 协程有两种构建器 , 调用 CoroutineScope 协程作用域

• launch 构建器 : 返回 Job 实例对象 , 该协程任务没有返回值

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

• async 构建器 : 返回 Deferred 实例对象 , 该协程任务可以返回一个返回值 , 可以使用 ​​.await()​​ 函数可以获取协程的返回值

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T> {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyDeferredCoroutine(newContext, block) else
        DeferredCoroutine<T>(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

2、runBlocking 函数

调用 GlobalScope#launch 方法 , 可以启动一个协程 , 这是顶级的协程 , 其 协程作用域是进程级别的 , 生命周期与应用进程同级

调用 runBlocking 函数 , 可以将 主线程 包装成 协程 ;

runBlocking {
  // 调用 runBlocking 函数 , 可以将 主线程 包装成 协程
}

在 runBlocking 代码块中 , 可以 直接调用 CoroutineScope 的扩展方法 , 如 launch , async 函数 ;

3、launch 构建器示例

launch 构建器 直接在 协程作用域 中实现协程任务 , 没有返回值 ;

runBlocking {
    // 调用 runBlocking 函数 , 可以将 主线程 包装成 协程
    val launchJob = launch {
        // 调用该挂起函数延迟 100 ms
        delay(100)
        Log.i(TAG, "launchJob 执行完毕")
    }
}

4、Deferred 类

Deferred 继承了 Job 接口 , 是 Job 接口的子接口 ;

public interface Deferred<out T> : Job {
    public suspend fun await(): T
    
    public val onAwait: SelectClause1<T>
    
    @ExperimentalCoroutinesApi
    public fun getCompleted(): T
    
    @ExperimentalCoroutinesApi
    public fun getCompletionExceptionOrNull(): Throwable?
}

5、async 构建器示例

调用 Deferred#await() 函数 , 可以获取 协程任务 的返回值 , 类型是一个泛型 T , 即可以返回任意类型 ,

• 如果在 async{} 协程体中返回 String , 则调用 Deferred#await() 函数得到的是一个 String 类型对象 ;
• 如果在 async{} 协程体中返回 Int , 则调用 Deferred#await() 函数得到的是一个 Int 值 ;

返回值直接写在 async 代码块的最后一行 , 然后调用 Deferred#await() 函数获取该返回值 ;

协程作用域 中返回了 String 字符串类型的返回值 , 则调用 Deferred#await() 函数获取的是 String 类型返回值 ;

runBlocking {
    // 调用 runBlocking 函数 , 可以将 主线程 包装成 协程
    val asyncJob = async {
        // 调用该挂起函数延迟 100 ms
        delay(100)
        Log.i(TAG, "asyncJob 执行完毕")
        "asyncJob 返回值 123"
    }
    // 获取 asyncJob 协程返回值
    val result = asyncJob.await()
    Log.i(TAG, "asyncJob 协程返回值 : ${result}")
}

二、协程构建器示例

​

完整代码示例 :

• 构建脚本导入依赖 :

dependencies {
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0-RC-native-mt'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.0-RC-native-mt'
}

• 协程核心代码 :

package kim.hsl.coroutine

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

class MainActivity : AppCompatActivity(){
    val TAG = "MainActivity"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            // 调用 runBlocking 函数 , 可以将 主线程 包装成 协程

            val launchJob = launch {
                // 调用该挂起函数延迟 100 ms
                delay(100)
                Log.i(TAG, "launchJob 执行完毕")
            }

            val asyncJob = async {
                // 调用该挂起函数延迟 100 ms
                delay(100)
                Log.i(TAG, "asyncJob 执行完毕")
                "asyncJob 返回值 123"
            }

            // 获取 asyncJob 协程返回值
            val result = asyncJob.await()
            Log.i(TAG, "asyncJob 协程返回值 : ${result}")
        }
    }
}

执行输出日志信息 :

21:20:00.099  I  launchJob 执行完毕
21:20:00.100  I  asyncJob 执行完毕
21:20:00.100  I  asyncJob 协程返回值 : asyncJob 返回值 123

​