Kotlin协程：定时执行挂起函数技巧

本文详细介绍了如何在Kotlin协程中定时重复执行挂起函数。通过结合`runBlocking`、`repeat`循环和`delay`函数，可以轻松实现非阻塞式的周期性任务调度。文章将提供完整的代码示例，并解析其工作原理，帮助开发者掌握在协程环境中管理重复性操作的有效方法。

理解Kotlin协程与挂起函数

在Kotlin中，协程（Coroutines）是一种轻量级的并发解决方案，它允许编写非阻塞式代码，从而提高应用程序的响应性和资源利用率。挂起函数（suspend function）是协程的核心，它可以在不阻塞线程的情况下暂停执行，并在稍后恢复。

例如，一个模拟网络请求的挂起函数可能如下所示：

import kotlinx.coroutines.delay
import kotlin.time.Duration.Companion.milliseconds

/**
 * 模拟一个耗时的网络请求，获取以太坊价格。
 * 内部包含一个短时延迟，模拟数据处理。
 *
 * @param input 一个整数输入，用于计算模拟结果。
 * @return 计算后的整数值。
 */
suspend fun ethPriceRequestFun(input: Int): Int {
    // 模拟内部数据处理或网络延迟，这里是10毫秒
    delay(10.milliseconds)
    return input * 20
}

在这个例子中，ethPriceRequestFun 是一个挂起函数，它使用 delay(10.milliseconds) 模拟了一个短暂的异步操作，例如数据计算或数据库查询。

定时重复执行挂起函数

要定时重复执行一个挂起函数，我们可以利用Kotlin协程库提供的 runBlocking、repeat 和 delay 函数。

• runBlocking: 这是一个协程构建器，用于启动一个新的协程并阻塞当前线程，直到协程完成。它通常用于将协程代码桥接到非协程的阻塞世界中，例如在 main 函数或测试代码中。
• repeat: 这是一个标准库函数，用于将代码块重复执行指定次数。
• delay: 这是一个挂起函数，它会在不阻塞底层线程的情况下暂停协程的执行，直到指定的时间过去。

以下是如何将这些组件结合起来，实现挂起函数的定时重复执行：

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.delay
import kotlin.time.DurationUnit
import kotlin.time.toDuration

// ... ethPriceRequestFun 定义如上 ...

/**
 * 调用 ethPriceRequestFun 函数并重复执行。
 * 该函数会在一个 runBlocking 协程中运行，并每隔一秒重复调用 ethPriceRequestFun 5次。
 */
fun callRequest() = runBlocking {
    println("开始重复调用 ethPriceRequestFun...")
    // 重复执行5次
    repeat(5) { index ->
        // 在每次调用前等待1秒
        delay(1.toDuration(DurationUnit.SECONDS))
        // 调用挂起函数并打印结果
        val result = ethPriceRequestFun(index)
        println("第 ${index + 1} 次调用结果: $result")
    }
    println("重复调用结束。")
}

/**
 * 程序的入口点。
 * 调用 callRequest 函数来启动挂起函数的重复执行。
 */
fun main() {
    callRequest()
}

代码解析与执行流程

1. main 函数: 作为程序的入口，它调用了 callRequest() 函数。
2. callRequest() 函数:
   • runBlocking { ... }: 启动一个协程，并阻塞 main 线程直到这个协程块内的所有操作完成。
   • repeat(5) { index -> ... }: 这个循环会执行其内部的代码块5次。index 会从0递增到4。
   • delay(1.toDuration(DurationUnit.SECONDS)): 在每次循环迭代的开始，协程会暂停执行1秒。这1秒的暂停是非阻塞的，意味着底层线程可以执行其他任务。toDuration 扩展函数结合 DurationUnit.SECONDS 明确指定了延迟的单位为秒。
   • val result = ethPriceRequestFun(index): 在1秒延迟后，ethPriceRequestFun 被调用。由于 ethPriceRequestFun 也是一个挂起函数，它内部的 delay(10.milliseconds) 会在其内部逻辑中再引入一个短暂的非阻塞延迟。
   • println(...): 打印每次调用的结果。
3. ethPriceRequestFun(input: Int): 接收一个整数 input，内部延迟10毫秒，然后返回 input * 20 的结果。

预期输出：

程序运行后，你会看到类似以下内容的输出，每行之间大约间隔1秒：

开始重复调用 ethPriceRequestFun...
第 1 次调用结果: 0
第 2 次调用结果: 20
第 3 次调用结果: 40
第 4 次调用结果: 60
第 5 次调用结果: 80
重复调用结束。

这里的 0 20 40 60 80 是因为 ethPriceRequestFun 接收的 index 分别是 0, 1, 2, 3, 4，然后乘以 20 得到的结果。

注意事项

• runBlocking 的使用场景: runBlocking 通常用于测试、main 函数或将现有阻塞代码与协程代码桥接的场景。在实际的生产环境中，特别是Android应用或服务器端，更推荐使用 CoroutineScope 和其他协程构建器（如 launch 或 async）来启动非阻塞的协程，以避免阻塞主线程。
• 延迟单位: 使用 kotlin.time.toDuration 和 DurationUnit 可以明确指定 delay 函数的延迟单位，避免混淆（例如，delay(10) 默认是毫秒）。
• 异常处理: 在实际应用中，你可能需要为挂起函数调用添加 try-catch 块来处理可能发生的异常。
• 取消机制: 对于长时间运行的重复任务，考虑引入协程的取消机制，以便在不再需要时能够优雅地停止任务。

总结

通过结合Kotlin协程的 runBlocking、repeat 循环和 delay 挂起函数，我们可以非常方便且非阻塞地实现挂起函数的定时重复执行。这种模式在需要周期性执行网络请求、数据同步或后台任务的场景中非常有用，充分利用了协程的轻量级和高效性。理解并熟练运用这些基本构建块，是编写高效、响应式Kotlin并发代码的关键。