package main

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

type Task struct {
	ID   int
	Name string
}

func main() {
	tasks := make([]*Task, 0)

	// 添加 5 个任务
	for i := 1; i <= 5; i++ {
		tasks = append(tasks, &Task{
			ID:   i,
			Name: strconv.Itoa(i),
		})
	}

	var wg sync.WaitGroup

	// 开启多个 goroutine 并行执行任务
	for _, task := range tasks {
		wg.Add(1)

		go func(t *Task) {
			defer wg.Done() // 任务完成

			fmt.Printf("Task %s starting ...\n", t.Name)

			time.Sleep(300 * time.Millisecond) // 模拟任务执行耗时
		}(task)
	}

	wg.Wait() // 等待所有任务执行结束
}

$ go run main.go

# 输出如下
Task 5 starting ...
Task 1 starting ...
Task 4 starting ...
Task 3 starting ...
Task 2 starting ...

// WaitGroup 一旦使用后，就不能再复制
type WaitGroup struct {
	noCopy noCopy // 保证编译期间不会发生复制
	
	state1 uint64
	state2 uint32
}

func (wg *WaitGroup) state() (statep *uint64, semap *uint32) {
	// 判断 state1 字段是否按照 64 位对齐
	if unsafe.Alignof(wg.state1) == 8 || uintptr(unsafe.Pointer(&wg.state1))%8 == 0 {
		// 如果 state1 字段是 64 位对齐，直接返回
		return &wg.state1, &wg.state2
	} else {
		// 如果 state1 是 32 位而非 64 位对齐
		// 这意味着 (&state1)+4 是 64 位对齐 (state1 字段 + 4， 正好是 state2 字段)
		// (&state1)+4 等于跨了两个字段，所以是 64 位对齐 (两个字段的内存是连续的)
		// 最后把两个字段地址进行连接，在连接的基础上实现地址交换
		state := (*[3]uint32)(unsafe.Pointer(&wg.state1))
		return (*uint64)(unsafe.Pointer(&state[1])), &state[0]
	}
}

func (wg *WaitGroup) Add(delta int) {
	statep, semap := wg.state() // 调用 state() 取出计数器和信号量
	
    ...
	
	state := atomic.AddUint64(statep, uint64(delta)<<32) // 增加计数器的值 
	v := int32(state >> 32) // 获取计数器的值 (高位字节)
	w := uint32(state)  // 获取等待者的值 (低位字节)
	
	...
	
	if v < 0 {
        // 计数器不能为负数 (出现了 BUG)
		panic("sync: negative WaitGroup counter")
	}
	
	// 等待者不等于 0, 说明已经有 goroutine 调用了 Wait 方法
	// 此时不允许再调用 Add 方法了 (参考规则 4)
	if w != 0 && delta > 0 && v == int32(delta) {
		panic("sync: WaitGroup misuse: Add called concurrently with Wait")
	}
	
	if v > 0 || w == 0 {
        // 如果计数器大于 0 或者没有等待者，直接返回
		return
	}
	
	// 当等待者大于 0 并且计数器等于 0 (所有 goroutine 都调用了 Done 方法表示其结束执行)
	// 重置计数器和等待者为 0
	*statep = 0
	// 唤醒所有等待者 (逐个阻塞调用)
	for ; w != 0; w-- {
		runtime_Semrelease(semap, false, 0)
	}
}

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

func (wg *WaitGroup) Wait() {
	statep, semap := wg.state() // 调用 state() 取出计数器和信号量

	...
	    
	for {
		state := atomic.LoadUint64(statep)
        v := int32(state >> 32) // 获取计数器的值 (高位字节)
        w := uint32(state)  // 获取等待者的值 (低位字节)
		if v == 0 {
			// 计数器等于 0，直接返回
			return
		}
		
		// 计数器不等于 0，说明存在并发
		// 增加等待者的值
		if atomic.CompareAndSwapUint64(statep, state, state+1) {
            ...
			
			// 休眠当前 goroutine 等待唤醒
			runtime_Semacquire(semap)
			if *statep != 0 {
				// 等待者不等于 0, 说明 WaitGroup 对象被重复使用了 (参考规则 4)
				panic("sync: WaitGroup is reused before previous Wait has returned")
			}
			
            ...
			
			return
		}
	}
}

type noCopy struct{}

func (*noCopy) Lock()   {}
func (*noCopy) Unlock() {}