在 Golang 中以最小间隔调用具有可变执行时间的函数的最佳方法？

你在学习golang相关的知识吗？本文《在 Golang 中以最小间隔调用具有可变执行时间的函数的最佳方法？》，主要介绍的内容就涉及到，如果你想提升自己的开发能力，就不要错过这篇文章，大家要知道编程理论基础和实战操作都是不可或缺的哦！

我想在 go 中以不少于给定的时间间隔执行一个函数，通过一次调用的开始到下一次调用的开始来衡量。函数本身的执行时间会有所不同。

如果函数运行的时间超过该间隔，我想立即再次运行它。但是，如果/当它最终在不到一个完整的时间间隔内恢复完成时，我希望它立即恢复等待，直到下一个时间间隔边界。

就上下文而言，这是一个速率限制器 - 被调用的函数可以轻松地旋转 cpu，但不会产生额外的价值，因为它与不可能反应那么快的人类进行交互。

为清楚起见，举一个示例（示例中的 interval == 20ms）：

runtime:  15ms
wait:      5ms
runtime:  25ms
wait:      0ms
runtime:  25ms
wait:      0ms
runtime:  15ms
wait:      5ms <-- this is the important bit

如果我使用 time.ticker，我相信额外的“ticks”要么会在 ticker.c 通道中排队（如果它已缓冲），导致它在恢复时毫无延迟地进行一堆调用，要么是 ticker 的编写器将阻止写入通道，并最终在恢复后的第一次调用中出现过长的延迟。

现在我正在做一些数学计算，这很有效，但感觉它可能不惯用：

minDurationBetweenRuns := time.Millisecond * 100
for {
    lastRunTime := time.Now()

    DO_STUFF_HERE()

    durationSinceLastRun := time.Now().Sub(lastRunTime)
    if durationSinceLastRun < minDurationBetweenRuns {
        sleepTime := minDurationBetweenRuns - durationSinceLastRun
        if sleepTime > minDurationBetweenRuns {
            sleepTime = minDurationBetweenRuns
        }
        time.Sleep(sleepTime)
    }
}

解决方案

在写问题时，我记得 golang 源代码非常容易阅读......并且认为我应该在看起来很愚蠢之前先看一眼。我对我的发现很满意:)

the source 中对 time.ticker 的评论表示，如果刻度读取器落后，它将开始丢弃刻度，而不是阻塞写入通道（其缓冲区只有 1）。这样做的效果是在我们错过一个或多个刻度后立即让事情回到“正轨”。

证明示例：

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.newticker(time.millisecond * 50)
    for i := 0; i < 10; i++ {
        fmt.printf("new invocation starting at %dms\n", time.now().round(time.millisecond).nanosecond()/int(time.millisecond))
        if i%3 == 0 {
            fmt.println("executing for 25ms")
            time.sleep(time.millisecond * 25)
        } else {
            fmt.println("executing for 75ms")
            time.sleep(time.millisecond * 75)
        }
        fmt.println("waiting for ticker...")
        <-t.c
    }
    t.stop()
}

输出：

New invocation starting at 0ms
Executing for 25ms
Waiting for ticker...
New invocation starting at 50ms
Executing for 75ms
Waiting for ticker...
New invocation starting at 125ms
Executing for 75ms
Waiting for ticker...
New invocation starting at 200ms
Executing for 25ms
Waiting for ticker...
New invocation starting at 250ms
Executing for 75ms
Waiting for ticker...
New invocation starting at 325ms
Executing for 75ms
Waiting for ticker...
New invocation starting at 400ms
Executing for 25ms
Waiting for ticker...
New invocation starting at 450ms
Executing for 75ms
Waiting for ticker...
New invocation starting at 525ms
Executing for 75ms
Waiting for ticker...
New invocation starting at 600ms
Executing for 25ms
Waiting for ticker...

好了，本文到此结束，带大家了解了《在 Golang 中以最小间隔调用具有可变执行时间的函数的最佳方法？》，希望本文对你有所帮助！关注编程网公众号，给大家分享更多Golang知识！