func Main() {

    wg := sync.WaitGroup{}

    for i := ; i < ; i++ {

        wg.Add()

        go func() {

            defer wg.Done()

            time.Sleep( * time.Second)

        }()

    }

    wg.Wait() // 等待在此，等所有go func里都执行了Done()才会退出

}

func main() {

  wg := sync.WaitGroup{}

  for i := ; i < ; i++ {

    wg.Add()

    go func() {

      defer wg.Done()

​    }()

  }

  time.Sleep( * time.Second)

  for j := ; j < ; j++ {

    go func(i int) {

      // 3个地方调用Wait()，通过等待j计时器，每个Wati都会被hu唤醒

      wg.Wait()

      fmt.Println("wait done now ", i)

    }(j)

  }

  time.Sleep( * time.Second)

  return

}

/*

输出如下，数字出现的顺序随机

wait done now  1

wait done now  0

wait done now  2

*/

func (wg *WaitGroup) Add(delta int) {

    statep := wg.state()

    // 更新statep，statep将在wait和add中通过原子操作一起使用

    state := atomic.AddUint64(statep, uint64(delta)<<)

    v := int32(state >> )

    w := uint32(state)

        if v <  {

        panic("sync: negative WaitGroup counter")

    }

    if w !=  && delta >  && v == int32(delta) {

        // wait不等于0说明已经执行了Wait，此时不容许Add

        panic("sync: WaitGroup misuse: Add called concurrently with Wait")

    }

    // 正常情况，Add会让v增加，Done会让v减少，如果没有全部Done掉，此处v总是会大于0的，直到v为0才往下走

    // 而w代表是有多少个goruntine在等待done的信号，wait中通过compareAndSwap对这个w进行加1

     if v >  || w ==  {

        return

    }

    // This goroutine has set counter to 0 when waiters > 0.

    // Now there can't be concurrent mutations of state:

    // - Adds must not happen concurrently with Wait,

    // - Wait does not increment waiters if it sees counter == 0.

    // Still do a cheap sanity check to detect WaitGroup misuse.

    // 当v为0(Done掉了所有)或者w不为0(已经开始等待)才会到这里，但是在这个过程中又有一次Add，导致statep变化，panic

    if *statep != state {

        panic("sync: WaitGroup misuse: Add called concurrently with Wait")

    }

    // Reset waiters count to 0.

    // 将statep清0，在Wait中通过这个值来保护信号量发出后还对这个Waitgroup进行操作

    *statep =

    // 将信号量发出，触发wait结束

    for ; w != ; w-- {

        runtime_Semrelease(&wg.sema, false)

    }

}

// Done decrements the WaitGroup counter by one.

func (wg *WaitGroup) Done() {

    wg.Add(-)

}

// Wait blocks until the WaitGroup counter is zero.

func (wg *WaitGroup) Wait() {

    statep := wg.state()

        for {

        state := atomic.LoadUint64(statep)

        v := int32(state >> )

        w := uint32(state)

        if v ==  {

            // Counter is 0, no need to wait.

            if race.Enabled {

                race.Enable()

                race.Acquire(unsafe.Pointer(wg))

            }

            return

        }

        // Increment waiters count.

        // 如果statep和state相等，则增加等待计数，同时进入if等待信号量

        // 此处做CAS，主要是防止多个goroutine里进行Wait()操作，每有一个goroutine进行了wait，等待计数就加1

        // 如果这里不相等，说明statep，在 从读出来 到 CAS比较 的这个时间区间内，被别的goroutine改写了，那么不进入if，回去再读一次，这样写避免用锁，更高效些

        if atomic.CompareAndSwapUint64(statep, state, state+) {

            if race.Enabled && w ==  {

                // Wait must be synchronized with the first Add.

                // Need to model this is as a write to race with the read in Add.

                // As a consequence, can do the write only for the first waiter,

                // otherwise concurrent Waits will race with each other.

                race.Write(unsafe.Pointer(&wg.sema))

            }

            // 等待信号量

            runtime_Semacquire(&wg.sema)

            // 信号量来了，代表所有Add都已经Done

            if *statep !=  {

                // 走到这里，说明在所有Add都已经Done后，触发信号量后，又被执行了Add

                panic("sync: WaitGroup is reused before previous Wait has returned")

            }

            return

        }

    }

}