使用 sync.RWMutex + map 可实现带过期机制的线程安全缓存，适合需精细控制的场景；高频读、键集稳定的场景可用 sync.Map 提升性能；通过后台 goroutine 定期清理过期项，结合实际需求选择方案。
在 Golang 中实现线程安全缓存，核心是解决多协程并发读写时的数据竞争问题。虽然 Go 的 map 本身不是线程安全的，但通过结合 sync.RWMutex 或使用 sync.Map，可以高效构建安全、高性能的缓存结构。
使用 sync.RWMutex + map 实现自定义缓存
这是最常见且灵活的方式，适合需要控制缓存行为（如过期、淘汰策略）的场景。
使用 sync.RWMutex 可以让多个读操作并发执行，只有写操作（如新增、删除）时才独占锁，提升读密集型场景的性能。
示例代码：
立即学习“go语言免费学习笔记（深入）”；
package main
import (
"sync"
"time"
)
type CacheItem struct {
Value interface{}
Expiration int64 // 过期时间戳（毫秒）
}
func (item *CacheItem) IsExpired() bool {
if item.Expiration == 0 {
return false
}
return time.Now().UnixMilli() > item.Expiration
}
type SafeCache struct {
items map[string]CacheItem
mu sync.RWMutex
}
func NewSafeCache() *SafeCache {
cache := &SafeCache{
items: make(map[string]CacheItem),
}
return cache
}
func (c *SafeCache) Set(key string, value interface{}, duration time.Duration) {
c.mu.Lock()
defer c.mu.Unlock()
var expiration int64
if duration > 0 {
expiration = time.Now().UnixMilli() + duration.Milliseconds()
}
c.items[key] = CacheItem{
Value: value,
Expiration: expiration,
}
}
func (c *SafeCache) Get(key string) (interface{}, bool) {
c.mu.RLock()
defer c.mu.RUnlock()
item, found := c.items[key]
if !found {
return nil, false
}
if item.IsExpired() {
// 可在此处触发异步清理，或由调用方处理
return nil, false
}
return item.Value, true
}
func (c *SafeCache) Delete(key string) {
c.mu.Lock()
defer c.mu.Unlock()
delete(c.items, key)
}
func (c *SafeCache) Cleanup() {
now := time.Now().UnixMilli()
c.mu.Lock()
defer c.mu.Unlock()
for k, v := range c.items {
if v.Expiration != 0 && now > v.Expiration {
delete(c.items, k)
}
}
}你可以定期调用 Cleanup() 方法清理过期项，或启动一个后台 goroutine 自动执行。
使用 sync.Map 作为轻量级并发缓存
sync.Map 是 Go 内置的线程安全映射，适用于读写并发但键集变化不频繁的场景，比如配置缓存、注册表等。
它不需要手动加锁，API 简单，但不支持直接遍历或设置过期时间，灵活性较低。
示例代码：
立即学习“go语言免费学习笔记（深入）”；
package main
import (
"sync"
"time"
)
type ExpiringCache struct {
data sync.Map
}
func (c *ExpiringCache) Set(key string, value interface{}, duration time.Duration) {
expTime := time.Now().Add(duration)
c.data.Store(key, struct {
Value interface{}
Expiration time.Time
}{
Value: value,
Expiration: expTime,
})
}
func (c *ExpiringCache) Get(key string) (interface{}, bool) {
if val, ok := c.data.Load(key); ok {
item := val.(struct {
Value interface{}
Expiration time.Time
})
if time.Now().After(item.Expiration) {
c.data.Delete(key)
return nil, false
}
return item.Value, true
}
return nil, false
}注意：sync.Map 更适合“一次写入，多次读取”的模式，频繁写入可能性能不如带 RWMutex 的普通 map。
添加自动过期与定期清理机制
无论是哪种实现，若需自动清理过期条目，可启动一个后台任务：
```go func (c *SafeCache) StartCleanup(interval time.Duration) { ticker := time.NewTicker(interval) go func() { for range ticker.C { c.Cleanup() } }() } ```在程序初始化缓存后调用：cache.StartCleanup(time.Minute)，每分钟清理一次过期数据。
选择合适的实现方式
根据实际需求选择：
- 需要精细控制缓存行为（如 LRU 淘汰、TTL、统计）→ 使用 sync.RWMutex + map
- 简单共享状态、键少变、高并发读 → 使用 sync.Map
- 需要复杂功能（如最大容量、自动回收）→ 考虑开源库如 groupcache 或 bigcache
基本上就这些。关键是理解并发访问下数据一致性的重要性，合理选择工具和策略。
