type Cond struct {
    L Locker          // 關(guān)聯(lián)的互斥鎖
    notify  notifyList // 通知隊(duì)列
    checker copyChecker // 防止復(fù)制檢查
}

cond := sync.NewCond(&sync.Mutex{})

// 等待方
cond.L.Lock()
for !condition {
    cond.Wait() // 原子解鎖并掛起
}
// 執(zhí)行操作
cond.L.Unlock()

// 通知方
cond.L.Lock()
// 改變條件
cond.Signal() // 或 cond.Broadcast()
cond.L.Unlock()

// runtime/sema.go

// Signal實(shí)現(xiàn)
func notifyListNotifyOne(l *notifyList) {
    // 從等待隊(duì)列頭部取出一個(gè)goroutine
    s := l.head
    if s != nil {
        l.head = s.next
        if l.head == nil {
            l.tail = nil
        }
        // 喚醒該goroutine
        readyWithTime(s, 4)
    }
}

// Broadcast實(shí)現(xiàn)
func notifyListNotifyAll(l *notifyList) {
    // 取出整個(gè)等待隊(duì)列
    s := l.head
    l.head = nil
    l.tail = nil

    // 逆序喚醒所有g(shù)oroutine（避免優(yōu)先級(jí)反轉(zhuǎn)）
    var next *sudog
    for s != nil {
        next = s.next
        s.next = nil
        readyWithTime(s, 4)
        s = next
    }
}

type TaskDispatcher struct {
    cond  *sync.Cond
    tasks []Task
}

func (d *TaskDispatcher) AddTask(task Task) {
    d.cond.L.Lock()
    d.tasks = append(d.tasks, task)
    d.cond.Signal() // 只喚醒一個(gè)worker
    d.cond.L.Unlock()
}

func (d *TaskDispatcher) Worker(id int) {
    for {
        d.cond.L.Lock()
        for len(d.tasks) == 0 {
            d.cond.Wait()
        }
        task := d.tasks[0]
        d.tasks = d.tasks[1:]
        d.cond.L.Unlock()
        
        processTask(id, task)
    }
}

type ConfigManager struct {
    cond   *sync.Cond
    config atomic.Value // 存儲(chǔ)當(dāng)前配置
}

func (m *ConfigManager) UpdateConfig(newConfig Config) {
    m.cond.L.Lock()
    m.config.Store(newConfig)
    m.cond.Broadcast() // 通知所有監(jiān)聽者
    m.cond.L.Unlock()
}

func (m *ConfigManager) WatchConfig() {
    for {
        m.cond.L.Lock()
        current := m.config.Load().(Config)
        
        // 等待配置變更
        m.cond.Wait()
        newConfig := m.config.Load().(Config)
        
        if newConfig.Version != current.Version {
            applyNewConfig(newConfig)
        }
        m.cond.L.Unlock()
    }
}

func BenchmarkSignal(b *testing.B) {
    cond := sync.NewCond(&sync.Mutex{})
    var wg sync.WaitGroup
    
    // 準(zhǔn)備100個(gè)等待goroutine
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            cond.L.Lock()
            cond.Wait()
            cond.L.Unlock()
            wg.Done()
        }()
    }
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        cond.Signal() // 每次喚醒一個(gè)
    }
    
    // 清理
    cond.Broadcast()
    wg.Wait()
}

func BenchmarkBroadcast(b *testing.B) {
    cond := sync.NewCond(&sync.Mutex{})
    var wg sync.WaitGroup
    
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            // 每個(gè)迭代創(chuàng)建100個(gè)等待者
            for i := 0; i < 100; i++ {
                wg.Add(1)
                go func() {
                    cond.L.Lock()
                    cond.Wait()
                    cond.L.Unlock()
                    wg.Done()
                }()
            }
            
            cond.Broadcast() // 喚醒所有
            wg.Wait()
        }
    })
}

func (q *TaskQueue) Notify(n int) {
    q.cond.L.Lock()
    defer q.cond.L.Unlock()
    
    // 根據(jù)任務(wù)數(shù)量精確喚醒
    for i := 0; i < min(n, len(q.waiters)); i++ {
        q.cond.Signal()
    }
}

// 錯(cuò)誤示例：可能造成永久阻塞
cond.L.Lock()
if len(tasks) > 0 {
    cond.Signal() // 可能無等待者
}
cond.L.Unlock()

cond.L.Lock()
hasTasks := len(tasks) > 0
cond.L.Unlock()

if hasTasks {
    cond.Signal() // 在鎖外通知更安全
}

type StatusNotifier struct {
    cond    *sync.Cond
    version int64 // 狀態(tài)版本號(hào)
}

func (s *StatusNotifier) UpdateStatus() {
    s.cond.L.Lock()
    s.version++ // 版本更新
    s.cond.Broadcast()
    s.cond.L.Unlock()
}

func (s *StatusNotifier) WaitForChange(ver int64) int64 {
    s.cond.L.Lock()
    defer s.cond.L.Unlock()
    
    for s.version == ver {
        s.cond.Wait()
        // 可能被虛假喚醒，檢查版本
    }
    return s.version
}

var (
    cond = sync.NewCond(&sync.Mutex{})
    resource int
)

func consumer() {
    cond.L.Lock()
    for resource == 0 {
        cond.Wait() // 等待資源
    }
    resource--
    cond.L.Unlock()
}

func producer() {
    cond.L.Lock()
    resource += 5
    cond.Signal() // 錯(cuò)誤：只喚醒一個(gè)消費(fèi)者
    cond.L.Unlock()
}

// 正確做法：根據(jù)資源數(shù)量喚醒
for i := 0; i < min(5, resource); i++ {
    cond.Signal()
}

func process() {
    for {
        // 高頻狀態(tài)檢查
        cond.L.Lock()
        if !ready {
            cond.Wait()
        }
        cond.L.Unlock()
        
        // 處理工作...
    }
}

func update() {
    // 每毫秒觸發(fā)更新
    for range time.Tick(time.Millisecond) {
        cond.Broadcast() // 每秒喚醒1000次
    }
}

// 使用條件變量+狀態(tài)標(biāo)記
func update() {
    for range time.Tick(time.Millisecond) {
        cond.L.Lock()
        statusUpdated = true
        cond.Broadcast()
        cond.L.Unlock()
    }
}

func process() {
    lastStatus := 0
    for {
        cond.L.Lock()
        for !statusUpdated {
            cond.Wait()
        }
        
        // 獲取最新狀態(tài)
        current := getStatus()
        if current == lastStatus {
            // 狀態(tài)未實(shí)際變化，跳過處理
            statusUpdated = false
            cond.L.Unlock()
            continue
        }
        
        lastStatus = current
        statusUpdated = false
        cond.L.Unlock()
        
        // 處理狀態(tài)變化...
    }
}

graph TD
    A[需要通知goroutine] --> B{變更性質(zhì)}
    B -->|資源可用| C[有多少資源？]
    C -->|單個(gè)資源| D[使用Signal]
    C -->|多個(gè)資源| E[多次Signal或條件Broadcast]
    B -->|狀態(tài)變更| F[所有等待者都需要知道？]
    F -->|是| G[使用Broadcast]
    F -->|否| H[按需使用Signal]
    A --> I{性能要求}
    I -->|高并發(fā)低延遲| J[優(yōu)先Signal]
    I -->|吞吐量?jī)?yōu)先| K[評(píng)估Broadcast開銷]

// 使用Broadcast前確認(rèn)：
if 狀態(tài)變化影響所有等待者 &&
   無性能瓶頸風(fēng)險(xiǎn) &&
   避免驚群效應(yīng)措施 {
   cond.Broadcast()
}

// 正確：循環(huán)檢查條件
for !condition {
    cond.Wait()
}

// 危險(xiǎn)：if檢查可能虛假喚醒
if !condition {
    cond.Wait()
}

// 跟蹤Wait調(diào)用
func (c *TracedCond) Wait() {
    start := time.Now()
    c.Cond.Wait()
    metrics.ObserveWaitDuration(time.Since(start))
}