Comment Golang fonctionne efficacement pour gérer les tâches parallèles

Gestion efficace des tâches parallèles dans les fonctions Go : utilisez le mot-clé go pour lancer des routines simultanées. Utilisez sync.WaitGroup pour compter le nombre de routines en attente. Une fois la routine terminée, wg.Done() est appelé pour décrémenter le compteur. Le programme principal se bloque en utilisant wg.Wait() jusqu'à ce que toutes les routines soient terminées. Cas pratique : Envoyez simultanément des requêtes web et collectez les réponses.

Traitement efficace des tâches parallèles dans les fonctions Go

Le langage Go offre de puissantes capacités de traitement parallèle, permettant aux développeurs de créer et d'exécuter facilement des tâches simultanées. Cet article expliquera comment utiliser les fonctions Go pour gérer efficacement des tâches parallèles et fournira un cas pratique pour démontrer son utilisation.

Concurrence dans les fonctions Go

Les fonctions Go fournissent deux mots-clés pour prendre en charge l'exécution simultanée : go et sync.WaitGroup. Le mot-clé go est utilisé pour démarrer des routines Go simultanées, tandis que sync.WaitGroup est utilisé pour attendre la fin de toutes les routines. go 和 sync.WaitGroup。go 关键字用于启动并发的 Go 例程，而 sync.WaitGroup 用于等待所有例程完成。

等待组

sync.WaitGroup 是一个计数器，用于跟踪未完成例程的数量。当例程完成时，它会调用 wg.Done() 来递减计数器。主程序可以使用 wg.Wait() 方法来阻塞，直到所有例程完成。

实战案例：并发 Web 请求

考虑一个场景，我们需要并发发送多个 Web 请求并收集响应。以下是演示如何使用 Go 函数进行高效并发任务处理的代码：

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func main() {
    // 要发送的 Web 请求 URL
    urls := []string{"https://example.com", "https://example2.com", "https://example3.com"}

    // 创建等待组
    var wg sync.WaitGroup

    for _, url := range urls {
        // 启动一个并发例程来发送 Web 请求
        wg.Add(1)
        go func(url string) {
            // 发送 GET 请求
            resp, err := http.Get(url)
            if err != nil {
                fmt.Printf("Error getting %s: %v\n", url, err)
            } else {
                fmt.Printf("Status code for %s: %d\n", url, resp.StatusCode)
            }

            // 例程完成，递减等待组计数
            wg.Done()
        }(url)
    }

    // 等待所有例程完成
    wg.Wait()
}

在上面的代码中：

• 我们使用 sync.WaitGroup 来跟踪未完成例程的数量。
• 对于每个 Web 请求 URL，我们启动一个并发的 Go 例程来发送请求。
• 例程使用 wg.Done() 来表示它已完成。
• 主程序使用 wg.Wait()

Wait Group

🎜sync.WaitGroup est un compteur qui garde une trace du nombre de routines en attente. Une fois la routine terminée, elle appelle wg.Done() pour décrémenter le compteur. Le programme principal peut utiliser la méthode wg.Wait() pour bloquer jusqu'à ce que toutes les routines soient terminées. 🎜🎜🎜Cas pratique : requêtes Web simultanées🎜🎜🎜Considérons un scénario dans lequel nous devons envoyer plusieurs requêtes Web simultanément et collecter des réponses. Voici le code qui montre comment utiliser les fonctions Go pour un traitement efficace des tâches simultanées : 🎜rrreee🎜 Dans le code ci-dessus : 🎜

• Nous utilisons sync.WaitGroup pour suivre la quantité de routines en suspens. 🎜
• Pour chaque URL de requête Web, nous démarrons une routine Go simultanée pour envoyer la requête. 🎜
• La routine utilise wg.Done() pour indiquer qu'elle est terminée. 🎜
• Le programme principal utilise wg.Wait() pour bloquer jusqu'à ce que toutes les routines soient terminées. 🎜🎜🎜En utilisant cette méthode, nous pouvons envoyer plusieurs requêtes Web simultanément et continuer à exécuter le programme principal sans attendre la réponse de chaque requête. 🎜

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!