Programmation simultanée efficace : conseils pratiques pour l'utilisation de Golang WaitGroup

Programmation simultanée efficace : compétences pratiques avec Golang WaitGroup

Introduction : Dans le domaine du développement logiciel actuel, la programmation simultanée est une compétence très importante. En tant que langage de programmation hautes performances, Golang fournit de riches mécanismes et outils de programmation simultanée. Parmi eux, WaitGroup est un outil très pratique pour la synchronisation des threads dans Golang. Dans cet article, nous explorerons comment utiliser WaitGroup pour une programmation simultanée efficace et fournirons des exemples de code pratiques.

1. Comprendre WaitGroup

Avant de commencer, comprenons d'abord ce qu'est WaitGroup. WaitGroup est une primitive de concurrence dans Golang qui peut être utilisée pour attendre qu'un groupe de goroutines termine des tâches. En termes simples, WaitGroup peut nous aider à passer à l'étape suivante une fois que toutes les goroutines ont terminé leurs tâches.

2. Méthodes de base d'utilisation de WaitGroup

Il existe trois méthodes de base d'utilisation de WaitGroup : Ajouter, Terminé et Attendre.

1. Méthode Add : utilisée pour indiquer à WaitGroup combien de goroutines nous devons encore attendre. Le paramètre de la méthode Add est de type int, indiquant le nombre de goroutines en attente.
2. Méthode Done : utilisée pour indiquer à WaitGroup qu'une goroutine a terminé sa tâche. Chaque fois que la méthode Done est appelée, le nombre de goroutines en attente sera réduit de un.
3. Méthode d'attente : utilisée pour attendre que toutes les goroutines terminent leurs tâches. Lorsque le nombre de goroutines en attente est réduit à 0, la méthode Wait reviendra.

3. Compétences pratiques

Ensuite, nous utiliserons un exemple de code réel pour démontrer comment utiliser WaitGroup pour une programmation simultanée efficace.

Exemple 1 : tâches simultanées simples

Supposons que nous ayons une liste de tâches, que nous devions exécuter des tâches en parallèle et que nous attendions que toutes les tâches soient exécutées pour imprimer les résultats. Cette fonction peut être facilement implémentée à l'aide de WaitGroup.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    tasks := []string{"task1", "task2", "task3", "task4"}

    for _, t := range tasks {
        wg.Add(1)
        go func(task string) {
            defer wg.Done()

            // 执行任务，这里假设执行耗时为1秒
            // ...

            fmt.Printf("任务 %s 执行完毕
", task)
        }(t)
    }

    wg.Wait()

    fmt.Println("所有任务执行完毕！")
}

Dans l'exemple ci-dessus, nous avons d'abord créé une instance WaitGroup wg. Ensuite, en parcourant la liste des tâches, utilisez la méthode Add pour indiquer au WaitGroup qu'il y a une goroutine à attendre. Ensuite, nous démarrons une coroutine pour exécuter la tâche et utilisons la méthode Done pour indiquer au WaitGroup que la goroutine est terminée après l'exécution de la tâche. Enfin, appelez la méthode Wait pour attendre que toutes les goroutines terminent leur exécution.

Exemple 2 : Téléchargements simultanés

Dans cet exemple, nous devons télécharger plusieurs fichiers en même temps et regrouper les résultats une fois tous les fichiers téléchargés. Cette fonction peut être facilement implémentée à l'aide de WaitGroup.

package main

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

func main() {
    var wg sync.WaitGroup

    urls := []string{"http://example.com/file1.txt", "http://example.com/file2.txt", "http://example.com/file3.txt"}

    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()

            resp, err := http.Get(url)
            if err != nil {
                fmt.Printf("下载 %s 失败：%s
", url, err.Error())
                return
            }

            defer resp.Body.Close()

            body, err := ioutil.ReadAll(resp.Body)
            if err != nil {
                fmt.Printf("读取 %s 内容失败：%s
", url, err.Error())
                return
            }

            fmt.Printf("下载 %s 完成，文件大小：%d 字节
", url, len(body))
        }(url)
    }

    wg.Wait()

    fmt.Println("所有文件下载完成！")
}

Dans l'exemple ci-dessus, nous utilisons également WaitGroup pour implémenter des téléchargements simultanés. En parcourant la liste d'adresses de téléchargement, utilisez la méthode Add pour indiquer au WaitGroup qu'il y a une goroutine à attendre. Dans chaque goroutine, nous utilisons le package http pour envoyer une requête GET et obtenir le contenu du fichier. Enfin, utilisez la méthode Done pour indiquer au WaitGroup que la goroutine est terminée. Enfin, appelez la méthode Wait pour attendre que toutes les goroutines terminent leur exécution.

Conclusion : cet article explique comment utiliser WaitGroup de Golang pour obtenir une programmation simultanée efficace. En utilisant correctement les méthodes Add, Done et Wait, nous pouvons facilement contrôler le processus d'exécution des tâches simultanées et améliorer les performances et l'efficacité du programme. Lorsque vous écrivez des programmes simultanés, vous pouvez aussi bien essayer d'utiliser WaitGroup pour synchroniser les tâches. Je pense que cela vous apportera beaucoup de commodité et de surprises !

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!