181

有没有办法在 Go 中执行重复的后台任务？我正在考虑类似Timer.schedule(task, delay, period)Java的东西。我知道我可以使用 goroutine 和 来做到这一点Time.sleep()，但我想要一些容易停止的东西。

这是我得到的，但对我来说看起来很丑。有没有更清洁/更好的方法？

func oneWay() {
    var f func()
    var t *time.Timer

    f = func () {
        fmt.Println("doing stuff")
        t = time.AfterFunc(time.Duration(5) * time.Second, f)
    }

    t = time.AfterFunc(time.Duration(5) * time.Second, f)

    defer t.Stop()

    //simulate doing stuff
    time.Sleep(time.Minute)
}
4

7 回答 7

283

该函数time.NewTicker创建一个发送周期性消息的通道，并提供一种停止它的方法。像这样使用它（未经测试）：

ticker := time.NewTicker(5 * time.Second)
quit := make(chan struct{})
go func() {
    for {
       select {
        case <- ticker.C:
            // do stuff
        case <- quit:
            ticker.Stop()
            return
        }
    }
 }()

quit您可以通过关闭通道来停止工作人员： close(quit)。

于 2013-05-09T16:28:50.853 回答
37

如果您不关心刻度移动（取决于之前每次执行花费了多长时间）并且您不想使用通道，则可以使用本机范围功能。

IE

package main

import "fmt"
import "time"

func main() {
    go heartBeat()
    time.Sleep(time.Second * 5)
}

func heartBeat() {
    for range time.Tick(time.Second * 1) {
        fmt.Println("Foo")
    }
}

操场

于 2016-02-05T16:29:12.660 回答
30

像这样的东西怎么样

package main

import (
    "fmt"
    "time"
)

func schedule(what func(), delay time.Duration) chan bool {
    stop := make(chan bool)

    go func() {
        for {
            what()
            select {
            case <-time.After(delay):
            case <-stop:
                return
            }
        }
    }()

    return stop
}

func main() {
    ping := func() { fmt.Println("#") }

    stop := schedule(ping, 5*time.Millisecond)
    time.Sleep(25 * time.Millisecond)
    stop <- true
    time.Sleep(25 * time.Millisecond)

    fmt.Println("Done")
}

操场

于 2013-05-09T16:27:36.950 回答
23

查看这个库：https ://github.com/robfig/cron

示例如下：

c := cron.New()
c.AddFunc("0 30 * * * *", func() { fmt.Println("Every hour on the half hour") })
c.AddFunc("@hourly",      func() { fmt.Println("Every hour") })
c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty") })
c.Start()
于 2015-12-08T07:56:44.603 回答
3

这个问题的更广泛的答案可能会考虑在 Occam 中经常使用的乐高积木方法，并通过JCSP提供给 Java 社区。Peter Welch对这个想法做了一个很好的介绍。

这种即插即用的方法直接转化为 Go，因为 Go 使用与 Occam 相同的通信顺序过程基础。

因此，在设计重复性任务时，您可以将系统构建为简单组件（如 goroutine）的数据流网络，这些组件通过通道交换事件（即消息或信号）。

这种方法是组合式的：每组小组件本身都可以表现为一个更大的组件，无穷无尽。这可能非常强大，因为复杂的并发系统是由易于理解的砖块组成的。

脚注：在 Welch 的演讲中，他使用 Occam 语法来表示频道，即! 和？这些直接对应于 Go中的ch<-和<-ch 。

于 2013-05-10T16:49:37.240 回答
3

如果你想随时停止它

ticker := time.NewTicker(500 * time.Millisecond)
go func() {
    for range ticker.C {
        fmt.Println("Tick")
    }
}()
time.Sleep(1600 * time.Millisecond)
ticker.Stop()

如果您不想停止它，请勾选：

tick := time.Tick(500 * time.Millisecond)
for range tick {
    fmt.Println("Tick")
}
于 2018-08-09T01:23:30.793 回答
3

我使用以下代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println("\nToday:", now)

    after := now.Add(1 * time.Minute)
    fmt.Println("\nAdd 1 Minute:", after)

    for {
        fmt.Println("test")
        time.Sleep(10 * time.Second)

        now = time.Now()

        if now.After(after) {
            break
        }
    }

    fmt.Println("done")
}

它更简单，对我来说效果很好。

于 2018-08-28T00:48:30.560 回答