Go语言并发之WaitGroup

1、Go语言并发之WaitGroup

goroutine 和 chan，一个用于并发，另一个用于通信。没有缓冲的通道具有同步的功能，除此之外，sync 包也提

供了多个 goroutine 同步的机制，主要是通过 WaitGroup 实现的。

WaitGroup 用来等待多个 goroutine 完成，main goroutine 调用 Add 设置需要等待 goroutine 的数目，每一个

goroutine 结束时调用 Done()，Wait() 被 main 用来等待所有的 goroutine 完成。

主要数据结构和操作如下：

type WaitGroup struct {
	// contains filtered or unexported fields
}

// 添加等待信号
func (wg*WaitGroup) Add (delta int)

// 释放等待信号
func (wg*WaitGroup) Done()

// 等待
func (wg*WaitGroup) Wait()

下面的程序演示如何使用 sync.WaitGroup 完成多个 goroutine 之间的协同工作。

package main

import (
	"net/http"
	"sync"
)

var wg sync.WaitGroup

var urls = []string{
	"https://news.sina.com.cn/",
	"https://www.bilibili.com/",
	"https://www.qq.com/",
}

func main() {
	for _, url := range urls {
		//每一个url启动一个goroutine，同时给wg加1
		wg.Add(1)
		// 启动一个goroutine获取URL
		go func(url string) {
			// 当前goroutine结束后给wg计数减1 ,wg.Done()等价于wg.Add(-1)
			// defer wg.Add(-1)
			defer wg.Done()
			// 发送http get请求并打印http返回码
			resp, err := http.Get(url)
			if err == nil {
				println(resp.Status)
			}
		}(url)
	}
	// 等待所有HTTP获取完成
	wg.Wait()
}

# 输出
501 Not Implemented
200 OK
200 OK

1.1 不加锁

多线程中使用睡眠函数不优雅，直接用 sync.WaitGroup 保证一个 goroutine 刚退出就可以继续执行，不需要自

己猜需要 sleep 多久。

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func main() {
	// 启动一个goroutine就登记+1,启动十个就+10
	wg.Add(10)
	var count = 0
	for i := 0; i < 10; i++ {
		go func() {
			// goroutine结束就登记-1
			defer wg.Done()
			for j := 0; j < 100000; j++ {
				count++
			}
		}()
	}
	// 等待所有登记的goroutine都结束
	wg.Wait()
	// 346730
	fmt.Print(count)
}

启动十个goroutine对count自增10w次，理想状况为100w，但由于没有锁，会出现实际情况远远小于并且不相等

的情况。为什么会出现这样的结果？因为自增并不是一个原子操作，很可能几个goroutine同时读到同一个数，自

增，又将同样的数写了回去。

1.2 互斥锁

1.2.1 直接使用锁

共享资源是count变量，临界区是count++，临界区之前加锁，使其他goroutine在临界区阻塞，离开临界区解

锁，就可以解决这个 data race 的问题。go语言是通过 sync.Mutex 实现这一功能。

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func main() {
	// 定义锁
	var mu sync.Mutex
	wg.Add(10)
	var count = 0
	for i := 0; i < 10; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < 100000; j++ {
				// 加锁
				mu.Lock()
				count++
				// 解锁
				mu.Unlock()
			}
		}()
	}
	wg.Wait()
	// 1000000
	fmt.Print(count)
}

1.2.2 嵌入字段方式使用锁

把 Mutex 嵌入 struct，可以直接在这个 struct 上使用 Lock/Unlock。

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

type Counter struct {
	sync.Mutex
	Count uint64
}

func main() {
	var counter Counter
	wg.Add(10)
	for i := 0; i < 10; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < 100000; j++ {
				counter.Lock()
				counter.Count++
				counter.Unlock()
			}
		}()
	}
	wg.Wait()
	// 1000000
	fmt.Print(counter.Count)
}

1.2.3 把加/解锁封装成方法

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

type Counter struct {
	mu    sync.Mutex
	count uint64
}

func (c *Counter) Incr() {
	c.mu.Lock()
	c.count++
	c.mu.Unlock()
}

func (c *Counter) Count() uint64 {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.count
}

func main() {
	var counter Counter
	// 启动一个goroutine就登记+1,启动十个就+10
	wg.Add(10)
	for i := 0; i < 10; i++ {
		go func() {
			// goroutine结束就登记-1
			defer wg.Done()
			for j := 0; j < 100000; j++ {
				counter.Incr()
			}
		}()
	}
	// 等待所有登记的goroutine都结束
	wg.Wait()
	// 1000000
	fmt.Print(counter.Count())
}