Maison > Article > développement back-end > Comment utiliser la fonction concurrente du langage Go pour explorer plusieurs pages Web en parallèle ?
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) } }
在上述代码中,我们定义了一个fetch
函数用于抓取单个网页。fetch
函数通过http.Get
发起网络请求,并将请求结果发送到一个chan
类型的通道ch
。主程序中,我们创建了一个通道ch
和一个包含多个网页URL的切片urls
。然后,通过for
循环遍历urls
切片,并对每个URL调用fetch
函数。每次调用fetch
函数时,都会使用go
关键字创建一个并发任务,这样多个任务就可以同时执行。
最后,我们通过for
循环遍历一次urls
切片,从通道ch
中接收抓取结果并打印输出。由于通道的读取操作会阻塞,所以程序会等待所有并发任务完成后再进行输出。
需要注意的是,并发任务的执行顺序是不确定的,所以最后输出的结果的顺序也是不确定的。如果需要保持结果的顺序,可以使用sync.WaitGroup
rrreee
Dans le code ci-dessus, nous définissons une fonctionfetch
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!