Existe-t-il un moyen d'effectuer des tâches répétitives à intervalles réguliers ?

Question

Existe-t-il un moyen d'effectuer des tâches de fond répétitives en Go ? Je pense à quelque chose comme Timer.schedule(task, delay, period) en Java. Je sais que je peux le faire avec une goroutine et Time.sleep() mais j'aimerais quelque chose qui s'arrête facilement.

Voici ce que j'ai obtenu, mais ça m'a paru moche. Existe-t-il un moyen plus propre/meilleur ?

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)
}

Answer 1

La fonction time.NewTicker crée un canal qui envoie un message périodique, et fournit un moyen de l'arrêter. Utilisez-le comme ceci (non testé) :

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

Vous pouvez arrêter le travailleur en fermant la fenêtre quit canal : close(quit) .

Answer 2

Si vous ne vous souciez pas du décalage des tics (en fonction du temps qu'il a fallu auparavant à chaque exécution) et que vous ne voulez pas utiliser de canaux, il est possible d'utiliser la fonction native de plage.

c'est-à-dire

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")
    }
}

Terrain de jeux

Answer 3

Que diriez-vous de quelque chose comme

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")
}

Terrain de jeux

Answer 4

Allez voir cette bibliothèque : https://github.com/robfig/cron

Exemple ci-dessous :

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()

Answer 5

Si vous voulez l'arrêter à tout moment téléscripteur

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

Si vous ne voulez pas l'arrêter tique :

tick := time.Tick(500 * time.Millisecond)
for range tick {
    fmt.Println("Tick")
}