Comment utiliser la fonction concurrente du langage Go pour explorer plusieurs pages Web en parallèle ?-Golang-php.cn

Comment utiliser la fonction concurrente du langage Go pour explorer plusieurs pages Web en parallèle ?

WBOY

Libérer： 2023-07-29 19:13:12

original

1259 Les gens l'ont consulté

Comment utiliser la fonction concurrente du langage Go pour réaliser une exploration parallèle de plusieurs pages Web ?

Dans le développement Web moderne, il est souvent nécessaire de récupérer les données de plusieurs pages Web. L'approche générale consiste à lancer les requêtes réseau une par une et à attendre les réponses, ce qui est moins efficace. Le langage Go fournit de puissantes fonctions de concurrence qui peuvent améliorer l'efficacité en explorant plusieurs pages Web en parallèle. Cet article explique comment utiliser la fonction concurrente du langage Go pour réaliser une analyse parallèle de plusieurs pages Web, ainsi que quelques précautions.

Tout d'abord, nous devons utiliser le mot-clé go intégré du langage Go pour créer des tâches simultanées. En ajoutant le mot-clé go avant un appel de fonction, le langage Go encapsulera l'appel de fonction dans une tâche simultanée, puis rendra immédiatement le contrôle au programme principal pour continuer à exécuter le code suivant. Cela peut avoir pour effet d'explorer plusieurs pages Web en parallèle. go关键字创建并发任务。通过在函数调用前加上go关键字，Go语言会将该函数调用包装为一个并发任务，然后立即返回主程序的控制权，继续执行后续的代码。这样可以实现并行抓取多个网页的效果。

下面是一个简单的示例代码：

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

// 并发抓取网页的函数
func fetch(url string, ch chan<- string) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprintf("fetch %s failed: %v", url, err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- fmt.Sprintf("read %s failed: %v", url, err)
        return
    }

    ch <- fmt.Sprintf("fetch %s success: %d bytes", url, len(body))
}

func main() {
    urls := []string{"http://www.example.com", "http://www.google.com", "http://www.microsoft.com"}

    ch := make(chan string)

    for _, url := range urls {
        go fetch(url, ch)
    }

    for range urls {
        fmt.Println(<-ch)
    }
}

Copier après la connexion

在上述代码中，我们定义了一个fetch函数用于抓取单个网页。fetch函数通过http.Get发起网络请求，并将请求结果发送到一个chan类型的通道ch。主程序中，我们创建了一个通道ch和一个包含多个网页URL的切片urls。然后，通过for循环遍历urls切片，并对每个URL调用fetch函数。每次调用fetch函数时，都会使用go关键字创建一个并发任务，这样多个任务就可以同时执行。

最后，我们通过for循环遍历一次urls切片，从通道ch中接收抓取结果并打印输出。由于通道的读取操作会阻塞，所以程序会等待所有并发任务完成后再进行输出。

需要注意的是，并发任务的执行顺序是不确定的，所以最后输出的结果的顺序也是不确定的。如果需要保持结果的顺序，可以使用sync.WaitGroup

Ce qui suit est un exemple de code simple :

rrreee

Dans le code ci-dessus, nous définissons une fonction fetch pour récupérer une seule page Web. La fonction fetch initie une requête réseau via http.Get et envoie le résultat de la requête à un canal de type chan ch . Dans le programme principal, nous avons créé un canal ch et une tranche urls contenant plusieurs URL de pages Web. Ensuite, parcourez la tranche urls à travers une boucle for et appelez la fonction fetch pour chaque URL. Chaque fois que la fonction fetch est appelée, une tâche simultanée sera créée à l'aide du mot-clé go afin que plusieurs tâches puissent être exécutées en même temps.

Enfin, nous parcourons la tranche urls une fois à travers la boucle for, recevons les résultats d'exploration du canal ch et imprimons la sortie. Étant donné que l'opération de lecture du canal sera bloquée, le programme attendra que toutes les tâches simultanées soient terminées avant de sortir. 🎜🎜Il convient de noter que l'ordre d'exécution des tâches simultanées est incertain, donc l'ordre des résultats finaux est également incertain. Si vous devez conserver l'ordre des résultats, vous pouvez utiliser sync.WaitGroup pour attendre la fin des tâches simultanées, puis traiter les résultats dans l'ordre. 🎜🎜De plus, il convient de noter que l'exploration simultanée de pages Web peut entraîner une plus grande pression sur le site Web cible. Afin d'éviter d'être bloqué par le site Web cible ou d'affecter la qualité du service, vous pouvez raisonnablement ajuster le nombre de tâches simultanées, augmenter l'intervalle d'exploration et d'autres stratégies. 🎜🎜En bref, en utilisant la fonction de concurrence du langage Go, nous pouvons facilement réaliser une exploration parallèle de plusieurs pages Web. Cela peut non seulement améliorer l'efficacité de l'exploration, mais également mieux répondre aux besoins de collecte de données à grande échelle. Dans le même temps, l’utilisation de tâches simultanées peut également améliorer l’évolutivité et les capacités de calcul parallèle du programme. 🎜

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!