Comment utiliser le contexte pour implémenter le contrôle du délai d'attente dans Go

Comment utiliser le contexte pour implémenter le contrôle des délais d'attente dans Go

Introduction :
Lors de l'écriture de programmes simultanés, le contrôle des délais d'attente est une technologie très importante. Lorsque le programme doit effectuer une opération, si l'opération ne peut pas être terminée dans le délai spécifié, nous espérons pouvoir l'interrompre et effectuer un autre traitement. Dans le langage Go, nous pouvons utiliser le package de contexte pour implémenter le contrôle du délai d'attente.

1. Introduction au contexte
   Le contexte est un mécanisme du langage Go spécialement conçu pour gérer des tâches simultanées. Il peut être utilisé pour transmettre des signaux d'annulation, des signaux d'expiration et des métadonnées de portée de demande. En utilisant le package de contexte, nous pouvons gérer avec élégance les problèmes de délai d'attente dans les opérations simultanées.
2. Utilisez le contexte pour implémenter le contrôle du délai d'attente
   Ci-dessous, nous utilisons un exemple pour expliquer comment utiliser le contexte pour implémenter le contrôle du délai d'attente. Supposons que nous ayons une fonction qui doit être exécutée dans les 3 secondes, sinon nous l'interromprons et effectuerons un autre traitement. Tout d’abord, nous devons importer le package de contexte.

import (
    "context"
    "fmt"
    "time"
)

Ensuite, nous définissons une fonction qui effectuera des opérations fastidieuses. Dans la fonction, nous utilisons l'instruction select pour surveiller si le signal Done() du contexte est déclenché. S'il est déclenché, l'opération en cours peut être interrompue.

func doSomething(ctx context.Context) {
    // 模拟一个耗时操作
    time.Sleep(5 * time.Second)
    
    select {
    case <-ctx.Done():
        fmt.Println("操作被中断")
        return
    default:
        fmt.Println("操作执行成功")
    }
}

Ensuite, nous devons créer un objet contextuel dans la fonction principale et définir le délai d'attente sur 3 secondes.

func main() {
    // 创建一个context对象，并设置超时时间为3秒
    ctx, cancel := context.WithTimeout(context.Background(), 3 * time.Second)
    defer cancel()

    // 在新的goroutine中执行操作，并传入context对象
    go doSomething(ctx)

    // 等待3秒，让操作有足够的时间执行
    time.Sleep(3 * time.Second)
}

Dans l'exemple ci-dessus, nous utilisons la fonction WithTimeout pour créer un objet contextuel contenant un délai d'attente et le transmettre à la fonction doSomething. Ensuite, nous attendons 3 secondes dans la fonction principale pour donner à la fonction doSomething suffisamment de temps pour s'exécuter. Si la fonction doSomething est exécutée dans les 3 secondes, « L'opération a été exécutée avec succès » sera affiché ; si elle dépasse 3 secondes et que le signal de délai d'attente est déclenché, « L'opération a été interrompue » sera affiché.

3. Utilisez le contexte pour gérer le contrôle du délai d'attente de plusieurs goroutines
   Dans des scénarios de concurrence réels, nous devons souvent gérer le contrôle du délai d'attente de plusieurs goroutines. L'exemple de code suivant montre comment utiliser le contexte pour gérer le contrôle du délai d'attente pour plusieurs goroutines.

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println(name, "被中断")
            return
        default:
            fmt.Println(name, "正常执行")
            time.Sleep(time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3 * time.Second)
    defer cancel()

    go worker(ctx, "worker1")
    go worker(ctx, "worker2")
    go worker(ctx, "worker3")

    // 等待3秒钟，观察goroutine的执行情况
    time.Sleep(3 * time.Second)
}

Dans le code ci-dessus, nous définissons une fonction de travail, qui affichera en continu le nom de la goroutine actuelle et dormira pendant une seconde. Ensuite, nous avons démarré la goroutine de trois travailleurs dans la fonction principale et passé dans le même objet contextuel. Nous utilisons la fonction WithTimeout pour créer un objet contextuel contenant un délai d'attente et le transmettre à la fonction de travail. Ensuite on attend 3 secondes dans la fonction main pour observer l'exécution de la goroutine. Lorsqu'il dépasse 3 secondes, le signal de délai d'attente est déclenché et la goroutine affichera « interrompu ».

Résumé :
En utilisant le package de contexte, nous pouvons implémenter avec élégance un contrôle de délai d'attente pour les opérations simultanées. Lors de l'écriture de programmes simultanés, l'utilisation rationnelle du contexte peut non seulement améliorer la fiabilité du programme, mais également éviter un blocage à long terme et améliorer les performances du programme. J'espère que cet article vous aidera à comprendre le contrôle des délais d'attente dans la programmation simultanée.

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!