// 示例：Happens-Before關(guān)系
var a string
var done bool
func setup() {
    a = "hello, world"  // 寫操作A
    done = true         // 寫操作B
}
func main() {
    go setup()
    for !done {        // 讀操作C
        // 忙等待
    }
    print(a)           // 讀操作D
}

func main() {
	var mu sync.Mutex
	mu.Lock()
	defer mu.Unlock()
	mu.TryLock()
}

type Mutex struct {
    state int32  // 鎖狀態(tài)：包含多個(gè)標(biāo)志位
    sema  uint32 // 信號(hào)量：用于阻塞goroutine
}

func (m *Mutex) Lock() {
    // 快速路徑：嘗試原子操作獲取鎖
    if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
        return
    }
    // 慢速路徑：鎖已被持有，需要等待
    m.lockSlow()
}

func (rw *RWMutex) Lock() {
    // 1. 獲取互斥鎖
    rw.w.Lock()
    // 2. 設(shè)置readerCount為負(fù)值，阻止新讀者
    r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders)
    // 3. 等待現(xiàn)有讀者
    if r != 0 {
        runtime_Semacquire(&rw.writerSem)
    }
}
func (rw *RWMutex) RLock() {
    // 檢查是否有寫者（readerCount < 0表示有寫者）
    if atomic.AddInt32(&rw.readerCount, 1) < 0 {
        // 有寫者在等待或正在寫，讀者必須阻塞
        runtime_Semacquire(&rw.readerSem)
    }
}

func main() {
	var wg sync.WaitGroup
	wg.Add(1) // 增加一個(gè)等待者
	go func() {
		defer wg.Done()
		// 執(zhí)行邏輯, 邏輯執(zhí)行完之后, 等待者數(shù)量-1
	}()
	wg.Wait() // 等待所有等待者執(zhí)行完成
}

type WaitGroup struct {
    noCopy noCopy
    // 64位值的高32位是計(jì)數(shù)器，低32位是等待者數(shù)量
    // 64位原子操作需要64位對(duì)齊，但32位編譯器不能確保這一點(diǎn)
    state atomic.Uint64 // high 32 bits are counter, low 32 bits are waiter count.
}

// WaitGroup狀態(tài)布局（64位）
// 高32位：計(jì)數(shù)器 (counter)
// 低32位：等待者數(shù)量 (waiters)
func (wg *WaitGroup) Add(delta int) {
    statep, semap := wg.state()
    // 更新計(jì)數(shù)器
    state := atomic.AddUint64(statep, uint64(delta)<<32)
    // 檢查狀態(tài)變化
    v := int32(state >> 32)  // 計(jì)數(shù)器
    w := uint32(state)       // 等待者數(shù)量
    if v > 0 || w == 0 {
        return // 還有工作要做，或者沒(méi)有等待者
    }
    // 所有工作完成，喚醒等待者
    if *statep != 0 {
        panic("sync: WaitGroup misuse")
    }
    // 喚醒所有等待的goroutine
    for ; w != 0; w-- {
        runtime_Semrelease(semap, false, 0)
    }
}

func main() {
	once := sync.Once{}
	once.Do(func() {
		// 這里的邏輯只會(huì)執(zhí)行一次
	})
}

func (o *Once) Do(f func()) {
	if o.done.Load() == 0 {
		o.doSlow(f)
	}
}
func (o *Once) doSlow(f func()) {
	o.m.Lock()
	defer o.m.Unlock()
	if o.done.Load() == 0 {
		defer o.done.Store(1)
		f()
	}
}

func main() {
	cond := sync.NewCond(new(sync.Mutex))
	done := false
	read := func(name string, c *sync.Cond) {
		c.L.Lock()
		if !done {
			c.Wait()
		}
		fmt.Println("start reading: ", name)
		c.L.Unlock()
	}
	write := func(name string, c *sync.Cond) {
		fmt.Println("start writing: ", name)
		c.L.Lock()
		done = true
		c.L.Unlock()
		fmt.Println("wakes all:", name)
		c.Signal()
	}
	go read("read3", cond)
	go read("read1", cond)
	go read("read2", cond)
	write("write1", cond)
	time.Sleep(5 * time.Second)
}

// 頻繁分配和回收的典型特征
func frequentAllocation() {
    pool := sync.Pool{
        New: func() interface{} {
            return make([]byte, 1024)
        },
    }
    // 在循環(huán)中重復(fù)創(chuàng)建和銷毀對(duì)象
    for i := 0; i < 1000; i++ {
        // 分配：創(chuàng)建新對(duì)象
        // buf := make([]byte, 1024)  // 直接分配內(nèi)存
        buf := pool.Get().([]byte) // 使用對(duì)象池
        // 使用對(duì)象
        copy(buf, data[i])
        process(buf)
        // 回收：對(duì)象超出作用域，被GC回收
        pool.Put(buf[:0]) // 歸還對(duì)象（清空）
    }
    // 每次循環(huán)都經(jīng)歷：分配→使用→回收
}