用 Go 语言实现高性能内存缓存：从零到生产级

为什么需要自己实现缓存？

虽然 Redis 是分布式缓存的首选，但在很多场景下，进程内缓存（in-process cache）才是性能最优解：

• 读多写少的配置数据
• 热点数据的本地加速层
• 减少网络开销，微秒级响应

今天分享如何用 Go 实现一个生产级的本地缓存库。

核心设计

1. 数据结构选择

type Cache struct {
    mu       sync.RWMutex
    items    map[string]*entry
    maxSize  int
    onEvict  func(key string, value interface{})
}

type entry struct {
    value     interface{}
    expireAt  time.Time
    accessAt  time.Time
}

使用 sync.RWMutex 而非 sync.Mutex，读操作不会互相阻塞。

2. 过期策略：懒删除 + 定时清理

func (c *Cache) Get(key string) (interface{}, bool) {
    c.mu.RLock()
    e, ok := c.items[key]
    c.mu.RUnlock()
    if !ok {
        return nil, false
    }
    // 懒删除：访问时检查过期
    if !e.expireAt.IsZero() && time.Now().After(e.expireAt) {
        c.Delete(key)
        return nil, false
    }
    e.accessAt = time.Now()
    return e.value, true
}

同时启动后台 goroutine 定期扫描过期 key：

func (c *Cache) startJanitor(interval time.Duration) {
    go func() {
        ticker := time.NewTicker(interval)
        for range ticker.C {
            c.mu.Lock()
            now := time.Now()
            for k, e := range c.items {
                if !e.expireAt.IsZero() && now.After(e.expireAt) {
                    delete(c.items, k)
                    if c.onEvict != nil {
                        c.onEvict(k, e.value)
                    }
                }
            }
            c.mu.Unlock()
        }
    }()
}

3. LRU 淘汰

当缓存满时，淘汰最久未访问的 key：

func (c *Cache) evict() {
    var oldestKey string
    var oldestTime time.Time
    for k, e := range c.items {
        if oldestKey == "" || e.accessAt.Before(oldestTime) {
            oldestKey = k
            oldestTime = e.accessAt
        }
    }
    if oldestKey != "" {
        delete(c.items, oldestKey)
    }
}

生产环境建议用双向链表优化到 O(1)。

4. 分片降低锁竞争

单锁在高并发下是瓶颈。分片方案：

type ShardedCache struct {
    shards    [256]*Cache
    hashFunc  func(string) uint8
}

func (sc *ShardedCache) getShard(key string) *Cache {
    return sc.shards[sc.hashFunc(key)]
}

256 个分片，锁竞争降低到 1/256。

性能对比

方案	QPS (读)	P99 延迟
单锁 Cache	500 万	2μs
分片 Cache	2000 万	0.5μs
Redis (本地)	10 万	200μs

本地缓存比 Redis 快 100-200 倍，适合做 L1 缓存层。

生产建议

1. 设置合理的 maxSize，避免 OOM
2. 监控命中率，低于 80% 说明缓存策略有问题
3. 考虑用 sync.Pool 减少 GC 压力
4. 对于大 value，考虑存指针而非拷贝
5. 使用 singleflight 防止缓存击穿

开源参考：groupcache、bigcache、ristretto，都是优秀的 Go 缓存库。