Comment utiliser goroutine pour implémenter des requêtes parallèles en langage Go

golang est un langage de programmation très populaire. Il possède de nombreuses fonctionnalités uniques, l'une des caractéristiques importantes est qu'il prend en charge le traitement parallèle. Dans le monde d'aujourd'hui, les requêtes réseau font désormais partie de notre quotidien. Si nous devons demander plusieurs API, comment pouvons-nous accomplir cette tâche dans les plus brefs délais ? C'est exactement le sujet du sujet des requêtes parallèles Golang.

La requête dite parallèle consiste simplement à lancer plusieurs requêtes réseau en même temps pour améliorer l'efficacité de la requête. En Golang, nous pouvons utiliser goroutine pour implémenter des requêtes parallèles afin de traiter rapidement un grand nombre de requêtes.

Tout d’abord, voyons comment utiliser goroutine pour implémenter des requêtes parallèles.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    urls := []string{
        "http://example.com/1",
        "http://example.com/2",
        "http://example.com/3",
    }

    for _, url := range urls {
        go func(url string) {
            res, err := http.Get(url)
            if err != nil {
                fmt.Println("Error:", err)
                return
            }

            fmt.Println("Response:", res.Status)
        }(url)
    }

    fmt.Scanln()
}

Dans cet exemple, nous définissons un tableau d'URL qui contient les URL que nous devons demander. Nous parcourons ce tableau et démarrons une nouvelle goroutine sur chaque URL en utilisant le mot-clé go. Cette goroutine envoie une requête HTTP GET et renvoie la réponse au terminal une fois la requête terminée. go 关键字在每个 URL 上启动一个新的 goroutine。这个 goroutine 发送一个 HTTP GET 请求，并在请求结束后将响应结果输出到终端。

这样的同时请求会让我们的程序变得更快，但同时也会有一些问题。首先，如果我们启动了太多的 goroutine，我们可能会超过操作系统允许的最大并发数。其次，我们需要等待所有请求完成才能得到结果，这可能会导致响应时间过长，也就是说我们需要一些更加高效的处理方式。

接下来，我们来看一下如何使用 goroutine 和 channel 实现更加高效的并行请求。

package main

import (
    "fmt"
    "net/http"
)

func main() {
    urls := []string{
        "http://example.com/1",
        "http://example.com/2",
        "http://example.com/3",
    }

    ch := make(chan string)

    for _, url := range urls {
        go func(url string) {
            res, err := http.Get(url)
            if err != nil {
                fmt.Println("Error:", err)
                return
            }

            ch <- fmt.Sprintf("Response from %s: %s", url, res.Status)
        }(url)
    }

    for i := 0; i < len(urls); i++ {
        fmt.Println(<-ch)
    }
}

在这个例子中，我们定义了一个名为 ch

De telles demandes simultanées rendront notre programme plus rapide, mais en même temps il y aura quelques problèmes. Premièrement, si nous démarrons trop de goroutines, nous pouvons dépasser la concurrence maximale autorisée par le système d'exploitation. Deuxièmement, nous devons attendre que toutes les demandes soient terminées avant de pouvoir obtenir les résultats, ce qui peut entraîner des temps de réponse longs, ce qui signifie que nous avons besoin de méthodes de traitement plus efficaces.

Ensuite, voyons comment utiliser goroutine et canal pour obtenir des requêtes parallèles plus efficaces.

rrreee

Dans cet exemple, nous définissons un canal nommé ch, et nous envoyons les résultats au canal dans chaque goroutine. Dans le thread principal, nous utilisons une boucle pour recevoir tous les résultats dans le canal et les imprimer sur le terminal. 🎜🎜L'avantage d'utiliser les canaux est que nous pouvons contrôler le nombre de goroutines, et nous n'avons pas besoin d'attendre que toutes les goroutines terminent la demande pour obtenir le résultat. Par rapport à l'attente que toutes les demandes soient terminées, de telles demandes parallèles peuvent nous permettre d'obtenir des résultats plus rapidement et également d'éviter les retards causés par les longs temps de réponse aux demandes. 🎜🎜En résumé, la requête parallèle Golang est une méthode qui utilise les fonctionnalités du langage Golang pour traiter plusieurs requêtes réseau en même temps, améliorant ainsi l'efficacité des requêtes. En implémentant des requêtes parallèles, nous pouvons utiliser goroutine et canal pour contrôler la concurrence du programme et renvoyer les résultats immédiatement après avoir reçu la réponse de chaque requête, nous permettant de traiter un grand nombre de requêtes dans les plus brefs délais. 🎜

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!