minuterie golang fermer

Golang est un langage de programmation moderne permettant de développer des performances élevées. Son minuteur est une fonction très pratique qui permet d'effectuer certaines tâches dans un intervalle de temps prédéterminé. Cependant, nous devons parfois désactiver manuellement une minuterie pour éviter un gaspillage inutile de ressources et des plantages de programmes. Cet article explique comment désactiver une minuterie dans Golang.

1. Principes de base des minuteries

Dans Golang, nous pouvons utiliser la fonction minuterie dans le package time. Le code de base pour créer un timer est le suivant :

timer := time.NewTimer(time.Second * 5)

Cette ligne de code créera une instance de timer qui se déclenchera après 5 secondes. Nous pouvons effectuer certaines tâches après le déclenchement du minuteur, par exemple :

<- timer.C
fmt.Println("定时器已触发！")

Lorsque le minuteur expirera, il enverra une heure au canal C. Nous pouvons lire cette heure depuis le canal et effectuer les tâches correspondantes. Le code ci-dessus affichera une ligne de texte prouvant que le minuteur s'est déclenché.

2. Éteignez la minuterie

Nous avons appris à créer une minuterie. Maintenant, nous devons apprendre à l'éteindre. Dans Golang, nous pouvons utiliser la méthode Stop() pour fermer manuellement une minuterie. La fonction de cette méthode est simple : elle arrête l'exécution du timer et rend le canal C incapable de recevoir d'autres messages.

Par exemple, le code suivant créera une minuterie de 5 secondes et la fermera manuellement après 3 secondes :

timer := time.NewTimer(time.Second * 5)
go func() {
    time.Sleep(time.Second * 3)
    timer.Stop()
}()
<- timer.C
fmt.Println("定时器已触发！")

Dans cet exemple, nous démarrons une nouvelle coroutine après la création de la minuterie et la fermons manuellement après 3 secondes. Ce timer ayant été fermé, le canal C ne recevra plus aucun message, donc aucune tâche ne sera déclenchée.

3. Choses à noter lors de l'extinction de la minuterie

Bien que le processus d'extinction de la minuterie semble simple, il y a en fait certaines choses auxquelles il faut prêter attention. Dans cette section, nous explorerons quelques problèmes courants et solutions concernant l'arrêt de la minuterie.

1. La fermeture d'un timer peut bloquer le programme

Dans l'exemple précédent, nous avons montré comment fermer un timer dans une coroutine. Cette approche est généralement la meilleure car elle évite de bloquer le programme principal. Mais que se passe-t-il si nous désactivons une minuterie dans le programme principal ?

Par exemple, le code suivant crée une minuterie de 5 secondes et tente de la fermer après 3 secondes :

timer := time.NewTimer(time.Second * 5)
time.Sleep(time.Second * 3)
timer.Stop()
<- timer.C
fmt.Println("定时器已触发！")

Dans cet exemple, nous utilisons la fonction time.Sleep() pour mettre le programme principal en pause pendant 3 secondes. Ensuite, nous essayons d'éteindre la minuterie et d'attendre qu'elle s'exécute. Cependant, ce programme sera en fait bloqué et attendra le résultat de l'exécution du minuteur.

En effet, lorsque la minuterie est éteinte, elle enverra toujours un message au canal C. Si nous attendons sur le canal C, le programme sera bloqué. Afin d'éviter cette situation, nous pouvons utiliser l'instruction Select pour attendre le résultat de l'exécution du timer.

Le code suivant montre comment utiliser l'instruction Select pour attendre le résultat de l'exécution du timer :

timer := time.NewTimer(time.Second * 5)
time.Sleep(time.Second * 3)
if !timer.Stop() {
    <- timer.C
}
fmt.Println("定时器已关闭！")

Dans cet exemple, nous utilisons la fonction timer.Stop() pour essayer d'éteindre le timer. Si cette fonction renvoie false, cela signifie que le timer n'a pas encore terminé son exécution. À ce stade, nous devons lire un message du canal C pour nous assurer que notre programme ne sera pas bloqué. Sinon, nous affichons directement un texte indiquant que la minuterie a été désactivée.

2. L'exécution du minuteur peut être incertaine

Lorsque nous utilisons l'instruction Select pour attendre le résultat de l'exécution du minuteur, nous pouvons constater que le résultat de l'exécution du minuteur est incertain. En d’autres termes, il est possible que le message du canal C que nous avons reçu ne soit pas un message de déclenchement de minuterie. En effet, nous avons utilisé la fonction Stop() pour fermer manuellement le timer, et cette opération peut avoir interféré avec l'exécution normale du timer.

Par exemple, le code ci-dessous crée une minuterie de 5 secondes et tente de la fermer après 2 secondes. Ensuite, nous utilisons l'instruction Select pour attendre le résultat de l'exécution du timer :

timer := time.NewTimer(time.Second * 5)
time.Sleep(time.Second * 2)
timer.Stop()
select {
    case <- timer.C:
        fmt.Println("定时器已触发！")
    default:
        fmt.Println("定时器已关闭！")
}

Dans cet exemple, nous utilisons l'instruction Select pour attendre le résultat de l'exécution du timer. Cependant, puisque nous avons désactivé manuellement la minuterie après 2 secondes, le résultat final peut être « La minuterie a été désactivée au lieu de « La minuterie s'est déclenchée ! Dans ce cas, le résultat de l’exécution du timer est incertain.

Afin d'éviter cette situation, nous pouvons enregistrer un horodatage lors de la création du timer pour garantir que le résultat de l'exécution du timer est correct. Par exemple :

timer := time.NewTimer(time.Second * 5)
start := time.Now()
time.Sleep(time.Second * 2)
timer.Stop()
if time.Since(start) < (time.Second * 5) {
    select {
        case <- timer.C:
            fmt.Println("定时器已触发！")
        default:
            fmt.Println("定时器已关闭！")
    }
}

Dans cet exemple, nous avons enregistré l'horodatage actuel lors de la création du minuteur. Lorsque nous essayons d'éteindre la minuterie, nous vérifions la différence entre l'heure actuelle et l'intervalle de temps programmé par la minuterie. Si l'intervalle est inférieur à 5 secondes, cela signifie que le timer n'a pas encore été exécuté. Nous pouvons attendre le résultat de l'exécution du timer via l'instruction Select. Sinon, nous générons directement un message texte indiquant que la minuterie a été désactivée.

4.Résumé

Le minuteur de Golang est une fonction très pratique qui peut nous aider à effectuer automatiquement certaines tâches répétitives. Cependant, afin d'éviter le gaspillage de ressources et les plantages de programmes, nous devons apprendre à désactiver manuellement une minuterie. Dans cet article, nous avons présenté comment utiliser la fonction Stop() pour désactiver une minuterie et discuté de certains problèmes et solutions possibles. Après avoir acquis ces compétences, nous pouvons mieux utiliser la fonction de minuterie de Golang pour apporter de meilleures performances et efficacité à nos programmes.

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!