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

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

Voici ce que j'ai, mais me semble laid. 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)
}

La fonction time.NewTickercrée un canal qui envoie un message périodique et fournit un moyen de l'arrêter. Utilisez-le quelque chose comme ça (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 le quitcanal: close(quit).

Et 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

Si vous ne vous souciez pas du décalage des ticks (en fonction du temps que cela a pris précédemment à chaque exécution) et que vous ne souhaitez pas utiliser de canaux, il est possible d'utiliser la fonction de plage native.

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

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

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

Une réponse plus large à cette question pourrait considérer l'approche brique Lego souvent utilisée en Occam, et proposée à la communauté Java via JCSP . Il y a une très bonne présentation de Peter Welch sur cette idée.

Cette approche plug-and-play se traduit directement par Go, car Go utilise les mêmes principes de base du processus séquentiel de communication que Occam.

Ainsi, quand il s'agit de concevoir des tâches répétitives, vous pouvez construire votre système comme un réseau de flux de données de composants simples (comme des goroutines) qui échangent des événements (c'est-à-dire des messages ou des signaux) via des canaux.

Cette approche est compositionnelle: chaque groupe de petits composants peut lui-même se comporter comme un composant plus grand, à l'infini. Cela peut être très puissant car les systèmes concurrents complexes sont fabriqués à partir de briques faciles à comprendre.

Note de bas de page: dans la présentation de Welch, il utilise la syntaxe Occam pour les canaux, qui est ! et ? et ceux-ci correspondent directement à ch <- et <-ch dans Go.

J'utilise le code suivant:

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

C'est plus simple et ça me convient.

Si vous voulez l'arrêter à tout moment, ticker

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 souhaitez pas l'arrêter, cochez :

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