Comprendre les contextes dans Go

Le contexte est l’une des fonctionnalités essentielles de Go qui permet la simultanéité. Dans Go, le « contexte » fait référence à un package qui fournit des fonctionnalités pour les valeurs de portée de demande et les signaux d’annulation au-delà des limites de l’API.

Le package de contexte fonctionne simultanément avec le modèle de concurrence de Go, basé sur le concept de goroutines. Les goroutines sont des threads d’exécution légers que vous pouvez créer et gérer efficacement, ce qui facilite la création de programmes simultanés dans Go.

Le paquet de contexte

Le package de contexte fournit une fonctionnalité permettant d’annuler des fonctions de longue durée ou des chaînes d’appel entières. Le package permet également de stocker des valeurs de portée de demande pour un accès n’importe où dans la chaîne d’appels. Cette fonctionnalité est pratique lorsque vous travaillez avec des API ou des microservices, où les demandes peuvent s’étendre sur plusieurs appels de fonction et vous souhaitez les annuler ou leur attacher des valeurs spécifiques.

Voici comment importer le package de contexte dans vos programmes Go.

import "context"


Les fonctions de contexte prennent le type de structure Context du package de contexte. Par convention, vous devez utiliser ctx comme nom de la variable d’instance.

func operations(ctx context.Context) {
}


Les fonctions peuvent renvoyer le type de structure Context pour d’autres fonctions et opérations.

func operations(ctx context.Context) context.Context {
}


Vous pouvez créer un nouveau contexte avec la fonction TODO du package de contexte. La fonction TODO crée un nouveau contexte avec la valeur de context.Done() , un canal qui se fermera lors de l’annulation du contexte. Vous devez l’utiliser comme espace réservé lorsque vous avez besoin d’un contexte mais qu’aucun contexte parent ne convient.

import "context"


func main() {
    ctx: = context.TODO()
}


Alternativement, la fonction Background crée un nouveau contexte sans valeur et un canal Done vide.

ctx: = context.Background()


Vous devez utiliser la fonction Background comme racine d’une arborescence de contexte.

Contexte avec des valeurs

Le package de contexte fournit des fonctionnalités pour propager des valeurs et des signaux d’annulation. Vous pouvez utiliser les valeurs pour obtenir des informations allant des données de portée de demande aux signaux d’annulation et aux délais.

Le package de contexte permet également la création d’un contexte enfant hérité des contextes parents, permettant une gestion efficace des valeurs et des signaux d’annulation tout au long d’un programme puisque vous pouvez transmettre le contexte à travers plusieurs fonctions.

Voici un exemple de passage de contexte à travers des fonctions avec le package de contexte.

import (
    "context"
)


func valuableContext(ctx context.Context) context.Context {
    return context.WithValue(ctx, "pass-key", "hfouneqcelkwfu")
}

func receiveContextData(ctx context.Context) any {
    passKey: = ctx.Value("pass-key")
    return passKey
}


La fonction valueContext prend une instance de contexte et renvoie une instance de contexte pour la fonction suivante. L’instance de contexte est une valeur créée avec la méthode WithValue . La méthode WithValue prend l’instance de contexte de la fonction et une paire clé-valeur.

Pour récupérer les données du contexte, vous devrez créer un nouveau contexte avec la fonction TODO ou Background et transmettre le contexte à la fonction (dans ce cas, valueContext) et recevoir le contexte avec la fonction receiveContextData .

func main() {
    ctx: = context.Background()
    ctx = valuableContext(ctx)
    fmt.Println(receiveContextData(ctx))


}


La variable ctx est l’instance de contexte de la fonction Background. La fonction valueContext prend la variable ctx et renvoie le contexte avec une valeur que la fonction receiveContextData prend et renvoie la valeur de la paire clé-valeur.

Délais d’attente et délais de contexte

Le package de contexte fournit des fonctionnalités permettant de définir des délais d’attente et des échéances dans les opérations. La définition de délais d’attente et d’échéances est utile pour les opérations qui doivent rattraper leur retard.

Les délais d’attente correspondent à la durée d’une opération. Vous pouvez définir un délai d’attente pour qu’une opération prenne 4 secondes ; après cela, le contexte annule la demande.

D’autre part, une échéance définit le point absolu où une opération doit s’annuler.

Vous pouvez utiliser la méthode WithTimeout pour définir un délai d’expiration de contexte. Voici comment définir un délai d’attente de 2 secondes.

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


    // some operation
}


La fonction main crée un contexte avec un timeout de deux secondes. La fonction WithTimeout renvoie une fonction d’annulation que vous pouvez reporter pour annulation à la sortie de la fonction principale.

Vous pouvez déclarer des échéances avec la méthode WithDeadline . La méthode WithDeadline prend en compte une instance de contexte et un délai.

func doSomething(ctx context.Context) {
    deadlineTime: = time.Now().Add(1500 * time.Millisecond)
    ctx, ctxCancel: = context.WithDeadline(ctx, deadlineTime)
    defer ctxCancel()


    // some operation

    ctxCancel()
}


La fonction doSomething prend dans un contexte, et la variable deadlineTime est le temps avant la date limite du contexte . La variable ctx est le contexte avec une date limite.

La variable ctxCancel annule le contexte lorsque le contexte dépasse son échéance.

Bonnes pratiques d’utilisation des contextes dans Go

Évitez d’utiliser des contextes comme variables globales. L’utilisation de contextes en tant que variables globales peut entraîner des comportements de code inattendus et des erreurs difficiles à tracer, et utiliser le contexte avec parcimonie pour réduire la complexité du code.

Enfin, utilisez les contextes comme des signaux, pas comme des garanties. L’annulation d’un contexte ne garantit pas que toutes les goroutines cesseront de fonctionner ; c’est simplement un signal, et les goroutines sont indépendantes des contextes.