Le contexte est l’une des caractéristiques critiques de Go qui permet la concurrence. En Go, le terme « contexte » fait référence à un paquet qui fournit des fonctionnalités pour les valeurs de requête et les signaux d’annulation à travers les frontières de l’API.
Le paquetage contextuel fonctionne simultanément avec le modèle de concurrence de Go, basé sur le concept de goroutines. Les goroutines sont des fils d’exécution légers que vous pouvez créer et gérer efficacement, ce qui facilite la création de programmes concurrents en Go.
Le paquet Context
Le paquet contextuel fournit une fonctionnalité permettant d’annuler des fonctions à long terme ou des chaînes d’appel entières. Ce paquet permet également de stocker des valeurs liées à une demande afin d’y accéder n’importe où dans la chaîne d’appels. Cette fonctionnalité est pratique lorsqu’on travaille avec des API ou des microservices, où les demandes peuvent couvrir plusieurs appels de fonctions et où l’on souhaite les annuler ou leur attacher des valeurs spécifiques.
Voici comment importer le package context dans vos programmes Go.
import "context"
Les fonctions contextuelles prennent en compte le Contexte Type de structure du paquet contextuel. Par convention, vous devriez utiliser ctx comme nom de la variable d’instance.
func operations(ctx context.Context) {
}
Les fonctions peuvent retourner le type de structure Contexte 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 paquetage contextuel. La fonction TODO crée un nouveau contexte avec la valeur de context.Done()Un canal qui se ferme à l’annulation du contexte. Vous devriez l’utiliser comme un substitut lorsque vous avez besoin d’un contexte mais qu’aucun contexte parent ne convient.
import "context"
func main() {
ctx := context.TODO()
}
Alternativement, l’option Contexte La fonction Done crée un nouveau contexte sans valeur et un canal Done vide.
ctx := context.Background()
Vous devriez utiliser la fonction Background comme racine d’un arbre de contexte.
Contexte avec valeurs
Le paquetage contextuel fournit une fonctionnalité de propagation des valeurs et des signaux d’annulation. Vous pouvez utiliser les valeurs pour des informations allant des données de la demande aux signaux d’annulation et aux délais.
Le paquetage contextuel permet également la création de contextes enfants hérités des contextes parents, ce qui permet 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 du contexte à travers des fonctions avec le package context.
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
}
Le site valuableContext prend en compte 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 fonction WithValue 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 devez créer un nouveau contexte avec la fonction TODO ou Fond d’écran et passer le contexte à la fonction (dans ce cas, valuableContext) et recevoir le contexte avec la fonction receiveContextData fonction.
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 valuableContext prend en compte la variable ctx et renvoie le contexte avec une valeur que la fonction receiveContextData prend en compte et renvoie la valeur de la paire clé-valeur.
Délais et échéances du contexte
Le site contexte fournit une fonctionnalité permettant de définir des délais et des échéances pour les opérations. La définition de délais et d’échéances est utile pour les opérations qui doivent rattraper leur retard.
Les délais d’attente sont la durée d’une opération. Vous pouvez définir un délai d’attente de 4 secondes pour une opération ; au-delà, le contexte annule la demande.
D’autre part, une date limite définit le point absolu où une opération doit être annulée.
Vous pouvez utiliser l’option WithTimeout pour définir un délai d’attente pour le contexte. Voici comment vous pouvez définir un délai de 2 secondes.
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 2 * time.Second)
defer cancel()
// some operation
}
Le site principal crée un contexte avec un délai d’attente de deux secondes. La fonction WithTimeout renvoie une fonction d’annulation que vous pouvez différer pour une annulation à la sortie de la fonction main.
Vous pouvez déclarer des délais avec la fonction WithDeadline méthode. La méthode WithDeadline prend en compte une instance de contexte et une date limite.
func doSomething(ctx context.Context) {
deadlineTime := time.Now().Add(1500 * time.Millisecond)
ctx, ctxCancel := context.WithDeadline(ctx, deadlineTime)
defer ctxCancel()
// some operation
ctxCancel()
}
Le site doSomething prend en compte un contexte, et la fonction deadlineTime variable est le temps avant que la contexte date limite. Le site ctx variable est le contexte avec une échéance.
Le site ctxCancel La variable annule le contexte lorsque celui-ci dépasse son délai.
Meilleures pratiques pour l’utilisation des contextes en Go
Évitez d’utiliser les contextes comme variables globales. L’utilisation de contextes comme variables globales peut conduire à des comportements inattendus du code et à des erreurs difficiles à tracer. Utilisez les contextes 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 agnostiques des contextes.
