3、同步原语详解：Mutex互斥锁、RWMutex读写锁、WaitGroup等待组、Cond条件变量

Go 语言的并发模型建立在 CSP（Communicating Sequential Processes）之上，但共享内存的同步场景依然无法避免。标准库 sync 包提供了四种核心同步原语：Mutex、RWMutex、WaitGroup 和 Cond。理解它们的内部状态机、竞争开销和适用边界，是诊断并发瓶颈、做出正确优化决策的前提。

3.1 Mutex 互斥锁：最基础的临界区保护

sync.Mutex 是 Go 中最基本的互斥锁，提供 Lock() 和 Unlock() 两个方法。其内部实现经历了多次演进，从简单的信号量到当前的自适应自旋 + 阻塞队列混合模式。

3.1.1 内部状态与模式切换

Mutex 的状态由 state 字段的低 3 位和 sema 信号量组成：

Mutex 有两种工作模式：

• 正常模式（非公平）：新 Goroutine 尝试自旋获取锁，若失败则进入等待队列。性能高，但可能导致等待 Goroutine 长时间得不到锁（饥饿）。
• 饥饿模式（公平）：当等待时间超过 1ms 时进入。锁释放后直接交给等待队列头部的 Goroutine，新 Goroutine 不自旋、不抢锁。保证公平性，但吞吐量下降。

3.1.2 性能特征与优化建议

// 错误示例：在热点路径上使用全局 Mutex
var mu sync.Mutex
var counter int64

func increment() {
    mu.Lock()
    counter++          // 临界区极短，但竞争激烈
    mu.Unlock()
}

// 优化示例：使用原子操作 + 分片
var counters [64]atomic.Int64  // 每个 CPU 缓存行一个计数器
func increment(workerID int) {
    counters[workerID&63].Add(1)
}

3.2 RWMutex 读写锁：读多写少场景的利器

sync.RWMutex 在 Mutex 基础上增加了读/写区分：多个读 Goroutine 可以同时持有读锁，但写锁是独占的。内部维护一个 writerSem 和 readerSem 信号量，以及读者计数。

3.2.1 内部结构

3.2.2 性能对比与选择策略

// 典型 RWMutex 使用模式
var rw sync.RWMutex
var data map[string]string

func read(key string) string {
    rw.RLock()
    defer rw.RUnlock()
    return data[key]
}

func write(key, value string) {
    rw.Lock()
    defer rw.Unlock()
    data[key] = value
}

3.3 WaitGroup 等待组：Goroutine 编排的基石

sync.WaitGroup 用于等待一组 Goroutine 完成。内部使用 state 字段原子操作，高 32 位存储计数器，低 32 位存储等待者数量。

3.3.1 核心方法

3.3.2 性能优化要点

• 预分配计数器：在启动 Goroutine 前调用 Add(n)，避免循环中反复调用 Add。
• 避免在 Goroutine 内部调用 Add：可能导致 Wait 在 Add 之前返回，造成竞态。
• 重用 WaitGroup：调用 Wait 后可以重置计数器再次使用，但需确保所有 Done 调用已完成。

// 高效模式：预分配计数器
var wg sync.WaitGroup
tasks := 100
wg.Add(tasks)

for i := 0; i < tasks; i++ {
    go func(id int) {
        defer wg.Done()
        // 执行任务
    }(i)
}
wg.Wait()

// 低效模式：循环内 Add
for i := 0; i < tasks; i++ {
    wg.Add(1)  // 每次原子操作，增加缓存行竞争
    go func(id int) {
        defer wg.Done()
        // 执行任务
    }(i)
}

3.4 Cond 条件变量：信号通知与等待

sync.Cond 用于 Goroutine 在某个条件满足时被唤醒。它必须与一个锁（Mutex 或 RWMutex）配合使用。内部维护一个 FIFO 等待队列。

3.4.1 核心方法

3.4.2 使用模式与陷阱

// 标准 Cond 使用模式
var mu sync.Mutex
cond := sync.NewCond(&mu)
var ready bool

func waitForReady() {
    mu.Lock()
    for !ready {          // 必须使用 for 循环，防止虚假唤醒
        cond.Wait()
    }
    mu.Unlock()
}

func setReady() {
    mu.Lock()
    ready = true
    cond.Broadcast()      // 或 cond.Signal()
    mu.Unlock()
}

3.5 四种原语的选择矩阵

理解这四种同步原语的内部机制和性能特征，是进行并发系统瓶颈诊断的基础。下一层我们将深入 channel 的环形缓冲区实现与 goroutine 调度交互，进一步揭示 Go 并发性能的底层逻辑。