C'è un modo per eseguire attività ripetitive a intervalli in Golang?

Question

Esiste un modo per eseguire attività di background ripetitive in Go? Sto pensando a qualcosa come Timer.schedule(task, delay, period) in Java. So che posso farlo con una goroutine e Time.sleep(), ma mi piacerebbe qualcosa che si fermasse facilmente.

Ecco cosa ho ottenuto, ma mi sembra brutto. C'è un modo più pulito/migliore?

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 funzione time.NewTicker fa un canale che invia un messaggio periodica, e fornisce un modo per fermarlo. Usalo qualcosa di simile (non testata):

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

si può fermare il lavoratore chiudendo il canale quit: close(quit).

Answer 2

ne dite qualcosa come

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

Playground

Answer 3

Una risposta più ampia a questa domanda potrebbe considerare l'approccio mattoncino Lego spesso utilizzato in Occam e offerto alla comunità Java tramite JCSP. C'è un ottimo presentation by Peter Welch su questa idea.

Questo approccio plug-and-play si traduce direttamente in Go, perché Go utilizza gli stessi fondamentali del processo di comunicazione sequenziale come Occam.

Quindi, quando si tratta di progettare attività ripetitive, è possibile costruire il proprio sistema come una rete di flussi di dati di componenti semplici (come le goroutine) che scambiano eventi (cioè messaggi o segnali) tramite canali.

Questo approccio è compositivo: ogni gruppo di piccoli componenti può comportarsi come un componente più grande, all'infinito. Questo può essere molto potente perché i complessi sistemi concorrenti sono realizzati con mattoncini di facile comprensione.

Nota: nella presentazione di Welch, che usa la sintassi Occam per i canali, che è ! e ? e questi corrispondono direttamente a ch < - e < -ch in Go.

Answer 4

Partenza questa libreria: https://github.com/robfig/cron

esempio come segue:

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

Se non si cura di zecca spostamento (a seconda di quanto tempo è stato preso in precedenza su ogni esecuzione) e si fa Non voglio usare i canali, è possibile usare la funzione di intervallo nativo.

cioè

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

Playground