Tutoriel de base : Go WaitGroup et son application dans Golang

Tutoriel de base : Go WaitGroup et son application en Golang, des exemples de code spécifiques sont requis

Avant-propos :
En Golang (langage Go), écrire des programmes concurrents est une tâche courante. Golang fournit une multitude de primitives et d'API de concurrence, l'un des outils importants étant WaitGroup. Cet article vous présentera le concept et l'utilisation de WaitGroup et fournira quelques exemples de code spécifiques.

1. Le concept de WaitGroup
WaitGroup est une primitive de concurrence dans Golang, qui est utilisée pour attendre la fin d'un groupe de goroutines. WaitGroup gère un compteur en interne, avec une valeur initiale de 0. Lorsque chaque coroutine commence à s'exécuter, le compteur est incrémenté de 1. À la fin de la coroutine, le compteur sera décrémenté de 1. Le thread principal peut bloquer la méthode Wait() jusqu'à ce que le compteur atteigne 0, c'est-à-dire que toutes les coroutines soient exécutées.

2. Utilisation de base de WaitGroup
Pour utiliser WaitGroup, vous devez suivre les étapes suivantes :

1. Créer un objet WaitGroup : Tout d'abord, nous devons importer le package "sync" et créer un objet WaitGroup.

   import "sync"
   
   var wg sync.WaitGroup

2. Ajouter une coroutine à WaitGroup : pour chaque coroutine à exécuter, nous devons incrémenter le compteur et utiliser le mot-clé go pour effectuer la tâche dans la nouvelle coroutine.

   wg.Add(1)
   go func() {
    // 协程的具体逻辑
    // ...
    wg.Done() // 协程执行完成后减少计数器
   }()

3. Attente de la fin des coroutines : le thread principal peut utiliser la méthode Wait() pour bloquer jusqu'à ce que le compteur soit à 0, c'est-à-dire que toutes les coroutines aient été exécutées.

   wg.Wait()

Exemple de code :
Ce qui suit est un exemple de code spécifique qui démontre l'application de WaitGroup dans Golang. Cet exemple utilise WaitGroup pour attendre la fin de plusieurs coroutines avant de poursuivre la logique suivante.

package main
 
import (
    "fmt"
    "sync"
    "time"
)
 
func main() {
    var wg sync.WaitGroup
 
    for i := 0; i < 5; i++ {
        wg.Add(1)
 
        go func(num int) {
            defer wg.Done()
            time.Sleep(time.Second) // 模拟长时间的任务
 
            fmt.Printf("协程 %d 完成
", num)
        }(i)
    }
 
    fmt.Println("等待所有协程完成...")
    wg.Wait()
    fmt.Println("所有协程已完成！")
}

Dans l'exemple ci-dessus, nous avons simulé l'exécution de 5 coroutines, et chaque coroutine a attendu 1 seconde. Avec WaitGroup, le thread principal se bloque jusqu'à ce que toutes les coroutines soient exécutées. Dans le résultat, nous pouvons voir que l'ordre dans lequel les coroutines se terminent n'est pas fixe car elles sont exécutées en parallèle.

3. Précautions pour WaitGroup
Lors de l'utilisation de WaitGroup, vous devez suivre les précautions suivantes :

1. Avant d'appeler Wait(), Done() doit être appelé dans chaque coroutine pour s'assurer que le compteur est décrémenté. Sinon, le thread principal se bloquera pour toujours.
2. WaitGroup est passé par valeur, donc lors du passage dans une fonction ou une méthode, assurez-vous de transmettre un pointeur, pas une copie de la valeur.
3. N'utilisez pas plusieurs objets WaitGroup pour s'attendre, cela entraînerait un blocage.

Conclusion :
WaitGroup est une primitive de concurrence très utile dans Golang, qui peut facilement attendre la fin d'un groupe de coroutines. Cet article présente les concepts de base et l'utilisation de WaitGroup et fournit un exemple de code spécifique. J'espère que l'étude de cet article pourra vous aider à mieux comprendre et appliquer l'utilisation de WaitGroup dans Golang.

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!