4. 同步原语：sync.Mutex 与 RWMutex、sync.WaitGroup、sync.Once、sync.Cond 的使用场景

在 Go 并发编程中，同步原语是协调 goroutine 访问共享资源、控制执行顺序的核心工具。标准库 sync 包提供了互斥锁、读写锁、等待组、一次性执行和条件变量等原语。本章深入剖析每种原语的设计意图、适用场景及典型陷阱，帮助你在容器化高并发服务中做出正确的同步决策。

4.1 互斥锁 sync.Mutex

sync.Mutex 是最基础的同步原语，保证同一时刻只有一个 goroutine 进入临界区。它适用于写多读少或读写比例不确定的场景。

4.1.1 基本用法与性能特征

// 典型用法：保护共享计数器
var (
    counter int
    mu      sync.Mutex
)

func increment() {
    mu.Lock()
    counter++          // 临界区
    mu.Unlock()
}

4.2 读写锁 sync.RWMutex

sync.RWMutex 在互斥锁基础上增加了读共享能力：多个读操作可以同时持有读锁，写操作必须独占所有锁。它适用于读多写少的典型场景，如配置缓存、路由表、统计计数器。

4.2.1 三种锁定模式对比

// 读多写少场景：安全缓存
type SafeCache struct {
    mu    sync.RWMutex
    items map[string]interface{}
}

func (c *SafeCache) Get(key string) interface{} {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.items[key]
}

func (c *SafeCache) Set(key string, val interface{}) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items[key] = val
}

4.3 等待组 sync.WaitGroup

sync.WaitGroup 用于等待一组 goroutine 全部完成。它是主 goroutine 等待子任务的标准模式，在批处理、并发 RPC 调用、并行计算中广泛使用。

4.3.1 核心方法

// 并发下载多个资源
func fetchAll(urls []string) []Result {
    var wg sync.WaitGroup
    results := make([]Result, len(urls))

    for i, url := range urls {
        wg.Add(1)
        go func(idx int, u string) {
            defer wg.Done()
            results[idx] = download(u)
        }(i, url)
    }

    wg.Wait()
    return results
}

4.4 一次性执行 sync.Once

sync.Once 保证某个函数在整个程序生命周期中只执行一次，即使被多个 goroutine 同时调用。它常用于单例模式、延迟初始化、全局配置加载。

4.4.1 实现原理与使用模式

sync.Once 内部通过原子操作和互斥锁组合实现：先检查标志位，若未执行则加锁执行，执行完成后设置标志位。后续调用直接返回。

// 线程安全的单例模式
var (
    instance *Service
    once     sync.Once
)

func GetService() *Service {
    once.Do(func() {
        instance = &Service{
            config: loadConfig(),
            pool:   newConnectionPool(),
        }
    })
    return instance
}

4.5 条件变量 sync.Cond

sync.Cond 用于 goroutine 之间的事件通知，让一个或多个 goroutine 等待某个条件成立，然后被唤醒。它比轮询 + 睡眠更高效，适用于生产者-消费者、任务队列、资源池等场景。

4.5.1 核心方法

// 条件变量实现任务队列
type TaskQueue struct {
    mu    sync.Mutex
    cond  *sync.Cond
    queue []Task
}

func NewTaskQueue() *TaskQueue {
    q := &TaskQueue{}
    q.cond = sync.NewCond(&q.mu)
    return q
}

func (q *TaskQueue) Push(task Task) {
    q.mu.Lock()
    q.queue = append(q.queue, task)
    q.cond.Signal()  // 通知一个消费者
    q.mu.Unlock()
}

func (q *TaskQueue) Pop() Task {
    q.mu.Lock()
    defer q.mu.Unlock()
    for len(q.queue) == 0 {
        q.cond.Wait()  // 等待任务
    }
    task := q.queue[0]
    q.queue = q.queue[1:]
    return task
}

4.6 同步原语选择决策表

在实际容器化服务中，选择合适的同步原语直接影响系统吞吐量和延迟。以下决策表帮助你快速匹配场景：