4. Go 内存缓存实现：sync.Map 基础用法、并发安全读写、缓存过期策略（TTL）

在 OAuth2.0 令牌缓存场景中，缓存组件需要同时满足高并发读写与自动过期两个核心需求。Go 标准库提供的 sync.Map 是并发安全的内置哈希表，适合读多写少、键值对生命周期较短的场景。本章将深入讲解 sync.Map 的基础用法、并发安全原理，并在此基础上实现 TTL 过期策略，构建一个生产可用的内存令牌缓存。

4.1 sync.Map 基础用法

sync.Map 是 Go 1.9 引入的并发安全映射，无需额外加锁即可在多个 goroutine 中安全读写。其核心 API 如下：

以下是一个简单的令牌缓存示例：

type TokenCache struct {
    store sync.Map
}

func (c *TokenCache) Set(tokenID string, token *Token) {
    c.store.Store(tokenID, token)
}

func (c *TokenCache) Get(tokenID string) (*Token, bool) {
    val, ok := c.store.Load(tokenID)
    if !ok {
        return nil, false
    }
    return val.(*Token), true
}

func (c *TokenCache) Delete(tokenID string) {
    c.store.Delete(tokenID)
}

4.2 并发安全读写与性能对比

为了直观理解 sync.Map 的并发安全特性，下面通过一个基准测试对比三种实现方式：

• 原生 map + sync.RWMutex：读写均需加锁，读操作使用 RLock，写操作使用 Lock。
• sync.Map：标准库并发安全映射，读多写少场景优化。
• 分片锁 map (ShardedMap)：将 key 哈希到多个分片，每个分片独立加锁，减少锁竞争。

4.3 缓存过期策略（TTL）实现

令牌缓存必须支持 TTL 过期，否则过期令牌会持续占用内存并可能被错误使用。sync.Map 本身不提供过期机制，我们需要在其基础上封装 TTL 逻辑。常见实现方式有两种：

• 惰性删除（Lazy Deletion）：在读取时检查时间戳，若过期则删除并返回 nil。实现简单，但过期数据会残留到下次读取。
• 定时清理（Periodic Cleanup）：启动后台 goroutine，定期扫描所有键值对，删除过期条目。内存更干净，但需要额外的遍历开销。

生产环境通常组合使用两种策略：惰性删除保证读取正确性，定时清理控制内存上限。

4.4 带 TTL 的 sync.Map 实现

下面给出一个完整的带 TTL 的令牌缓存实现，包含惰性删除和定时清理：

type CacheItem struct {
    value      interface{}
    expireTime int64 // Unix 纳秒时间戳
}

type TTLCache struct {
    store sync.Map
    ttl   time.Duration
    stop  chan struct{}
}

func NewTTLCache(ttl time.Duration, cleanupInterval time.Duration) *TTLCache {
    c := &TTLCache{
        ttl:  ttl,
        stop: make(chan struct{}),
    }
    // 启动后台定时清理
    go c.cleanupLoop(cleanupInterval)
    return c
}

func (c *TTLCache) Set(key string, value interface{}) {
    item := CacheItem{
        value:      value,
        expireTime: time.Now().Add(c.ttl).UnixNano(),
    }
    c.store.Store(key, item)
}

func (c *TTLCache) Get(key string) (interface{}, bool) {
    val, ok := c.store.Load(key)
    if !ok {
        return nil, false
    }
    item := val.(CacheItem)
    // 惰性删除：检查是否过期
    if time.Now().UnixNano() > item.expireTime {
        c.store.Delete(key)
        return nil, false
    }
    return item.value, true
}

func (c *TTLCache) cleanupLoop(interval time.Duration) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop()
    for {
        select {
        case <-ticker.C:
            c.cleanup()
        case <-c.stop:
            return
        }
    }
}

func (c *TTLCache) cleanup() {
    now := time.Now().UnixNano()
    c.store.Range(func(key, val interface{}) bool {
        item := val.(CacheItem)
        if now > item.expireTime {
            c.store.Delete(key)
        }
        return true // 继续遍历
    })
}

func (c *TTLCache) Stop() {
    close(c.stop)
}

4.5 令牌缓存中的 TTL 策略优化

在 OAuth2.0 场景中，令牌的 TTL 通常由授权服务器指定（如 3600 秒）。为了提升缓存命中率并减少刷新请求，可以采用以下优化策略：