go-zero 框架通过内置的 cache.cache 接口和 core/metric 监控体系,结合业务层的逻辑判断来防范缓存击穿与雪崩。核心做法是在读取缓存时采用“互斥锁”或“逻辑过期”策略解决单点击穿,在写入缓存时设置随机过期时间和使用本地缓存(如 groupcache)缓解雪崩。具体实现需调用 cache.get 获取数据,若为空则加锁查询数据库并回填,同时为 key 设置带抖动的 ttl。

如何防止单个热点 Key 的缓存击穿
针对单个热点 Key 在缓存失效瞬间被大量请求穿透到数据库的问题,Go-Zero 推荐采用“互斥锁”方案。即在代码中检查缓存未命中时,先尝试获取一个分布式锁,只有获取成功的线程才去查库并写回缓存,其他线程等待或重试。这能确保同一时刻只有一个请求访问数据库,避免击穿。

package main
import (
"context"
"fmt"
"sync"
"time"
"github.com/zeromicro/go-zero/core/cache"
"github.com/zeromicro/go-zero/core/logx"
)
// 模拟数据库查询
dbData := map[string]string{
"user:1001": "{\"name\":\"Alice\",\"age\":25}",
}
func queryDB(key string) (string, error) {
logx.Info("Querying DB for key:", key)
time.Sleep(100 * time.Millisecond) // 模拟慢查询
if data, ok := dbData[key]; ok {
return data, nil
}
return "", fmt.Errorf("not found")
}
// 使用 sync.Mutex 模拟本地互斥锁(生产环境建议用 Redis 锁)
var mu sync.Mutex
func GetUserInfo(ctx context.Context, c cache.Cache, key string) (string, error) {
var resp string
// 1. 尝试从缓存获取
err := c.Get(key, &resp)
if err == nil {
return resp, nil
}
// 2. 缓存未命中,加锁防止击穿
mu.Lock()
defer mu.Unlock()
// 双重检查:锁获取后再次确认缓存是否已被其他线程回填
err = c.Get(key, &resp)
if err == nil {
return resp, nil
}
// 3. 查询数据库
data, err := queryDB(key)
if err != nil {
return "", err
}
// 4. 写回缓存,设置随机 TTL 防止雪崩
ttl := 30 * time.Minute + time.Duration(time.Now().UnixNano()%60)*time.Second
err = c.Set(key, data, ttl)
if err != nil {
logx.Error("Cache set failed:", err)
}
return data, nil
}
func main() {
c := cache.New(cache.RedisNode,
cache.WithHost("localhost:6379"),
cache.WithPass(""))
ctx := context.Background()
result, _ := GetUserInfo(ctx, c, "user:1001")
fmt.Println(result)
}
如何防止缓存雪崩导致的系统过载
当大量 Key 在同一时间过期,导致请求集中涌向数据库引发雪崩时,Go-Zero 的处理策略是引入“随机抖动”和“多级缓存”。在代码中设置缓存 TTL 时,不应使用固定值,而应在基础时间上增加一个随机区间(如 ±5分钟)。此外,可结合 Go-Zero 的 core/stores 模块配置连接池参数,限制并发数,从而保护后端服务。

package main
import (
"context"
"fmt"
"math/rand"
"time"
"github.com/zeromicro/go-zero/core/cache"
"github.com/zeromicro/go-zero/core/logx"
)
// 模拟多级缓存结构
type MultiLevelCache struct {
local map[string]string // 简易本地缓存
remote cache.Cache // 远程 Redis 缓存
}
func NewMultiLevelCache(remote cache.Cache) *MultiLevelCache {
return &MultiLevelCache{
local: make(map[string]string),
remote: remote,
}
}
func (m *MultiLevelCache) Get(ctx context.Context, key string) (string, error) {
// 1. 检查本地缓存
if val, ok := m.local[key]; ok {
return val, nil
}
// 2. 检查远程缓存
var val string
err := m.remote.Get(key, &val)
if err == nil {
// 回填本地缓存,设置较短过期时间
m.local[key] = val
return val, nil
}
// 3. 远程也未命中,查库并回填
logx.Info("Cache miss, querying DB")
// 此处省略查库逻辑,假设查到数据
dbVal := "db_data_for_" + key
// 设置随机 TTL 防止雪崩
baseTTL := 10 * time.Minute
jitter := time.Duration(rand.Intn(120)) * time.Second // ±2分钟抖动
totalTTL := baseTTL + jitter
m.remote.Set(key, dbVal, totalTTL)
m.local[key] = dbVal
return dbVal, nil
}
func main() {
remote := cache.New(cache.RedisNode,
cache.WithHost("localhost:6379"))
mlc := NewMultiLevelCache(remote)
ctx := context.Background()
val, _ := mlc.Get(ctx, "product:999")
fmt.Println(val)
}
基于程序中 Set 操作返回错误的具体处理
在 Go-Zero 的代码实现中,当 c.Set(key, value, ttl) 执行失败(例如 Redis 连接断开或内存满)时,程序会返回非 nil 的 error。此时正确的做法是记录日志并降级处理,而不是直接阻断业务流程。在上述示例中,我们使用了 logx.Error 打印错误信息,但依然返回了从数据库查到的有效数据,保证了服务的可用性。


















