1.ttl策略适合大多数场景，lru适合访问模式不规律的数据，lfu适合数据访问模式稳定的高命中率场景，fifo实现简单但效果一般。2.使用sync.rwmutex读写锁保证并发安全，允许多个goroutine同时读取缓存但写入时独占锁。3.通过分片锁降低锁竞争概率，利用sync.pool减少内存分配，压缩数据减少内存占用，并可选用高性能缓存库优化性能。文章介绍了基于golang内置map和互斥锁实现简易缓存系统的方法，支持过期时间机制并探讨了不同缓存策略的选择及优化手段。
用 Golang 实现一个简易缓存系统，核心在于利用 Go 语言内置的 map 数据结构，结合互斥锁保证并发安全，并可以加入过期时间机制，从而实现一个基于内存的键值存储方案。
解决方案
下面是一个简易的 Golang 缓存系统的实现示例：
package main
import (
"fmt"
"sync"
"time"
)
// CacheItem 缓存项
type CacheItem struct {
value interface{}
expiration int64 // 过期时间戳
}
// Cache 缓存结构体
type Cache struct {
items map[string]CacheItem
mu sync.RWMutex
cleanupInterval time.Duration
}
// NewCache 创建一个新的缓存实例
func NewCache(cleanupInterval time.Duration) *Cache {
cache := &Cache{
items: make(map[string]CacheItem),
cleanupInterval: cleanupInterval,
}
go cache.startCleanupTimer()
return cache
}
// Set 设置缓存项
func (c *Cache) Set(key string, value interface{}, expiration time.Duration) {
c.mu.Lock()
defer c.mu.Unlock()
c.items[key] = CacheItem{
value: value,
expiration: time.Now().Add(expiration).Unix(),
}
}
// Get 获取缓存项
func (c *Cache) Get(key string) (interface{}, bool) {
c.mu.RLock()
defer c.mu.RUnlock()
item, found := c.items[key]
if !found {
return nil, false
}
if item.expiration > 0 && time.Now().Unix() > item.expiration {
return nil, false // 已经过期
}
return item.value, true
}
// Delete 删除缓存项
func (c *Cache) Delete(key string) {
c.mu.Lock()
defer c.mu.Unlock()
delete(c.items, key)
}
// cleanupExpired 清理过期缓存
func (c *Cache) cleanupExpired() {
c.mu.Lock()
defer c.mu.Unlock()
now := time.Now().Unix()
for key, item := range c.items {
if item.expiration > 0 && now > item.expiration {
delete(c.items, key)
}
}
}
// startCleanupTimer 启动清理过期缓存的定时器
func (c *Cache) startCleanupTimer() {
ticker := time.NewTicker(c.cleanupInterval)
defer ticker.Stop()
for range ticker.C {
c.cleanupExpired()
}
}
func main() {
cache := NewCache(5 * time.Second) // 每 5 秒清理一次过期缓存
cache.Set("name", "John Doe", 10 * time.Second)
cache.Set("age", 30, 15 * time.Second)
name, found := cache.Get("name")
if found {
fmt.Println("Name:", name)
}
age, found := cache.Get("age")
if found {
fmt.Println("Age:", age)
}
time.Sleep(12 * time.Second) // 等待 name 过期
name, found = cache.Get("name")
if !found {
fmt.Println("Name not found (expired)")
}
time.Sleep(5 * time.Second) // 等待 age 也过期，并触发清理
age, found = cache.Get("age")
if !found {
fmt.Println("Age not found (expired)")
}
}如何选择合适的缓存过期策略？
缓存过期策略的选择取决于应用场景。常用的过期策略包括：
立即学习“go语言免费学习笔记（深入）”；
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
- TTL (Time To Live): 为每个缓存项设置一个过期时间，到期后自动删除。 示例代码中使用的就是 TTL 策略。
- LRU (Least Recently Used): 当缓存达到容量上限时，优先删除最近最少使用的缓存项。需要维护一个记录缓存项使用顺序的数据结构（例如链表）。
- LFU (Least Frequently Used): 当缓存达到容量上限时，优先删除使用频率最低的缓存项。需要维护每个缓存项的使用频率计数器。
- FIFO (First In First Out): 按照缓存项进入缓存的顺序，先进入的先被删除。
选择哪种策略，要考虑缓存命中率、实现复杂度等因素。例如，对于访问模式不规律的数据，LRU 可能比 FIFO 更好；对于需要高命中率且数据访问模式相对稳定的场景，可以考虑 LFU。
如何处理缓存并发访问问题？
在多线程/并发环境下，对缓存的读写操作需要保证线程安全。Golang 提供了多种并发控制机制，例如互斥锁 (Mutex)、读写锁 (RWMutex) 等。
在上面的示例代码中，使用了 sync.RWMutex 读写锁。读写锁允许多个 goroutine 同时读取缓存，但在写入缓存时会独占锁，防止数据竞争。
除了锁之外，还可以考虑使用原子操作 (atomic package) 来实现某些简单的并发控制，例如计数器更新。
如何优化缓存的性能？
-
选择合适的数据结构： Golang 的
map是一个高效的键值存储结构，但在高并发场景下可能存在锁竞争。可以考虑使用分片锁 (shard lock) 的方式，将map分成多个小map，每个map使用一个独立的锁，从而降低锁竞争的概率。 - 减少内存分配： 频繁的内存分配和垃圾回收会影响缓存的性能。可以考虑使用对象池 (sync.Pool) 来复用缓存项对象，减少内存分配的次数。
- 压缩缓存数据： 如果缓存的数据量较大，可以考虑使用压缩算法 (例如 gzip) 对数据进行压缩，减少内存占用和网络传输开销。
-
使用更高级的缓存库： Golang 社区有很多优秀的缓存库，例如
groupcache、bigcache等，它们提供了更丰富的功能和更高的性能。可以根据实际需求选择合适的库。
