Golang如何实现并发安全的缓存_Golang并发缓存设计与操作方法_技术教程

使用 sync.Map 可实现读多写少的并发安全缓存，适合简单场景；对于需 TTL、淘汰策略等复杂需求，应结合 RWMutex 与 map 或采用 groupcache、golang-lru 等第三方库，兼顾性能与功能。

在高并发场景下，缓存能显著提升系统性能，但多个 goroutine 同时读写缓存可能引发数据竞争。Golang 提供了多种机制来实现并发安全的缓存，既要保证线程安全，又要兼顾性能和简洁性。

使用 sync.Map 实现并发安全缓存

sync.Map 是 Go 1.9 引入的专为并发场景设计的映射类型，适用于读多写少的缓存场景，无需额外加锁即可安全操作。

示例代码：

var cache sync.Map

// 存储数据
cache.Store("key", "value")

// 获取数据
if val, ok := cache.Load("key"); ok {
    fmt.Println(val)
}

// 原子性加载或存储（类似 GetOrSet）
val, _ := cache.LoadOrStore("key", "default")

sync.Map 内部通过分段锁等机制优化并发性能，适合大多数简单缓存需求，但不支持遍历或统计类操作。

结合 Mutex 和 map 实现自定义缓存

对于需要复杂控制逻辑（如过期、淘汰策略）的缓存，可使用普通 map 配合 sync.Mutex 或 RWMutex 实现。

示例：带 TTL 的缓存结构

type Cache struct {
    items map[string]struct {
        value      interface{}
        expireTime time.Time
    }
    mu sync.RWMutex
}

func (c *Cache) Set(key string, value interface{}, duration time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()
    if c.items == nil {
        c.items = make(map[string]struct {
            value      interface{}
            expireTime time.Time
        })
    }
    c.items[key] = struct {
        value      interface{}
        expireTime time.Time
    }{
        value:      value,
        expireTime: time.Now().Add(duration),
    }
}

func (c *Cache) Get(key string) (interface{}, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    item, found := c.items[key]
    if !found || time.Now().After(item.expireTime) {
        return nil, false
    }
    return item.value, true
}

使用 RWMutex 可让多个读操作并行，提高读密集场景的吞吐量。

引入第三方库增强功能

对于更高级的需求，如 LRU 淘汰、自动过期、内存限制等，可使用成熟库如 groupcache 或 bigcache。

例如使用 github.com/hashicorp/golang-lru：

import "github.com/hashicorp/golang-lru/v2"

cache, _ := lru.New[int, string](128) // 容量为 128 的 LRU 缓存
cache.Add(1, "hello")
if val, ok := cache.Get(1); ok {
    fmt.Println(val)
}

这类库内部已处理并发安全，API 简洁，适合生产环境使用。