arrêt programmé à Golang

De plus en plus de systèmes logiciels nécessitent des opérations périodiques, telles que la sauvegarde des données, le nettoyage des journaux, les tâches planifiées, etc. Lors de la mise en œuvre de ces opérations périodiques, nous devons généralement utiliser des minuteries. Golang fournit une minuterie intégrée, mais lors de l'exécution d'opérations de chronométrage, comment pouvons-nous arrêter la minuterie à l'heure requise ?

De manière générale, nous pouvons utiliser le package time fourni par golang pour générer un timer. Par exemple :

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

Le code ci-dessus affichera "Timer 1 expired" après 5 secondes. Le programme ici recevra un signal horaire du canal minuterie (timer1.C) après avoir attendu 5 secondes, réalisant ainsi la tâche de la minuterie. Il convient de noter que le minuteur créé à l'aide de la fonction time.NewTimer() se répétera automatiquement par défaut. Vous devez utiliser timer.Stop() pour mettre fin au minuteur, sinon le minuteur continuera à fonctionner.

Mais que se passe-t-il si nous devons arrêter le chronomètre dans un délai déterminé ? Par exemple, lorsque nous sauvegardons des données, si la durée de sauvegarde spécifiée est dépassée, nous devons arrêter de force le minuteur et mettre fin à la tâche de sauvegarde. À ce stade, nous devons lier le signal d'arrêt lorsque la minuterie est générée et envoyer des informations d'abandon au signal lorsqu'il doit être arrêté.

// 定时任务函数
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
}

Dans le code ci-dessus, nous avons ajouté un signal d'arrêt stopSignal dans la fonction doDataBackup() pour accepter les informations d'arrêt forcé. Lorsque nous devons arrêter la tâche de sauvegarde, il nous suffit d'envoyer true au canal stopSignal, et la tâche de sauvegarde sera arrêtée de force.

Il est à noter qu'avant d'envoyer un signal d'arrêt au canal stopSignal, certaines opérations nécessaires telles que la sauvegarde des données et la libération des ressources peuvent être nécessaires. Ces opérations doivent être effectuées avant d'envoyer un signal d'arrêt au canal, sinon cela pourrait entraîner des problèmes tels qu'une perte de données.

Il convient de souligner que les tâches de sauvegarde ci-dessus sont effectuées au sein d'une seule coroutine. Si nous devons exécuter des tâches régulièrement dans plusieurs coroutines et les arrêter régulièrement, nous pouvons utiliser les packages sync.WaitGroup et context de Golang pour y parvenir. Par exemple :

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

Dans le code ci-dessus, nous avons créé trois coroutines. Chaque coroutine exécutera une tâche régulièrement et contrôlera la fermeture de la coroutine via le contexte entrant. Utilisez sync.WaitGroup pour vous assurer que toutes les tâches de coroutine sont terminées avant de terminer le programme. Utilisez la fonction WithTimeout() dans le contexte, qui stipule que le temps maximum d'exécution de la tâche est de 5 secondes. Si la tâche n'est pas terminée dans les 5 secondes, la tâche sera arrêtée de force et la coroutine se terminera.

Ce qui précède explique comment utiliser les minuteries dans Golang et comment mettre en œuvre un arrêt programmé. Grâce à ces méthodes, nous pouvons facilement mettre en œuvre diverses tâches périodiques et contrôler avec précision le temps d’exécution et l’heure d’arrêt des tâches en cas de besoin.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!