3. Go 并发基础回顾：goroutine、channel、sync.Mutex 在构建缓存一致性中的角色

在分布式报表回放系统中，缓存一致性是核心挑战之一。Go 语言的并发原语——goroutine、channel 和 sync.Mutex——为我们提供了构建高效、安全缓存层的基石。本章将回顾这三种原语的核心机制，并剖析它们在解决缓存并发读写、数据竞争和状态同步问题中的具体角色。

3.1 并发原语的三层抽象

Go 的并发模型遵循“不要通过共享内存来通信，而应通过通信来共享内存”的哲学。下表对比了三种原语在缓存一致性场景中的定位与适用边界：

3.2 goroutine：并发执行单元

goroutine 是 Go 运行时调度的最小执行单元。在缓存系统中，每个缓存键的加载、失效或回放操作都可以独立封装为一个 goroutine，从而实现高吞吐的并行处理。

以下代码展示了一个使用 goroutine 并发加载多个缓存键的典型模式：

func (c *Cache) BatchLoad(keys []string) map[string]Value {
    results := make(map[string]Value)
    var mu sync.Mutex
    var wg sync.WaitGroup

    for _, key := range keys {
        wg.Add(1)
        go func(k string) {
            defer wg.Done()
            val := c.loadFromSource(k) // 模拟从数据源加载
            mu.Lock()
            results[k] = val
            mu.Unlock()
        }(key)
    }
    wg.Wait()
    return results
}

3.3 channel：事件驱动与任务编排

channel 是 goroutine 之间通信的一等公民。在缓存一致性场景中，channel 天然适合实现生产者-消费者模式，用于传递缓存失效事件、回放请求和结果。

下图展示了基于 channel 的缓存失效广播架构：

使用 channel 实现缓存失效通知的代码示例：

type CacheEvent struct {
    Key   string
    Op    string // "invalidate" | "refresh"
    Data  interface{}
}

func (c *Cache) StartInvalidationListener(eventCh chan CacheEvent) {
    go func() {
        for evt := range eventCh {
            switch evt.Op {
            case "invalidate":
                c.mu.Lock()
                delete(c.store, evt.Key)
                c.mu.Unlock()
            case "refresh":
                val := c.loadFromSource(evt.Key)
                c.mu.Lock()
                c.store[evt.Key] = val
                c.mu.Unlock()
            }
        }
    }()
}

3.4 sync.Mutex：保护共享状态

当多个 goroutine 需要同时读写缓存的核心数据结构（如哈希表、LRU 链表、过期时间堆）时，sync.Mutex 提供了最直接的互斥保护。在缓存一致性实现中，Mutex 通常用于保护以下关键路径：

• 缓存条目替换：淘汰策略（如 LRU）需要原子地更新链表指针和哈希表映射。
• 计数器与统计：命中率、回放次数等指标需要线程安全的累加。
• 状态切换：缓存从“预热中”切换到“就绪”状态时，需要互斥保护。

以下是一个使用 sync.Mutex 保护 LRU 缓存的典型实现片段：

type LRUCache struct {
    mu       sync.Mutex
    maxSize  int
    items    map[string]*list.Element
    evictList *list.List
}

func (c *LRUCache) Get(key string) (Value, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()

    if elem, ok := c.items[key]; ok {
        c.evictList.MoveToFront(elem)
        return elem.Value.(*entry).value, true
    }
    return nil, false
}

func (c *LRUCache) Set(key string, val Value) {
    c.mu.Lock()
    defer c.mu.Unlock()

    if elem, ok := c.items[key]; ok {
        c.evictList.MoveToFront(elem)
        elem.Value.(*entry).value = val
        return
    }
    // 淘汰与插入逻辑...
}

3.5 三种原语的协同工作流

在真实的报表回放缓存系统中，三种原语通常协同工作，形成完整的并发安全链路。下图展示了它们之间的协作关系：

3.6 常见陷阱与最佳实践

在构建缓存一致性系统时，以下陷阱需要特别注意：

• 死锁：嵌套加锁或锁顺序不一致会导致死锁。始终按固定顺序获取多个 Mutex。
• channel 泄漏：未关闭的 channel 会导致 goroutine 永远阻塞。使用 close() 或 select 超时模式。
• goroutine 泄漏：启动的 goroutine 没有退出机制。使用 context.Context 控制生命周期。
• 伪共享（False Sharing）：高频访问的缓存行被不同 goroutine 修改。使用填充（padding）或 sync.Pool 缓解。