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 fonction est pratique lorsque vous travaillez avec
Apis 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 vous pouvez importer le package de contexte dans votre Allez programmes.
importer"contexte"
Les fonctions contextuelles prennent en compte Contexte type de structure du package de contexte. Classiquement, vous devez utiliser ctx comme nom de la variable d'instance.
fonctionopérations(contexte ctx. Contexte) {
}
Les fonctions peuvent renvoyer le type de structure Context pour d'autres fonctions et opérations.
fonctionopérations(contexte ctx. Contexte)contexte.Contexte {
}
Vous pouvez créer un nouveau contexte avec le FAIRE fonction du package de contexte. La fonction TODO crée un nouveau contexte avec la valeur de contexte. Fait(), 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.
importer"contexte"
fonctionprincipal() {
ctx := contexte. FAIRE()
}
Alternativement, le Arrière-plan La fonction crée un nouveau contexte sans valeur et un canal Done vide.
ctx := contexte. Arrière-plan()
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, ce qui permet une gestion des valeurs et des signaux d'annulation tout au long d'un programme puisque vous pouvez passer le contexte à travers plusieurs les fonctions.
Voici un exemple de passage de contexte à travers des fonctions avec le package de contexte.
importer (
"contexte"
)fonctionvalueContext(contexte ctx. Contexte)contexte.Contexte {
retour contexte. AvecValeur (ctx, « passe-partout », "hfouneqcelkwfu")
}
fonctionrecevoirContextData(contexte ctx. Contexte)n'importe quel {
passKey := ctx. Valeur(« passe-partout »)
retour passKey
}
Le valueContext La fonction 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 le Avecvaleur méthode. 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 le FAIRE ou Arrière-plan fonction et passer le contexte à la fonction (dans ce cas, valueContext) et recevoir le contexte avec le recevoirContextData fonction.
fonctionprincipal() {
ctx := contexte. Arrière-plan()
ctx = valeurContexte (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 contexte Le package fournit des fonctionnalités permettant de définir des délais d'attente et des délais 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 le AvecTimeout méthode pour définir un délai d'attente de contexte. Voici comment définir un délai d'attente de 2 secondes.
fonctionprincipal() {
ctx, annuler := contexte. AvecTimeout (context. Arrière-plan(), 2 * temps. Deuxième)
reporter Annuler()
// une opération
}
Le principal La fonction crée un contexte avec un délai d'attente 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 délais avec le Avec date limite méthode. La méthode WithDeadline prend en compte une instance de contexte et un délai.
fonctionfaire quelque chose(contexte ctx. Contexte) {
date limite := temps. Maintenant().Ajouter(1500 * temps. milliseconde)
ctx, ctxAnnuler := contexte. WithDeadline (ctx, date limite)
reporter ctxAnnuler()// une opération
ctxAnnuler()
}
Le faire quelque chose fonction prend dans un contexte, et la heure limite la variable est le temps avant la contexte date limite. Le ctx variable est le contexte avec une échéance.
Le ctxAnnuler La variable 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.
