Comment utiliser le contexte pour implémenter la communication entre les goroutines dans Go

Le langage Go, en tant que langage de programmation prenant en charge la concurrence, fournit un puissant mécanisme goroutine qui peut exécuter plusieurs tâches simultanément pendant l'exécution du programme. Cependant, communiquer entre plusieurs goroutines n’est pas toujours simple. Afin de résoudre ce problème, le langage Go a introduit le package de contexte, qui fournit un mécanisme permettant de transmettre les données de portée de la requête entre les goroutines et d'annuler l'exécution des goroutines. Cet article expliquera comment utiliser le contexte pour implémenter la communication entre les routines et fournira des exemples de code correspondants.

1. Concepts de base
Avant de commencer à utiliser le contexte, nous devons comprendre certains concepts de base. En langage Go, le contexte est un mécanisme utilisé pour suivre l'état de la goroutine. Le contexte contient une variété d'opérations qui peuvent être utilisées pour transmettre des données dans la portée de la requête et annuler l'exécution de goroutine.

context utilise une interface Context, qui définit quatre méthodes :

1. Deadline() (deadline time.Time, ok bool) : renvoie une heure, représentant la date limite (heure limite) du contexte actuel. Si le contexte n'a pas de date limite, la valeur de ok est fausse.
2. Done() <-chan struct{} : renvoie un canal qui sera fermé lorsque le contexte est annulé ou que la date limite est atteinte.
3. Erreur Err() : renvoie la raison pour laquelle le contexte a été annulé.
4. Value(key interface{}) interface{} : renvoie la valeur associée à la clé.

2. Exemple d'utilisation
Nous utilisons un exemple pour démontrer comment utiliser le contexte pour réaliser une communication entre les groupes. Supposons que nous ayons une fonction qui simule une requête réseau. Le code lié à la requête est le suivant :

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

func simulateNetworkRequest(ctx context.Context) {
    // 模拟一个网络请求，请求耗时5秒
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("网络请求完成")
    case <-ctx.Done():
        fmt.Println("网络请求被取消")
        return
    }
}

Dans le code ci-dessus, la fonction simulationNetworkRequest simule une requête réseau, ce qui prend 5 secondes. Nous écoutons deux canaux via l'instruction select. L'un est le canal renvoyé par la fonction time.After, ce qui signifie qu'après un certain temps, une valeur sera envoyée au canal ; méthode, ce qui signifie que le contexte est Lorsqu'il est annulé, une valeur sera envoyée au canal. Si la requête réseau n'est pas terminée dans les 5 secondes et que le contexte est annulé, nous la traiterons dans la deuxième branche case de l'instruction select.

Ensuite, nous utilisons cette fonction dans la fonction principale et ajoutons du code pour montrer comment utiliser le contexte pour réaliser une communication inter-goroutines :

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

func simulateNetworkRequest(ctx context.Context) {
    // 模拟一个网络请求，请求耗时5秒
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("网络请求完成")
    case <-ctx.Done():
        fmt.Println("网络请求被取消")
        return
    }
}

func main() {
    // 创建一个基于context.Background()的新context
    ctx, cancel := context.WithCancel(context.Background())

    // 启动goroutine执行网络请求
    go simulateNetworkRequest(ctx)

    // 在3秒后取消网络请求
    time.Sleep(3 * time.Second)
    cancel()

    // 等待网络请求执行完毕
    time.Sleep(10 * time.Second)
}

Dans le code ci-dessus, nous créons d'abord un nouveau contexte en utilisant la fonction context.WithCancel, Et renvoie une fonction Cancel spécialement utilisée pour l'annulation. Ensuite, nous avons démarré une goroutine pour exécuter la fonction simulationNetworkRequest, en passant le contexte créé ci-dessus en paramètre. Ensuite, après avoir attendu 3 secondes dans la fonction principale, on appelle la fonction Cancel pour annuler la requête réseau.

La dernière ligne de code est utilisée pour garantir qu'après l'annulation de la demande réseau, la fonction principale ne se terminera pas avant que la demande réseau ne soit terminée. De cette façon, nous pouvons établir la communication entre la fonction principale et la goroutine, et annuler l'exécution de la goroutine en cas de besoin.

Résumé
En utilisant le package de contexte, nous pouvons transmettre les données de portée de la requête entre différentes goroutines et annuler l'exécution de la goroutine en cas de besoin. Cet article montre comment utiliser le contexte pour implémenter la communication entre les routines à travers un exemple simple. J'espère que les lecteurs pourront comprendre comment utiliser le package de contexte en langage Go grâce à l'introduction de cet article, afin de mieux effectuer 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!