Có cách nào để thực hiện các nhiệm vụ lặp đi lặp lại trong khoảng thời gian không?

Có cách nào để thực hiện các tác vụ nền lặp đi lặp lại trong Go không? Tôi đang nghĩ về một cái gì đó giống như Timer.schedule(task, delay, period)trong Java. Tôi biết tôi có thể làm điều này với một con goroutine và Time.sleep(), nhưng tôi muốn thứ gì đó dễ dàng dừng lại.

Đây là những gì tôi có, nhưng trông xấu xí đối với tôi. Có cách nào sạch hơn / tốt hơn không?

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

Hàm này time.NewTickertạo một kênh gửi thông điệp định kỳ và cung cấp một cách để ngăn chặn nó. Sử dụng nó một cái gì đó như thế này (chưa được kiểm tra):

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

Bạn có thể ngừng người lao động bằng cách đóng quitkênh: close(quit).

Thế còn một cái gì đó như

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

Sân chơi

Nếu bạn không quan tâm đến việc dịch chuyển tick (tùy thuộc vào thời gian trước đó trong mỗi lần thực hiện) và bạn không muốn sử dụng các kênh, bạn có thể sử dụng chức năng phạm vi gốc.

I E

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

Sân chơi

Kiểm tra thư viện này: https://github.com/robfig/cron

Ví dụ như dưới đây:

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

Một câu trả lời rộng hơn cho câu hỏi này có thể xem xét cách tiếp cận gạch Lego thường được sử dụng trong Occam và được cung cấp cho cộng đồng Java thông qua JCSP . Có một bài thuyết trình rất hay của Peter Welch về ý tưởng này.

Cách tiếp cận plug-and-play này dịch trực tiếp sang Go, bởi vì Go sử dụng các nguyên tắc cơ bản Giao tiếp liên tục tương tự như Occam.

Vì vậy, khi nói đến việc thiết kế các tác vụ lặp đi lặp lại, bạn có thể xây dựng hệ thống của mình dưới dạng một mạng dữ liệu gồm các thành phần đơn giản (như goroutines) để trao đổi các sự kiện (tức là tin nhắn hoặc tín hiệu) qua các kênh.

Cách tiếp cận này là thành phần: mỗi nhóm các thành phần nhỏ có thể tự hoạt động như một thành phần lớn hơn, ad infinitum. Điều này có thể rất mạnh mẽ vì các hệ thống đồng thời phức tạp được làm từ những viên gạch dễ hiểu.

Chú thích: trong bài thuyết trình của Welch, anh ấy sử dụng cú pháp Occam cho các kênh, đó là ! và ? và những cái này tương ứng trực tiếp với ch <- và <-ch trong Go.

Tôi sử dụng mã sau đây:

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

Nó đơn giản hơn và hoạt động tốt với tôi.

Nếu bạn muốn ngăn chặn nó trong bất kỳ thời điểm ticker

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

Nếu bạn không muốn dừng nó, hãy đánh dấu :

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