Une introduction approfondie à l'utilisation du contexte Golang

Golang est un langage de programmation puissant, efficace et simple, et se développe actuellement rapidement. Lors de l'écriture du code Go, les paramètres d'entrée et de sortie de chaque fonction ont leur propre cycle de vie. Lorsque plusieurs Goroutines s'exécutent en même temps, nous devrons peut-être gérer le contexte pour garantir l'exactitude du programme. C'est le rôle du contexte Golang. Dans cet article, nous présenterons l'utilisation du contexte Golang.

1. Le concept de Golang Context

Golang Context est un objet contenant des valeurs pertinentes dans la plage de requête. Cet objet peut être transmis entre les fonctions et prend en charge les opérations d'annulation. Par exemple, lors du traitement des requêtes Http, nous pouvons utiliser le package de contexte pour transmettre la requête Http en paramètre afin d'obtenir le contexte lié à la requête.

La définition de la structure de Golang Context est la suivante :

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}

La définition de la structure ci-dessus comprend les méthodes Deadline, Done, Err et Value. Ci-dessous, nous présenterons leurs fonctions une par une.

2. Utilisation de Golang Context

1. Méthode Deadline

La méthode Deadline renvoie une heure et une valeur booléenne. Lorsque le contexte est annulé ou atteint son échéance, le contexte renvoie cette fois et une valeur booléenne true, sinon il renvoie false. Certains contextes n'ont pas de date limite, auquel cas la méthode Deadline renverra false.

func main() {
    ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Second*5))
    defer cancel()
    
    select {
    case <-time.After(3 * time.Second):
        fmt.Println("等待了3秒钟")
    case <-ctx.Done():
        fmt.Println(ctx.Err())
    }
}

Dans le code ci-dessus, nous créons d'abord un contexte avec une date limite dont la date limite est de 5 secondes après l'heure actuelle. Ensuite, nous utilisons l'instruction select pour attendre 3 secondes. À ce moment-là, nous constaterons que le programme est toujours en attente, car le temps d'attente ne dépasse pas la date limite. Enfin, lorsque le délai est dépassé, le programme se terminera en raison de la valeur de retour de ctx.Done().

2. Méthode Done

La méthodeDone renvoie un canal en lecture seule Lorsque le contexte est annulé ou atteint la date limite, ce canal sera fermé. Par conséquent, nous pouvons utiliser l'instruction select et la méthode Done dans notre code pour surveiller l'état du contexte.

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    go func(ctx context.Context) {
        for {
            select {
            case <-ctx.Done():
                fmt.Println(ctx.Err())
                return
            default:
                fmt.Println("goroutine正在运行中...")
                time.Sleep(1 * time.Second)
            }
        }
    }(ctx)

    // 模拟耗时操作
    time.Sleep(5 * time.Second)
    cancel() // 取消Context
    time.Sleep(3 * time.Second)
    fmt.Println("main函数执行结束")
}

Dans le code ci-dessus, nous utilisons les fonctions WithCancel et Cancel pour démarrer et terminer le contexte, et imprimons régulièrement les journaux dans une goroutine jusqu'à ce que le contexte soit annulé. En parallèle, nous utilisons Sleep pour simuler une opération chronophage. La fonction actuelle appelle la fonction d'annulation après 5 secondes, mettant fin au contexte et mettant ainsi fin à l'ensemble du programme.

3. Méthode Err

La méthode Err renvoie la raison pour laquelle le contexte a été annulé. Pour un contexte annulé, cette méthode renverra une valeur d'erreur non nulle. Si le Contexte n'a pas été annulé, la méthode Err retournera nul.

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    go func(ctx context.Context) {
        for {
            select {
            case <-ctx.Done():
                fmt.Println(ctx.Err())
                return
            default:
                fmt.Println("goroutine正在运行中...")
                time.Sleep(1 * time.Second)
            }
        }
    }(ctx)

    // 模拟耗时操作
    time.Sleep(5 * time.Second)
    cancel() // 取消Context
    time.Sleep(3 * time.Second)
    fmt.Println("main函数执行结束")
}

Dans le code ci-dessus, la méthode Err est utilisée dans la goroutine, qui renvoie le motif de l'annulation. Enfin, nous imprimons "l'exécution de la fonction principale est terminée" dans la fonction principale.

4. Méthode Value

La méthode Value renvoie la valeur associée au Context, qui est un objet de type interface{}. Vous pouvez définir n'importe quel type de valeur dans le contexte et utiliser la méthode Value pour obtenir la valeur dans les opérations ultérieures.

type authKey string
func main() {
    ctx := context.WithValue(context.Background(), authKey("token"), "123456")
    fmt.Println(ctx.Value(authKey("token"))) // 打印"123456"
}

Dans le code ci-dessus, nous utilisons la méthode WithValue pour associer une valeur de type chaîne au contexte, et utilisons la méthode Value pour obtenir la valeur.

3. Résumé

Le contexte Golang est une partie importante de la gestion du code concurrent. En transmettant Context entre les fonctions, nous pouvons gérer le cycle de vie dans le code et nous pouvons également surveiller l'état de Context via des méthodes telles que Done, Err et Value. Maîtriser l'utilisation de Golang Context peut améliorer la qualité et la concurrence de votre code.

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!