sync.WaitGroup est une structure de données très courante dans un environnement concurrent, utilisée pour attendre la fin de toutes les coroutines. Lors de l'écriture du code, appuyez sur C'est écrit comme. un exemple, et il n'est pas nécessaire d'approfondir son utilisation. Il y a quelques jours, je me demandais si je pouvais exécuter la fonction Add() dans une coroutine. La réponse est non. Voici une introduction. sync.WaitGroup是并发环境中，一个相当常用的数据结构，用来等待所有协程的结束，在写代码的时候都是按着例子的样子写的，也没用深究过它的使用。前几日想着能不能在协程中执行Add()函数，答案是不能，这里介绍下。
陷阱在WaitGroup的3个函数的调用顺序上。先回顾下3个函数的功能：
-
Add(delta int)：给计数器增加delta，比如启动1个协程就增加1。 -
Done()：协程退出前执行，把计数器减1。 -
Wait()：阻塞等待计数器为0。
考一考
下面的程序是创建了协程father，然后father协程创建了10个子协程，main函数等待所有协程结束后退出，看看下面代码有没有什么问题？
package main
import (
"fmt"
"sync"
)
func father(wg *sync.WaitGroup) {
wg.Add(1)
defer wg.Done()
fmt.Printf("father\n")
for i := 0; i < 10; i++ {
go child(wg, i)
}
}
func child(wg *sync.WaitGroup, id int) {
wg.Add(1)
defer wg.Done()
fmt.Printf("child [%d]\n", id)
}
func main() {
var wg sync.WaitGroup
go father(&wg)
wg.Wait()
log.Printf("main: father and all chindren exit")
}发现问题了吗？如果没有看下面的运行结果：main函数在子协程结束前就开始结束了。
father main: father and all chindren exit child [9] child [0] child [4] child [7] child [8]
陷阱分析
产生以上问题的原因在于，创建协程后在协程内才执行Add()函数，而此时Wait()函数可能已经在执行，甚至Wait()函数在所有Add()执行前就执行了，Wait()
-
Add(delta int) : ajoutez du delta au compteur, par exemple, lors du démarrage d'une coroutine, augmentez-le de 1.
-
Done() : exécuté avant la sortie de la coroutine, décrémentant le compteur de 1.
-
Wait() : Le compteur d'attente bloquante est 0.
Faites un testAdd(delta int) : ajoutez du delta au compteur, par exemple, lors du démarrage d'une coroutine, augmentez-le de 1. Done() : exécuté avant la sortie de la coroutine, décrémentant le compteur de 1. Wait() : Le compteur d'attente bloquante est 0. Le programme suivant crée la coroutine père, puis la coroutine père crée 10 sous-coroutines. La fonction principale attend que toutes les coroutines se terminent, puis se termine. ci-dessous. Pas de problème ?
package main
import (
"fmt"
"sync"
)
func father(wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("father\n")
for i := 0; i < 10; i++ {
wg.Add(1)
go child(wg, i)
}
}
func child(wg *sync.WaitGroup, id int) {
defer wg.Done()
fmt.Printf("child [%d]\n", id)
}
func main() {
var wg sync.WaitGroup
wg.Add(1)
go father(&wg)
wg.Wait()
fmt.Println("main: father and all chindren exit")
}father child [9] child [7] child [8] child [1] child [4] child [5] child [2] child [6] child [0] child [3] main: father and all chindren exit
Add() est exécutée dans la coroutine après la création de la coroutine, et à ce moment le Wait() <p>Peut-être</p> est déjà en cours d'exécution, ou même la fonction <code>Wait() est exécutée avant que tous les Add() ne soient exécutés, et immédiatement lorsque Wait () est exécuté. Il est satisfait que le compteur de WaitGroup est 0, l'attente se termine et le programme principal se termine. Par conséquent, toutes les sous-coroutines ne sont pas complètement terminées et la fonction principale se termine. 
