4. 同步原语：sync.Mutex互斥锁、sync.RWMutex读写锁、锁的粒度与性能

在中间件链路开发中，多个 goroutine 并发访问共享资源是常态。Go 语言通过 sync 包提供了经典的同步原语，其中 sync.Mutex 和 sync.RWMutex 是最核心的两种锁机制。理解它们的实现原理、适用场景以及锁粒度对性能的影响，是构建高吞吐中间件的关键。

4.1 sync.Mutex：互斥锁

sync.Mutex 是最基本的互斥锁，保证同一时刻只有一个 goroutine 可以访问被保护的临界区。其内部实现经历了多次演进，从早期的简单阻塞锁，到当前的“自旋 + 阻塞”混合模式，以平衡低延迟与高并发场景。

// 基础用法示例
var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()
    counter++ // 临界区：对共享变量进行写操作
    mu.Unlock()
}

// 推荐使用 defer 确保解锁
func safeIncrement() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

4.2 sync.RWMutex：读写锁

sync.RWMutex 是读写分离的锁，适用于“读多写少”的场景。它允许多个 goroutine 同时持有读锁，但写锁是独占的——当写锁被持有时，所有读锁和写锁请求都会阻塞。

// RWMutex 典型用法：缓存读取
type Cache struct {
    sync.RWMutex
    data map[string]string
}

func (c *Cache) Get(key string) (string, bool) {
    c.RLock()
    defer c.RUnlock()
    val, ok := c.data[key]
    return val, ok
}

func (c *Cache) Set(key, value string) {
    c.Lock()
    defer c.Unlock()
    c.data[key] = value
}

4.3 锁的粒度与性能

锁的粒度直接决定了并发性能。粒度越粗，临界区越大，并发度越低；粒度越细，锁竞争越少，但锁管理开销和死锁风险也相应增加。在中间件开发中，需要根据实际场景权衡。

4.4 性能调优：从粗粒度到细粒度

以一个简单的内存缓存为例，展示锁粒度对性能的影响。假设缓存使用哈希表实现，包含 256 个桶。

// 分片锁实现示例（简化版）
type ShardedCache struct {
    shards [256]struct {
        sync.RWMutex
        data map[string]string
    }
}

func (c *ShardedCache) getShard(key string) *struct {
    sync.RWMutex
    data map[string]string
} {
    hash := fnv32(key) // 哈希函数
    return &c.shards[hash%256]
}

func (c *ShardedCache) Get(key string) (string, bool) {
    shard := c.getShard(key)
    shard.RLock()
    defer shard.RUnlock()
    val, ok := shard.data[key]
    return val, ok
}

func (c *ShardedCache) Set(key, value string) {
    shard := c.getShard(key)
    shard.Lock()
    defer shard.Unlock()
    shard.data[key] = value
}

4.5 常见陷阱与避坑指南

// 错误示例：复制了已加锁的 Mutex
type Container struct {
    mu sync.Mutex
    data []int
}

func process(c Container) { // 这里发生了复制
    c.mu.Lock() // 复制后的锁是未加锁状态，不安全
    defer c.mu.Unlock()
    // ...
}

// 正确做法：使用指针
func process(c *Container) {
    c.mu.Lock()
    defer c.mu.Unlock()
    // ...
}