WaitGroup 剖析

type WaitGroup struct {
  // 嵌入 noCopy 表示该结构不能被复制
  // 不允许通过复制产生一个新的 WaitGroup
  noCopy noCopy


  // 记录调用 Add() 后累加的数目，记作 Counter
  // 记录调用 Wait() 的协程数目，记作 Waiter
  // 记录信号量，用来同步 Add 和 Wait，记作 state
  state1 [3]uint32
}

func (wg *WaitGroup) Done() {
   比较简单，内部调用了 Add
  wg.Add(-1)
}

func (wg *WaitGroup) Add(delta int) {
  // 解析 state1 结构
  // statep: 高32位为 counter 数量
  //         低32位为 waiter 数量
  // semap: 信号，用来同步
  statep, semap := wg.state()
  
  // 由于高 32 位是counter数量，所以加之前左移32位
  state := atomic.AddUint64(statep, uint64(delta)<<32)


  // v: counter 数量
  v := int32(state >> 32)


   w: 调用 Wait() 的协程数量
  w := uint32(state)


  // 不允许 counter 的数量为负数
  if v < 0 {
    panic("sync: negative WaitGroup counter")
  }


   不允许并发调用 Add 和 wait
  if w != 0 && delta > 0 && v == int32(delta) {
    panic("sync: WaitGroup misuse: Add called concurrently with Wait")
  }


  // 调用 Add 发生在调用 Wait 之前
  // 因此正常返回
  if v > 0 || w == 0 {
    return
  }


  // 到此，说明 v=0, w>0, 此时不能并发的修改状态
  // 1. Add 绝对不能和 Wait 并发发生
  // 2. Wait 在 counter=0 的时候，wait 不能增加waiter的数量
  if *statep != state {
    panic("sync: WaitGroup misuse: Add called concurrently with Wait")
  }


  // v=0， w>0，此时说明所有 goroutine 结束了
  // 所有 goroutine 结束后，给 w 发送信号，便于
  // 唤醒因调用 Wait 而阻塞的协程
  *statep = 0


  // 有多少个 Wait 等待，就给出多少个信号量
  // 为的就是喂饱所有的 Wait 保证这些阻塞的
  // Wait 协程能够正常解除
  for ; w != 0; w-- {
    // 增加 sema 资源，每调用一次 +1
    runtime_Semrelease(semap, false, 0)
  }
}

// Wait blocks until the WaitGroup counter is zero.
func (wg *WaitGroup) Wait() {
  // statep: 计数器，高32位，协程任务数目; 低32位 wait 数目
  statep, semap := wg.state()


  for {
    // 读取当前 wainter 和 counter 的值
    state := atomic.LoadUint64(statep)


    // v 计数器，也就是协程数量
    v := int32(state >> 32)


    // w 调用了Wait() 的协程数量
    w := uint32(state)


    // counter 为 0，说明没有 Add 的情况下直接调用了
    // Wait, 此时直接返回，不需要阻塞等待
    if v == 0 {       
      return
    }


    // 原子操作，增加 wait() 数量
    if atomic.CompareAndSwapUint64(statep, state, state+1) {
      // 阻塞等待信号量，当观察到 semap > 0
      // 是立马对 semap-1，然后返回
      runtime_Semacquire(semap)


      // 解除阻塞    
      // wait 返回之后，如果发现 counter 数不为 0，说明wg
      // 被重用了，就是说 Wait 刚从阻塞中唤醒，唤醒是因为
      // 之前 Add 过的协程都 Done了，结束了，此时 counter应当
      // 为 0，但是此刻又有其它协程在此 wg 上调用了 Add
      if *statep != 0 {
        panic("sync: WaitGroup is reused before previous Wait has returned")
      }
      return
    }
  }
}