Golang线程安全缓存实现方法

Golang不知道大家是否熟悉？今天我将给大家介绍《Golang实现线程安全缓存方法》，这篇文章主要会讲到等等知识点，如果你在看完本篇文章后，有更好的建议或者发现哪里有问题，希望大家都能积极评论指出，谢谢！希望我们能一起加油进步！

使用 sync.RWMutex + map 可实现带过期机制的线程安全缓存，适合需精细控制的场景；高频读、键集稳定的场景可用 sync.Map 提升性能；通过后台 goroutine 定期清理过期项，结合实际需求选择方案。

在 Golang 中实现线程安全缓存，核心是解决多协程并发读写时的数据竞争问题。虽然 Go 的 map 本身不是线程安全的，但通过结合 sync.RWMutex 或使用 sync.Map，可以高效构建安全、高性能的缓存结构。

使用 sync.RWMutex + map 实现自定义缓存

这是最常见且灵活的方式，适合需要控制缓存行为（如过期、淘汰策略）的场景。

使用 sync.RWMutex 可以让多个读操作并发执行，只有写操作（如新增、删除）时才独占锁，提升读密集型场景的性能。

示例代码：

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 简单，但不支持直接遍历或设置过期时间，灵活性较低。

示例代码：

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。

添加自动过期与定期清理机制

无论是哪种实现，若需自动清理过期条目，可启动一个后台任务：

在程序初始化缓存后调用：cache.StartCleanup(time.Minute)，每分钟清理一次过期数据。

选择合适的实现方式

根据实际需求选择：

• 需要精细控制缓存行为（如 LRU 淘汰、TTL、统计）→ 使用 sync.RWMutex + map
• 简单共享状态、键少变、高并发读 → 使用 sync.Map
• 需要复杂功能（如最大容量、自动回收）→ 考虑开源库如 groupcache 或 bigcache

基本上就这些。关键是理解并发访问下数据一致性的重要性，合理选择工具和策略。

今天关于《Golang线程安全缓存实现方法》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于golang,过期机制,sync.Map,sync.RWMutex,线程安全缓存的内容请关注golang学习网公众号！