之前有做過一個需求：要打一個 request 一千萬次，並收集其 response 以供之後流程處理分析

我的第一個版本寫得非常非常純『蠢』

func main() {
	for i := 1; i < 11; i++ {
		go testInsert(grpcClient, "f"+strconv.Itoa(i)+".txt")
	}
	time.Sleep(3600 * time.Second)

}

func testInsert(grpcClient abc.AbcServiceClient, fileName string) {
	aa1 := getResultWrite(grpcClient, "QWERT", 1000000)
	fmt.Println(aa1)

	f, err := os.Create(fileName)

	defer f.Close()

	if err != nil {
		// fmt.Println(err.Error())
	} else {

		_, err = f.Write([]byte(aa1))
		// fmt.Println(err.Error())
	}
}

缺點：我需要自行調整 time.Sleep 的秒數，否則如果睡完後，func main就直接結束， go routine 還沒執行完的話，那本次執行的的任務，收集到的東西會全部消失，浪費 N 分鐘

前輩 W大大 幫我加入了 waiting group 的概念 ...

func main() {
    wg := sync.WaitGroup{}

	for i := 1; i <= 10; i++ {
		wg.Add(1)
		go conn.testInsert("f"+strconv.Itoa(i)+".txt", &wg)
	}
	wg.Wait()
}

func (conn *Conn) testInsert(fileName string, wg *sync.WaitGroup) {
	aa1 := conn.getResultWrite(conn.param, conn.fileSize)
	// fmt.Println(aa1)

	f, err := os.Create(fileName)
	defer func() {
		f.Close()
		wg.Done()
	}()

	if err != nil {
		fmt.Println(err.Error())
	} else {
		_, err = f.Write([]byte(aa1))
		// fmt.Println(err.Error())
	}
}

func (wg *WaitGroup) Add(delta int)

Add adds delta, which may be negative, to the WaitGroup counter. If the counter becomes zero, all goroutines blocked on Wait are released. If the counter goes negative, Add panics.

https://pkg.go.dev/sync#WaitGroup.Add
delta 只能為正，負的會 panic
增加可以本 wg 等待的 goroutine 數

func (wg *WaitGroup) Wait()

Wait blocks until the WaitGroup counter is zero.

https://pkg.go.dev/sync#WaitGroup.Wait
阻塞他，堵住，等所有 goroutine 回來

func (wg *WaitGroup) Done()

Done decrements the WaitGroup counter by one.

https://pkg.go.dev/sync#WaitGroup.Done
告知一個 goroutine 已完成

加上 waiting group 的概念可以讓工作變得更加活，也不需要自己去調整到底需要幾秒鐘來讓所有的 goroutine 都完成

讓 code 變得更加聰明