Go中看似简单的WaitGroup源码设计，竟然暗含这么多知识？

 1func main() {
 2    var wg sync.WaitGroup
 3
 4    wg.Add(2) //worker number 2
 5
 6    go func() {
 7        // worker 1 do something
 8        fmt.Println("goroutine 1 done！")
 9        wg.Done()
10    }()
11
12    go func() {
13        // worker 2 do something
14        fmt.Println("goroutine 2 done！")
15        wg.Done()
16    }()
17
18    wg.Wait() // wait all waiter done
19    fmt.Println("all work done！")
20}
21
22// output
23goroutine 2 done！
24goroutine 1 done！
25all work done！

1func (wg *WaitGroup) Add(delta int)  // 增加WaitGroup中的子goroutine计数值
2func (wg *WaitGroup) Done()          // 当子goroutine任务完成，将计数值减1
3func (wg *WaitGroup) Wait()          // 阻塞调用此方法的goroutine，直到计数值为0
4

 1type Ins struct {
 2    x bool  // 1个字节
 3    y int32 // 4个字节
 4    z byte  // 1个字节
 5}
 6
 7func main() {
 8    ins := Ins{}
 9    fmt.Printf("ins size: %d, align: %d\n", unsafe.Sizeof(ins), unsafe.Alignof(ins))
10}
11
12//output
13ins size: 12, align: 4

 1type WaitGroup struct {
 2    noCopy noCopy
 3
 4    // 64-bit value: high 32 bits are counter, low 32 bits are waiter count.
 5    // 64-bit atomic operations require 64-bit alignment, but 32-bit
 6    // compilers do not ensure it. So we allocate 12 bytes and then use
 7    // the aligned 8 bytes in them as state, and the other 4 as storage
 8    // for the sema.
 9    state1 [3]uint32
10}
11
12// state returns pointers to the state and sema fields stored within wg.state1.
13func (wg *WaitGroup) state() (statep *uint64, semap *uint32) {
14  // 64位编译器地址能被8整除，由此可判断是否为64位对齐
15    if uintptr(unsafe.Pointer(&wg.state1))%8 == 0 {
16        return (*uint64)(unsafe.Pointer(&wg.state1)), &wg.state1[2]
17    } else {
18        return (*uint64)(unsafe.Pointer(&wg.state1[1])), &wg.state1[0]
19    }
20}

 1func (wg *WaitGroup) Add(delta int) {
 2  // 获取包含counter与waiter的复合状态statep，表示信号量值的semap
 3    statep, semap := wg.state()
 4    state := atomic.AddUint64(statep, uint64(delta)<<32)
 5    v := int32(state >> 32)
 6    w := uint32(state)
 7
 8    if v < 0 {
 9        panic("sync: negative WaitGroup counter")
10    }
11
12    if w != 0 && delta > 0 && v == int32(delta) {
13        panic("sync: WaitGroup misuse: Add called concurrently with Wait")
14    }
15
16    if v > 0 || w == 0 {
17        return
18    }
19
20    if *statep != state {
21        panic("sync: WaitGroup misuse: Add called concurrently with Wait")
22    }
23
24  // 如果执行到这，一定是 counter=0，waiter>0
25  // 能执行到这，一定是执行了Add(-x)的goroutine
26  // 它的执行，代表所有子goroutine已经完成了任务
27  // 因此，我们需要将复合状态全部归0，并释放掉waiter个数的信号量
28    *statep = 0
29    for ; w != 0; w-- {
30    // 释放信号量，执行一次就将唤醒一个阻塞的waiter
31        runtime_Semrelease(semap, false, 0)
32    }
33}

1     state := atomic.AddUint64(statep, uint64(delta)<<32)  // 新增counter数值delta
2    v := int32(state >> 32)   // 获取counter值
3    w := uint32(state)        // 获取waiter值

 1    // 情况1：这是很低级的错误，counter值不能为负
 2  if v < 0 {
 3        panic("sync: negative WaitGroup counter")
 4    }
 5
 6  // 情况2：misuse引起panic 
 7  // 因为wg其实是可以用复用的，但是下一次复用的基础是需要将所有的状态重置为0才可以
 8    if w != 0 && delta > 0 && v == int32(delta) {
 9        panic("sync: WaitGroup misuse: Add called concurrently with Wait")
10    }
11
12  // 情况3：本次Add操作只负责增加counter值，直接返回即可。
13  // 如果此时counter值大于0，唤醒的操作留给之后的Add调用者（执行Add(negative int)）
14  // 如果waiter值为0，代表此时还没有阻塞的waiter
15    if v > 0 || w == 0 {
16        return
17    }
18
19  // 情况4: misuse引起的panic
20    if *statep != state {
21        panic("sync: WaitGroup misuse: Add called concurrently with Wait")
22    }

1func TestWaitGroupMisuse(t *testing.T)
2func TestWaitGroupMisuse2(t *testing.T)
3func TestWaitGroupMisuse3(t *testing.T)
4

1func (wg *WaitGroup) Done() {
2    wg.Add(-1)
3}

 1func (wg *WaitGroup) Wait() {
 2    statep, semap := wg.state()
 3    for {
 4        state := atomic.LoadUint64(statep) // 原子读取复合状态statep
 5        v := int32(state >> 32)            // 获取counter值
 6        w := uint32(state)                 // 获取waiter值
 7    // 如果此时v==0,证明已经没有待执行任务的子goroutine，直接退出即可。
 8        if v == 0 {
 9            return
10        }
11        // 如果在执行CAS原子操作和读取复合状态之间，没有其他goroutine更改了复合状态
12    // 那么就将waiter值+1，否则：进入下一轮循环，重新读取复合状态
13        if atomic.CompareAndSwapUint64(statep, state, state+1) {
14      // 对waiter值累加成功后
15      // 等待Add函数中调用 runtime_Semrelease 唤醒自己
16            runtime_Semacquire(semap)
17      // reused 引发panic
18      // 在当前goroutine被唤醒时，由于唤醒自己的goroutine通过调用Add方法时
19      // 已经通过 *statep = 0 语句做了重置操作
20      // 此时的复合状态位不为0，就是因为还未等Waiter执行完Wait，WaitGroup就已经发生了复用
21            if *statep != 0 {
22                panic("sync: WaitGroup is reused before previous Wait has returned")
23            }
24            return
25        }
26    }
27}