waitGroup并发场景应用案例

案例1

下面是一个使用waitGroup的案例，它演示了如何使用多个goroutine执行并发任务，并等待所有任务完成后再继续执行主线程：

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup

	// 模拟需要执行的任务数量
	taskCount := 10

	// 向waitGroup中添加任务数量
	wg.Add(taskCount)

	// 启动多个goroutine执行任务
	for i := 0; i < taskCount; i++ {
		gofunc(index int) {
			fmt.Printf("开始执行任务%d\n", index)

			// 模拟任务执行时间
			time.Sleep(1 * time.Second)

			fmt.Printf("任务%d执行完毕\n", index)

			// 标记任务已完成
			wg.Done()
		}(i)
	}

	// 等待所有任务完成
	wg.Wait()

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

在上面的代码中，我们创建了一个waitGroup，并向其中添加了需要执行的任务数量。然后我们启动了多个goroutine执行这些任务，每个goroutine完成任务后都会调用waitGroup的Done()方法，表示任务已经完成。在主线程中，我们使用waitGroup的Wait()方法等待所有任务完成后再继续执行主线程。

输出结果如下：

开始执行任务0
开始执行任务1
开始执行任务2
开始执行任务3
开始执行任务4
开始执行任务5
开始执行任务6
开始执行任务7
开始执行任务8
开始执行任务9
任务0执行完毕
任务6执行完毕
任务7执行完毕
任务1执行完毕
任务4执行完毕
任务8执行完毕
任务9执行完毕
任务2执行完毕
任务5执行完毕
任务3执行完毕
所有任务执行完毕

在输出结果中，我们可以看到所有任务都被正确地执行，并且最后输出了“所有任务执行完毕”的信息。这个案例展示了如何使用waitGroup实现并发任务的等待，以及如何确保所有任务完成后再继续执行主线程

案例2 请求多个HTTP接口

在Golang的并发编程中，经常需要同时请求多个HTTP接口，然后将它们返回的数据组合起来使用，这个过程可以通过waitGroup实现。

waitGroup是Golang中一种非常有用的并发组件，可以帮助我们控制多个goroutine的执行顺序和等待。

下面是一个使用waitGroup请求多个HTTP接口，并将它们返回的数据组合起来的示例代码：

package main

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

type Response struct {
	ID      int`json:"id"`
	Name    string`json:"name"`
	Company string`json:"company"`
}

func main() {
	var wg sync.WaitGroup
	wg.Add(3)

	responses := make([]Response, 3)

	go func() {
		defer wg.Done()
		response, err := http.Get("https://jsonplaceholder.typicode.com/users/1")
		if err != nil {
			fmt.Println(err)
			return
		}

		data, err := ioutil.ReadAll(response.Body)
		if err != nil {
			fmt.Println(err)
			return
		}

		err = json.Unmarshal(data, &responses[0])
		if err != nil {
			fmt.Println(err)
			return
		}
	}()

	go func() {
		defer wg.Done()
		response, err := http.Get("https://jsonplaceholder.typicode.com/users/2")
		if err != nil {
			fmt.Println(err)
			return
		}

		data, err := ioutil.ReadAll(response.Body)
		if err != nil {
			fmt.Println(err)
			return
		}

		err = json.Unmarshal(data, &responses[1])
		if err != nil {
			fmt.Println(err)
			return
		}
	}()

	go func() {
		defer wg.Done()
		response, err := http.Get("https://jsonplaceholder.typicode.com/users/3")
		if err != nil {
			fmt.Println(err)
			return
		}

		data, err := ioutil.ReadAll(response.Body)
		if err != nil {
			fmt.Println(err)
			return
		}

		err = json.Unmarshal(data, &responses[2])
		if err != nil {
			fmt.Println(err)
			return
		}
	}()

	wg.Wait()

	fmt.Println(responses)
}

在这个示例中，我们首先创建了一个waitGroup，并使用Add方法将计数器设置为3，表示需要等待三个goroutine执行完成。

接着，我们创建了三个goroutine，并在其中发起HTTP请求获取数据，并将数据解析为Response结构体，最后将其保存到一个切片中。

每个goroutine执行完成后，都会调用waitGroup的Done方法，表示自己已经完成了执行。

在最后，我们调用waitGroup的Wait方法，等待所有的goroutine执行完成后，再将数据打印出来。

通过waitGroup，我们可以很方便地实现多个goroutine的同步和控制。同时，我们也可以使用select和chan等其他并发组件来实现类似的效果，具体的使用方法需要根据具体的场景和需求来确定