Aralıklarla tekrar eden görevleri yapmanın bir yolu var mı?

Go'da tekrarlayan arka plan görevlerini yapmanın bir yolu var mı? Timer.schedule(task, delay, period)Java'daki gibi bir şey düşünüyorum . Bunu bir gorutinle yapabileceğimi biliyorum Time.sleep()ama kolayca durdurulabilecek bir şey istiyorum.

İşte bulduğum şey, ama bana çirkin görünüyor. Daha temiz / daha iyi bir yol var mı?

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

İşlev time.NewTicker, periyodik bir mesaj gönderen bir kanal oluşturur ve onu durdurmanın bir yolunu sağlar. Bunun gibi bir şey kullanın (test edilmemiş):

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

Sen kapatarak işçiyi durdurabilirsiniz quitkanalı: close(quit).

Gibi bir şeye ne dersin

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

Oyun alanı

Kene kaydırmayı umursamıyorsanız (her yürütmede daha önce ne kadar sürdüğüne bağlı olarak) ve kanalları kullanmak istemiyorsanız, yerel aralık işlevini kullanmak mümkündür.

yani

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

Oyun alanı

Bu kitaplığa göz atın: https://github.com/robfig/cron

Aşağıdaki gibi örnek:

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

Bu soruya daha geniş bir cevap, Occam'da sıklıkla kullanılan ve Java topluluğuna JCSP aracılığıyla sunulan Lego tuğla yaklaşımını düşünebilir . Bu fikir hakkında Peter Welch'in çok güzel bir sunumu var .

Bu tak ve çalıştır yaklaşımı doğrudan Go'ya çevrilir, çünkü Go, Occam'ın yaptığı gibi aynı Sıralı İletişim Süreci temellerini kullanır.

Dolayısıyla, tekrarlayan görevlerin tasarlanması söz konusu olduğunda, sisteminizi, kanallar aracılığıyla olayları (yani mesajlar veya sinyaller) değiş tokuş eden basit bileşenlerden (grup olarak) oluşan bir veri akışı ağı olarak oluşturabilirsiniz.

Bu yaklaşım bileşimseldir: her küçük bileşen grubu, daha büyük bir bileşen, sonsuza kadar davranabilir. Bu çok güçlü olabilir çünkü karmaşık eşzamanlı sistemler anlaşılması kolay tuğlalardan yapılmıştır.

Dipnot: Welch'in sunumunda, kanallar için Occam sözdizimini kullanıyor, yani ! ve ? ve bunlar doğrudan Go'daki ch <- ve <-ch'e karşılık gelir .

Aşağıdaki kodu kullanıyorum:

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

Daha basit ve benim için iyi çalışıyor.

Herhangi bir anda durdurmak istiyorsanız, ticker

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

Durdurmak istemiyorsanız işaretleyin :

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