Gibt es eine Möglichkeit, sich wiederholende Aufgaben in regelmäßigen Abständen auszuführen?

Gibt es eine Möglichkeit, sich wiederholende Hintergrundaufgaben in Go auszuführen? Ich denke an so etwas wie Timer.schedule(task, delay, period)in Java. Ich weiß, dass ich das mit einer Goroutine machen kann und Time.sleep(), aber ich möchte etwas, das leicht zu stoppen ist.

Folgendes habe ich bekommen, sehe aber für mich hässlich aus. Gibt es einen saubereren / besseren Weg?

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

Die Funktion erstellt time.NewTickereinen Kanal, der eine periodische Nachricht sendet, und bietet eine Möglichkeit, diese zu stoppen. Verwenden Sie es so etwas (ungetestet):

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

Sie können den Worker stoppen, indem Sie den quitKanal schließen : close(quit).

Wie wäre es mit so etwas

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

Spielplatz

Wenn Sie sich nicht für das Tick-Shifting interessieren (abhängig davon, wie lange es zuvor bei jeder Ausführung gedauert hat) und keine Kanäle verwenden möchten, können Sie die native Bereichsfunktion verwenden.

dh

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

Spielplatz

Schauen Sie sich diese Bibliothek an: https://github.com/robfig/cron

Beispiel wie folgt:

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

Eine umfassendere Antwort auf diese Frage könnte den in Occam häufig verwendeten Lego-Brick-Ansatz berücksichtigen, der der Java-Community über JCSP angeboten wird . Es gibt eine sehr gute Präsentation von Peter Welch zu dieser Idee.

Dieser Plug-and-Play-Ansatz wird direkt in Go übersetzt, da Go dieselben Grundlagen für den kommunizierenden sequentiellen Prozess verwendet wie Occam.

Wenn Sie sich wiederholende Aufgaben entwerfen, können Sie Ihr System als Datenflussnetzwerk aus einfachen Komponenten (als Goroutinen) aufbauen, die Ereignisse (dh Nachrichten oder Signale) über Kanäle austauschen.

Dieser Ansatz ist kompositorisch: Jede Gruppe kleiner Komponenten kann sich ad infinitum als größere Komponente verhalten. Dies kann sehr leistungsfähig sein, da komplexe gleichzeitige Systeme aus leicht verständlichen Bausteinen bestehen.

Fußnote: In Welchs Präsentation verwendet er die Occam-Syntax für Kanäle, das heißt ! und ? und diese entsprechen direkt ch <- und <-ch in Go.

Ich benutze den folgenden Code:

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

Es ist einfacher und funktioniert gut für mich.

Wenn Sie es in jedem Moment stoppen möchten, ticken Sie

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

Wenn Sie nicht aufhören wollen, es tick :

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