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

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 cela fonctionne bien pour moi.

Answer 2

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

Cette approche "plug-and-play" se traduit directement en Go, car Go utilise les mêmes principes fondamentaux du processus séquentiel communicant que Occam.

Ainsi, lorsqu'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 composé de composants simples (comme les 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 constitués de briques faciles à comprendre.

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

Answer 3

Vous pouvez simplement utiliser le paquet gocron comme ceci :

package main

import (
 "fmt"
 "time"
 // go get github.com/go-co-op/gocron
 "github.com/go-co-op/gocron"
)

func main() {
 s := gocron.NewScheduler(time.UTC)
 s.Every(3).Seconds().Do(func() { fmt.Println("Every 3 seconds") })
 // you can start running the scheduler in two different ways:
 // starts the scheduler asynchronously
 s.StartAsync()
 // starts the scheduler and blocks current execution path
 // s.StartBlocking()
}

gocron : https://github.com/go-co-op/gocron