Concurrence des demandes du réseau Golang

Avec le développement d'Internet, les requêtes réseau constituent un lien très important, et de nombreuses applications doivent obtenir des données via des requêtes réseau. Pour les scénarios à forte concurrence, la concurrence des requêtes réseau est particulièrement importante. Cet article explique comment utiliser Golang pour le traitement simultané des requêtes réseau.

1. Le modèle de concurrence de Golang

Golang est un langage qui prend en charge la programmation simultanée. Son modèle de concurrence est basé sur goroutine et canal.

Goroutine est un thread léger qui peut exécuter plusieurs goroutines simultanément dans un processus. Dans Golang, vous pouvez facilement créer une goroutine via le mot-clé go, par exemple :

func test() { fmt.Println("hello, world!") } func main() { go test() // 创建一个goroutine fmt.Println("main") }

Dans le code ci-dessus, la fonction de test est créée dans une goroutine et s'exécute en même temps que la fonction principale est exécutée.

Channel est un mécanisme de communication qui peut être utilisé pour transmettre des données entre goroutines. La création et l'utilisation de canaux sont très simples, par exemple :

ch := make(chan int) go func() { ch <- 1 // 发送数据到通道 }() x := <-ch // 从通道中读取数据

Dans ce code, nous créons un canal entier ch, et utilisons une fonction anonyme pour envoyer un entier 1 au canal ch dans une autre goroutine. Ensuite, un entier est lu à partir du canal ch dans la goroutine principale.

2. Concurrence des requêtes réseau Golang

Dans Golang, le package net/http de la bibliothèque standard fournit la prise en charge du protocole http. Nous pouvons utiliser ce package pour lancer facilement des requêtes http, par exemple :

resp, err := http.Get("http://www.google.com")

Ce code peut lancer une requête http GET à Google et obtenir la réponse. Cependant, si vous devez lancer des requêtes pour plusieurs URL en même temps, chaque requête devra attendre la fin de la requête précédente avant de pouvoir être lancée, ce qui est inefficace.

Dans ce cas, nous pouvons utiliser des goroutines et des canaux pour un traitement simultané. Par exemple :

func main() { urls := []string{"http://www.google.com", "http://www.sina.com.cn", "http://www.baidu.com"} ch := make(chan string) for _, url := range urls { go func(u string) { resp, err := http.Get(u) if err != nil { ch <- fmt.Sprintf("error: %s", err) return } defer resp.Body.Close() ch <- fmt.Sprintf("url: %s, status: %s", u, resp.Status) }(url) } for range urls { fmt.Println(<-ch) } }

Dans le code ci-dessus, nous avons créé un canal de type chaîne ch pour recevoir des informations sur chaque résultat de requête. Nous utilisons une boucle for pour parcourir la liste des URL et utilisons une goroutine pour envoyer des requêtes http GET à chaque URL individuellement.

Dans goroutine, nous lançons d'abord une requête et fermons le corps de la réponse une fois la requête terminée. Utilisez ensuite le canal ch pour envoyer les informations de résultat demandées. La boucle for externe est chargée de recevoir les informations de résultat renvoyées par le canal et de les imprimer sur la console.

En utilisant des goroutines et des canaux, nous pouvons lancer plusieurs requêtes réseau en même temps pour améliorer les performances de concurrence.

3. Traitement du délai d'expiration des requêtes réseau Golang

Lorsque nous effectuons des requêtes réseau simultanées, nous devons utiliser un mécanisme de délai d'attente pour contrôler la plage horaire des requêtes face à des anomalies du réseau ou à des temps de réponse longs du serveur.

Dans Golang, nous pouvons utiliser le package context pour ajouter un mécanisme de timeout, par exemple :

func main() { urls := []string{"http://www.google.com", "http://www.sina.com.cn", "http://www.baidu.com"} ch := make(chan string) ctx, cancel := context.WithTimeout(context.Background(), time.Second*2) defer cancel() for _, url := range urls { go func(ctx context.Context, u string) { req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil) if err != nil { ch <- fmt.Sprintf("error: %s", err) return } resp, err := http.DefaultClient.Do(req) if err != nil { ch <- fmt.Sprintf("error: %s", err) return } defer resp.Body.Close() ch <- fmt.Sprintf("url: %s, status: %s", u, resp.Status) }(ctx, url) } for range urls { fmt.Println(<-ch) } }

Dans le code ci-dessus, nous utilisons la fonction WithTimeout du package context pour créer un contexte avec un timeout de 2 secondes. Ensuite, dans la goroutine, une requête http avec contexte est créée à l'aide de la fonction http.NewRequestWithContext et la requête est envoyée. Pendant le processus de requête, nous utilisons le canal ctx.Done() pour écouter le signal de timeout. Si le signal de timeout est déclenché, l'opération demandée est interrompue.

En utilisant le mécanisme de délai d'attente du package de contexte, nous pouvons contrôler l'heure des requêtes réseau et gérer les exceptions qui peuvent survenir pendant le processus de requête.

4. Résumé

Dans cet article, nous avons présenté le modèle de concurrence de Golang, comment utiliser goroutine et les canaux pour le traitement simultané des requêtes réseau, et comment utiliser le package de contexte pour gérer le mécanisme d'expiration des requêtes réseau.

En tant qu'opération courante dans les applications Internet, les requêtes réseau ont un impact crucial sur l'amélioration des performances du système. En traitant simultanément les requêtes réseau et en utilisant le mécanisme de délai d'attente, nous pouvons améliorer les performances de concurrence et la stabilité de l'application et améliorer l'expérience utilisateur.

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!