perhentian berjadual golang

Semakin banyak sistem perisian memerlukan operasi berkala, seperti sandaran data, pembersihan log, tugas berjadual, dsb. Apabila melaksanakan operasi berkala ini, kita biasanya perlu menggunakan pemasa. Golang menyediakan pemasa terbina dalam, tetapi apabila melakukan operasi pemasaan, bagaimanakah anda boleh menghentikan pemasa pada masa yang diperlukan?

Secara umumnya, kita boleh menggunakan pakej masa yang disediakan oleh golang untuk menjana pemasa. Contohnya:

timer1 := time.NewTimer(time.Second * 5)
<-timer1.C
fmt.Println("Timer 1 expired")

Kod di atas akan mengeluarkan "Pemasa 1 tamat tempoh" selepas 5 saat. Program di sini akan menerima isyarat masa daripada saluran pemasa (pemasa1.C) selepas menunggu selama 5 saat, dengan itu merealisasikan tugas pemasa. Perlu diingatkan bahawa pemasa yang dibuat menggunakan fungsi time.NewTimer() akan berulang secara automatik secara lalai Anda perlu menggunakan pemasa.Stop() untuk menamatkan pemasa, jika tidak pemasa akan terus berjalan.

Tetapi bagaimana jika kita perlu menghentikan pemasa dalam masa yang ditetapkan? Sebagai contoh, apabila kami membuat sandaran data, jika masa sandaran yang ditentukan melebihi, kami perlu menghentikan pemasa secara paksa dan menamatkan tugas sandaran. Pada masa ini, kita perlu mengikat isyarat berhenti apabila pemasa dijana, dan menghantar maklumat batal kepada isyarat apabila ia perlu dihentikan.

// 定时任务函数
func doDataBackup(stopSignal chan bool){
    // 模拟数据备份，并每10秒执行一遍
    for {
        select {
        case <-time.After(time.Second * 10):
            backupData()
        case stop := <-stopSignal:
            if stop {
                fmt.Println("Data backup stopped.")
                return
            }
        }
    }
}

func main() {
    stopSignal := make(chan bool)
    // 每10秒备份一次数据，规定备份时间为50秒
    go doDataBackup(stopSignal)
    time.Sleep(time.Second * 50)
    // 操纵停止信号，结束任务
    stopSignal <- true
}

Dalam kod di atas, kami menambahkan isyarat berhenti stopSignal dalam fungsi doDataBackup() untuk menerima maklumat berhenti paksa. Apabila kami perlu menghentikan tugas sandaran, kami hanya perlu menghantar benar ke saluran stopSignal, dan tugas sandaran akan dihentikan secara paksa.

Perlu diambil perhatian bahawa sebelum menghantar isyarat berhenti ke saluran stopSignal, beberapa operasi yang diperlukan seperti penjimatan data dan keluaran sumber mungkin diperlukan. Operasi ini perlu dilakukan sebelum menghantar isyarat berhenti ke saluran, jika tidak, ia boleh menyebabkan masalah seperti kehilangan data.

Perlu ditegaskan bahawa tugas sandaran di atas dilakukan dalam satu coroutine. Jika kita perlu melaksanakan tugas dengan kerap dalam berbilang coroutine dan perlu menghentikannya dengan kerap, kita boleh menggunakan penyegerakan golang.WaitGroup dan pakej konteks untuk mencapai perkara ini. Contohnya:

func doTask(ctx context.Context, wg *sync.WaitGroup, id int){
    defer wg.Done()
    fmt.Printf("goroutine %d started.
", id)
    for {
        select {
        case <-time.After(time.Second * 1):
            fmt.Printf("goroutine %d is working.
", id)
        case <-ctx.Done():
            fmt.Printf("goroutine %d is stopped.
", id)
            return
        }
    }
}

func main() {
    wg := sync.WaitGroup{}
    ctx, cancel := context.WithTimeout(context.Background(), time.Second * 5)
    defer cancel()
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go doTask(ctx, &wg, i)
    }
    wg.Wait()
    fmt.Println("Task completed.")
}

Dalam kod di atas, kami mencipta tiga coroutine Setiap coroutine akan melaksanakan tugas dengan kerap dan mengawal penutupan coroutine melalui konteks masuk. Gunakan sync.WaitGroup untuk memastikan semua tugas coroutine selesai sebelum menamatkan program. Gunakan fungsi WithTimeout() dalam konteks, yang menetapkan bahawa masa maksimum untuk tugasan dijalankan ialah 5 saat Jika tugasan tidak selesai dalam masa 5 saat, tugasan akan dihentikan secara paksa dan coroutine akan keluar.

Di atas ialah cara menggunakan pemasa dalam golang dan cara melaksanakan hentian berjadual. Menggunakan kaedah ini, kami boleh melaksanakan pelbagai tugasan berkala dengan mudah dan mengawal masa berjalan dan masa berhenti tugasan dengan tepat apabila diperlukan.

Atas ialah kandungan terperinci perhentian berjadual golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!