在 Kotlin 中创建和执行协程

1. Kotlin 中的协程
2. 在 Kotlin 中创建一个新项目并添加依赖项
3. 在 Kotlin 中按顺序创建和执行协程
4. 在 Kotlin 中同时创建和执行协程
5. 结论

本教程将介绍协程并展示如何在 Kotlin 中使用 async- await() 顺序或同时执行它们。

Kotlin 中的协程

协程可以被视为一个过程，除了它支持异步编程与其他仅支持同步编程的普通过程相比。

异步编程是一种技术，我们可以在某个点暂停任务的执行，并将执行委托给另一个任务，因为暂停的任务等待一些后台任务执行。这些后台任务可以包括从数据库读取记录、下载网页内容以及处理来自应用程序的用户请求。

在同步编程中，任务的执行在任何时候都不会挂起，线程是独占使用的，直到执行完成。

一个协程代表这个暂停的例程的实例。它也可以被视为一个线程，但是协程不依赖于底层线程，因为它可以在不同的线程上暂停和恢复执行。

在本教程中，我们将学习如何通过确保 async- await() 函数以正确的顺序执行来创建顺序和并发协同程序。

在 Kotlin 中创建一个新项目并添加依赖项

转到 IntelliJ 并选择 文件 > 新建 > 项目。在打开的窗口中，输入 kotlinCoroutines 作为项目名称，在 Language 部分选择 Kotlin，在 Build System 部分选择 Gradle，然后按 Create 按钮。

要在 Kotlin 中使用协程，我们必须将协程依赖项添加到我们的应用程序中。转到文件 build.gradle.kts 并确保你具有以下依赖项。

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.2")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.2")
    testImplementation(kotlin("test"))
}

确保你具有活动的 Internet 连接以下载依赖项。下载依赖项后，加载 Gradle 更改并继续执行后续步骤。

在 Kotlin 中按顺序创建和执行协程

在 kotlin 文件夹下创建包 com/coroutine，这将是我们应用程序的基础包。在 coroutine 文件夹下创建一个 Main.kt 文件，并将以下代码复制并粘贴到该文件中。

package com.coroutine

import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

suspend fun executeProcedureOne(): Int{
    delay(3000L)
    println("procedure one executed")
    return 50;
}

suspend fun executeProcedureTwo(): Int{
    delay(1000L)
    println("procedure two executed")
    return 30;
}

fun main(): Unit = runBlocking {
    val value = async {
        executeProcedureOne()
    }
    value.await()
    val secondValue = async {
        executeProcedureTwo()
    }
    secondValue.await()
}

在上面的代码中，我们定义了两个方法，executeProcedureOne() 和 executeProcedureTwo()，可以暂停执行一些后台任务。这是使用 suspend 关键字实现的，如上所示。

请注意，这两种方法可以在不阻塞底层线程的情况下挂起。

我们已将 main 函数分配给名为 runBlocking 的函数。runBlocking 函数是一个构建器函数，它创建一个在主线程上运行的协程并被阻塞，直到函数内的协程完成执行。

在 runBlocking 函数中，我们创建了两个 async 函数，它们分别调用 executeProcedureOne() 和 executeProcedureTwo() 方法。

async 函数是一个协程构建器，它创建一个新的协程并返回一个 Deferred。Deferred 是一个代表返回值的承诺的未来，我们可以使用 await() 来检索该值。

请注意，在 async 之后立即调用 await() 将导致协程暂停，因为内部协程正在执行并在完成后恢复。

上面的代码在每个 async 函数强制协程暂停直到它完成并且可以转到其他协程之后，作为 await() 方法顺序执行。

运行上面的代码，注意 executeProcedureOne() 在 executeProcedureTwo() 之前完成，即使它延迟了最长时间。输出如下图所示。

procedure one executed
procedure two executed

在 Kotlin 中同时创建和执行协程

注释前面的代码，然后将下面的代码复制并粘贴到注释后的 Main.kt 文件中。

suspend fun executeProcedureOne(): Int{
    delay(3000L)
    println("procedure one executed")
    return 50;
}

suspend fun executeProcedureTwo(): Int{
    delay(1000L)
    println("procedure two executed")
    return 30;
}

suspend fun executeProcedures() = coroutineScope{
    val firstValue = async {
        executeProcedureOne()
    }

    val secondValue = async {
        executeProcedureTwo()
    }

    firstValue.await()
    secondValue.await()
}

fun main(): Unit = runBlocking  {
    executeProcedures()
}

我们已经将前面的示例修改为并发，通过在函数执行后将 async 协程构建器移动到另一个具有 coroutineScope 和 await() 的可挂起函数，以防止挂起协程。

coroutineScope 和 runBlocking 之间的区别在于 coroutineScope 被挂起并释放底层线程以继续执行其他任务。

运行上面的代码并注意 executeProcedureTwo() 方法首先执行，因为它比 executeProcedureOne() 方法具有更少的延迟。输出如下所示。

procedure two executed
procedure one executed

结论

在本教程中，我们了解了协程是什么以及如何利用 async- await() 函数顺序或同时执行它们。我们还学习了协程上下文中的几个常见概念，包括异步编程、同步编程、runBlocking{} 函数和 coroutineScope{} 函数。