
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
Generated by kimi-k2.6 model
面向 Senior/Staff 级别后端开发岗位的 Redis 系统性面试准备文档。涵盖数据结构、持久化、高可用、分布式锁、缓存、性能优化等核心知识点,深度解析原理 + 实战 + 源码。
目录
- Redis 基础数据结构
- Redis 高级数据结构
- Redis 持久化
- Redis 高可用架构
- Redis 分布式锁
- Redis 缓存问题
- Redis 内存管理与淘汰策略
- Redis 性能优化
- Redis 线程模型
- Redis 与数据库一致性
- Redis 实战场景
1. Redis 基础数据结构
TL;DR
Redis 不是简单的 key-value,而是多数据结构内存数据库——理解每种数据结构的底层编码(SDS/ziplist/quicklist/skiplist/intset)和时间复杂度,是选型的前提。
1.1 String
Situation(场景)
String 是 Redis 最常用的类型,但面试官考的不是 SET/GET,而是底层 SDS(Simple Dynamic String)的设计、整数编码优化、以及为什么不用 C 字符串。
Theory(理论)
SDS 结构(Redis 3.2+ 优化后):
// 根据字符串长度选择不同 header 类型
struct __attribute__ ((__packed__)) sdshdr8 {
uint8_t len; // 已使用长度(< 256)
uint8_t alloc; // 分配总长度
unsigned char flags; // 类型标识
char buf[]; // 柔性数组,实际数据
};SDS vs C 字符串:
| 特性 | C 字符串 | SDS |
|---|---|---|
| 获取长度 | O(n) | O(1)(len 字段) |
| 缓冲区溢出 | 手动检查,易溢出 | 自动扩容 |
| 二进制安全 | 遇到 \0 截断 | 二进制安全 |
| 内存预分配 | 无 | 预分配,减少重分配次数 |
| 惰性释放 | 无 | 缩短时保留空间,后续复用 |
String 的三种编码:
| 编码 | 条件 | 说明 |
|---|---|---|
| int | 值是 64 位有符号整数 | 直接存整数,省内存 |
| embstr | 字符串长度 ≤ 44 字节 | 一次分配(RedisObject + SDS),缓存友好 |
| raw | 字符串长度 > 44 字节 | 两次分配(RedisObject 指针 → SDS) |
为什么是 44 字节? RedisObject 占 16 字节(64 位系统),SDS header 3 字节 + 末尾 \0 1 字节 = 20 字节,44 + 20 = 64 字节,正好是 jemalloc 的 64 字节分配单元。
Practice(实践)
// 真实业务:分布式计数器(String + INCR)
type CounterService struct {
rdb *redis.Client
}
func NewCounterService(rdb *redis.Client) *CounterService {
return &CounterService{rdb: rdb}
}
// 商品浏览量计数
func (s *CounterService) IncrementViewCount(ctx context.Context, productId string) (int64, error) {
key := "product:view:" + productId
return s.rdb.Incr(ctx, key).Result()
}
// 带过期时间的计数器(24h 滑动窗口)
func (s *CounterService) RecordApiCall(ctx context.Context, userId string) error {
key := "api:count:" + userId + ":" + time.Now().Format("2006-01-02")
pipe := s.rdb.Pipeline()
pipe.Incr(ctx, key)
pipe.Expire(ctx, key, 25*time.Hour) // 多给 1h 防止边界
_, err := pipe.Exec(ctx)
return err
}// 真实业务:分布式计数器(Java 实现)
@Service
public class CounterService {
@Autowired
private StringRedisTemplate redisTemplate;
// 商品浏览量计数
public long incrementViewCount(String productId) {
String key = "product:view:" + productId;
return redisTemplate.opsForValue().increment(key);
}
// 带过期时间的计数器(24h 滑动窗口)
public void recordApiCall(String userId) {
String key = "api:count:" + userId + ":" + LocalDate.now();
redisTemplate.opsForValue().increment(key);
redisTemplate.expire(key, 25, TimeUnit.HOURS); // 多给 1h 防止边界
}
}业界案例:微博使用 Redis String 存储用户粉丝数/关注数,INCR 原子操作确保计数准确。单 key 承载千万级更新,通过 Hash Tag 分片到不同槽位分散压力。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| String 只能存字符串 | String 可以存整数(int 编码)、二进制数据、JSON |
| SDS 就是 C 字符串 | SDS 是独立实现,解决了 C 字符串的所有问题 |
| String 最大 512MB | 官方建议单个 value 不超过 10KB,大 value 阻塞 Redis |
| SETNX 和 SET key NX 一样 | SET key NX EX 是原子操作,SETNX + EXPIRE 非原子 |
Extension(延伸)
- 追问:SDS 空间预分配策略? → 修改后 len < 1MB 时 alloc = len * 2;≥ 1MB 时 alloc = len + 1MB
- 追问:embstr 为什么不可修改? → embstr 是只读的,修改后转为 raw 编码(需要重新分配内存)
- 追问:String 的 BITOP 用途? → 位运算,适合做用户签到(365 位 = 46 字节存一年签到)
1.2 Hash
TL;DR
Hash 适合存储对象属性——理解 ziplist 和 hashtable 的转换条件,是控制 Redis 内存的关键。
Theory(理论)
Hash 的两种编码:
| 编码 | 条件 | 说明 |
|---|---|---|
| ziplist | 字段数 < hash-max-ziplist-entries(512) 且每个值长度 < hash-max-ziplist-value(64B) | 紧凑列表,省内存 |
| hashtable | 不满足 ziplist 条件 | 标准哈希表,O(1) 读写 |
ziplist 结构:
| zlbytes | zltail | zllen | entry1 | entry2 | ... | entryN | zlend |
每个 entry:prevlen | encoding | content。紧凑但插入/删除可能需要连锁更新(prevlen 从 1 字节变 5 字节)。
为什么用 ziplist 存小 Hash? 省内存。一个包含 100 个字段的 Hash,ziplist 可能只需几百字节,hashtable 需要几千字节。
Practice(实践)
// 真实业务:购物车(Hash 存商品 SKU 和数量)
type CartService struct {
rdb *redis.Client
}
func (s *CartService) AddToCart(ctx context.Context, userId, skuId string, quantity int) error {
key := "cart:" + userId
return s.rdb.HSet(ctx, key, skuId, quantity).Err()
}
func (s *CartService) GetCart(ctx context.Context, userId string) (map[string]string, error) {
key := "cart:" + userId
return s.rdb.HGetAll(ctx, key).Result()
}
func (s *CartService) RemoveItems(ctx context.Context, userId string, skuIds []string) error {
key := "cart:" + userId
args := make([]interface{}, len(skuIds))
for i, id := range skuIds {
args[i] = id
}
return s.rdb.HDel(ctx, key, args...).Err()
}业界案例:美团商品详情缓存用 Hash 存储商品属性(价格/库存/图片 URL),HGETALL 一次取全,比 String 存 JSON 更省内存(字段复用 ziplist 压缩)。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| Hash 的字段数无限制 | 单个 Hash 建议不超过 1000 字段,HGETALL 大 Hash 会阻塞 |
| Hash 比 String 省内存 | 小对象(字段少、值短)才省,大对象反而更费 |
| Hash 不能设置字段过期 | Redis 不支持字段级 TTL,只能通过整个 key 的 TTL 管理 |
1.3 List
TL;DR
Redis List 是双向链表(quicklist)——理解 quicklist 的 ziplist 节点结构,是控制 List 内存和性能的关键。
Theory(理论)
List 的编码演进:
| 版本 | 编码 | 说明 |
|---|---|---|
| Redis 3.2 之前 | ziplist / linkedlist | 小数据用 ziplist,大数据用双向链表 |
| Redis 3.2+ | quicklist | 双向链表 + ziplist 节点,折中方案 |
| Redis 7.0+ | quicklist + listpack | ziplist 替换为 listpack(解决连锁更新) |
quicklist 结构:
quicklist
├── head → quicklistNode(ziplist) → quicklistNode(ziplist) → ... → tail
│
每个 quicklistNode 包含一个 ziplist
配置:list-max-ziplist-size = -2(每个 ziplist 不超过 8KB)
list-compress-depth = 0(两端不压缩)
List 的核心操作:
| 操作 | 时间复杂度 | 说明 |
|---|---|---|
| LPUSH/RPUSH | O(1) | 头/尾插入 |
| LPOP/RPOP | O(1) | 头/尾弹出 |
| LRANGE | O(S+N) | 范围查询,N 是返回元素数 |
| LINDEX | O(N) | 按索引查,需要遍历 ziplist |
| LTRIM | O(N) | 裁剪列表,保留指定范围 |
Practice(实践)
// 真实业务:消息队列(List + BLPOP)
type MessageQueue struct {
rdb *redis.Client
}
func (s *MessageQueue) SendMessage(ctx context.Context, queueName, message string) error {
return s.rdb.RPush(ctx, queueName, message).Err()
}
// BLPOP 阻塞等待,超时返回空字符串
func (s *MessageQueue) ConsumeMessage(ctx context.Context, queueName string, timeout time.Duration) (string, error) {
result, err := s.rdb.BLPop(ctx, timeout, queueName).Result()
if err != nil {
return "", err
}
// result[0] 是 key,result[1] 是值
if len(result) < 2 {
return "", nil
}
return result[1], nil
}业界案例:Twitter 早期使用 Redis List 做时间线缓存——每个用户的关注推文 ID 存为一个 List,LRANGE 分页获取。后迁移到 Redis Stream + 自定义排序集。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| List 适合做大数据量分页 | LRANGE 大列表性能差,大列表建议用 Stream 或外部索引 |
| List 是数组 | 是双向链表(quicklist),LINDEX 是 O(N) |
| List 可以按值删除 | LREM 是 O(N),大数据量时很慢 |
1.4 Set
TL;DR
Set 是无序唯一集合——理解 intset 和 hashtable 的转换,以及集合运算的应用场景。
Theory(理论)
Set 的两种编码:
| 编码 | 条件 | 说明 |
|---|---|---|
| intset | 元素都是整数且数量 < set-max-intset-entries(512) | 有序整数数组,支持二分查找 |
| hashtable | 不满足 intset 条件 | 值存为 key,value 为 null |
Set 的核心操作:
| 操作 | 时间复杂度 | 说明 |
|---|---|---|
| SADD/SREM | O(1) | 添加/删除 |
| SISMEMBER | O(1) | 判断是否存在 |
| SINTER/SUNION/SDIFF | O(N*M) | 集合运算,数据量大时谨慎 |
| SRANDMEMBER | O(N) | 随机取 N 个元素 |
| SPOP | O(1) | 随机移除并返回 |
Practice(实践)
// 真实业务:用户标签系统(Set 存标签,集合运算找交集用户)
type TagService struct {
rdb *redis.Client
}
// 给用户打标签
func (s *TagService) TagUser(ctx context.Context, userId, tag string) error {
return s.rdb.SAdd(ctx, "tag:"+tag, userId).Err()
}
// 找到同时有"VIP"和"活跃"标签的用户(交集)
func (s *TagService) FindVipActiveUsers(ctx context.Context) ([]string, error) {
return s.rdb.SInter(ctx, "tag:VIP", "tag:ACTIVE").Result()
}
// 随机抽奖(从参与用户中抽 3 个)
func (s *TagService) DrawWinners(ctx context.Context, activityId string, count int64) ([]string, error) {
return s.rdb.SRandMemberN(ctx, "activity:"+activityId, count).Result()
}业界案例:字节跳动推荐系统使用 Redis Set 存储用户兴趣标签,SINTER 计算用户-内容标签匹配度,作为推荐排序的特征输入。
1.5 Sorted Set(ZSet)
TL;DR
ZSet 是 Redis 最强大的数据结构——跳表 + 哈希表双重索引,支持按 score 排序和范围查询,是排行榜、延迟队列的基石。
Theory(理论)
ZSet 的底层结构:
ZSet
├── dict(哈希表): member → score → O(1) 查 score
└── zskiplist(跳表): 按 score 排序 → O(log N) 范围查询
跳表(skiplist)原理:
Level 3: head ──────────────────────→ 50
Level 2: head ──────────→ 30 ──────→ 50 ──────→ 80
Level 1: head ─→ 10 ─→ 20 ─→ 30 ─→ 40 ─→ 50 ─→ 60 ─→ 70 ─→ 80
- 每层是有序链表,上层是下层的"快速通道"
- 查找:从顶层开始,大的往右,小的往下,平均 O(log N)
- 插入:随机层数(概率 1/2 晋升一层),平衡树效果但实现简单
- 为什么不用红黑树? → 跳表实现简单、支持范围查询、并发友好(修改局部性)
ZSet 的核心操作:
| 操作 | 时间复杂度 | 说明 |
|---|---|---|
| ZADD | O(log N) | 添加/更新 |
| ZRANGE/ZREVRANGE | O(log N + M) | 按排名范围查 |
| ZRANGEBYSCORE | O(log N + M) | 按 score 范围查 |
| ZRANK/ZREVRANK | O(log N) | 查排名 |
| ZREM | O(log N) | 删除 |
| ZINCRBY | O(log N) | score 原子增加 |
Practice(实践)
// 真实业务:实时排行榜(ZSet + ZINCRBY)
type LeaderboardService struct {
rdb *redis.Client
}
// 用户得分更新
func (s *LeaderboardService) UpdateScore(ctx context.Context, gameId, userId string, score float64) error {
key := "leaderboard:" + gameId
pipe := s.rdb.Pipeline()
pipe.ZIncrBy(ctx, key, score, userId)
// 只保留前 1000 名,自动裁剪
pipe.ZRemRangeByRank(ctx, key, 0, -1001)
_, err := pipe.Exec(ctx)
return err
}
// 获取前 10 名
func (s *LeaderboardService) GetTop10(ctx context.Context, gameId string) ([]redis.Z, error) {
return s.rdb.ZRevRangeWithScores(ctx, "leaderboard:"+gameId, 0, 9).Result()
}
// 获取用户排名
func (s *LeaderboardService) GetUserRank(ctx context.Context, gameId, userId string) (int64, error) {
return s.rdb.ZRevRank(ctx, "leaderboard:"+gameId, userId).Result()
}
// 真实业务:延迟队列(ZSet + score = 执行时间戳)
type DelayQueue struct {
rdb *redis.Client
}
func (s *DelayQueue) Enqueue(ctx context.Context, taskId string, executeAt int64) error {
return s.rdb.ZAdd(ctx, "delay:queue", redis.Z{Score: float64(executeAt), Member: taskId}).Err()
}
func (s *DelayQueue) Process(ctx context.Context) error {
now := time.Now().UnixMilli()
// 取出 score ≤ now 的任务
tasks, err := s.rdb.ZRangeByScore(ctx, "delay:queue", &redis.ZRangeBy{
Min: "0",
Max: fmt.Sprintf("%d", now),
}).Result()
if err != nil {
return err
}
for _, taskId := range tasks {
// 成功移除才执行(防止多实例竞争)
removed, err := s.rdb.ZRem(ctx, "delay:queue", taskId).Result()
if err != nil {
return err
}
if removed > 0 {
s.executeTask(taskId)
}
}
return nil
}
func (s *DelayQueue) executeTask(taskId string) {
// 执行任务逻辑
}业界案例:腾讯游戏排行榜使用 Redis ZSet 存储全区玩家战力排名,亿级用户、毫秒级查询。通过 Hash Tag 将同一游戏的玩家映射到同一分片,ZRANGE 避免跨分片排序。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| ZSet 的 score 只能是数字 | score 是 64 位浮点数,时间戳、小数都支持 |
| ZSet 按 score 唯一 | member 唯一,score 可以重复,重复时按 member 字典序排 |
| ZSet 查询范围是 O(1) | 范围查询是 O(log N + M),M 是返回数量 |
| 跳表比红黑树慢 | 跳表实现更简单,常数因子略大但范围查询更优 |
Extension(延伸)
- 追问:ZSet 的跳表层数上限? → 64 层,足够处理 2^64 个元素
- 追问:如何实现相同 score 按插入顺序排? → 将时间戳的小数部分嵌入 score(如
score + timestamp/1e13) - 追问:ZSet 适合做全局排行榜吗? → 大数据量需要分片,用 Hash Tag 或外部聚合(ES/ClickHouse)
2. Redis 高级数据结构
TL;DR
Redis 的高级数据结构(Bitmap/HyperLogLog/Geo/Stream)在特定场景下能替代复杂计算——理解它们的误差边界和空间复杂度,是选型时的关键依据。
2.1 Bitmap
Situation(场景)
需要记录海量布尔状态(用户签到、在线状态、功能开关),传统方式每个用户一条记录内存爆炸——Bitmap 用 1 个 bit 表示一个状态,内存降低 99%。
Theory(理论)
Bitmap 原理:
Redis Bitmap 本质上是 String 的位操作接口
1 字节 = 8 bit,可以表示 8 个用户的状态
key = "user:sign:2024-01"
bit 0 = 1 → 1 号用户已签到
bit 1 = 0 → 2 号用户未签到
bit 2 = 1 → 3 号用户已签到
...
核心命令:
| 命令 | 复杂度 | 说明 |
|---|---|---|
| SETBIT key offset value | O(1) | 设置某一位 |
| GETBIT key offset | O(1) | 获取某一位 |
| BITCOUNT key | O(N) | 统计 1 的个数 |
| BITOP AND/OR/XOR/NOT | O(N) | 位运算 |
| BITPOS key bit | O(N) | 查找第一个 0/1 |
空间计算:1 亿用户一年的签到数据 = 100,000,000 bit = 12.5MB
Practice(实践)
// 真实业务:用户签到系统(Bitmap 一年仅需 12.5MB/亿用户)
type SignInService struct {
rdb *redis.Client
}
func (s *SignInService) SignIn(ctx context.Context, userId int64) error {
key := fmt.Sprintf("sign:%d:%d", time.Now().Year(), time.Now().Month())
return s.rdb.SetBit(ctx, key, userId, 1).Err()
}
func (s *SignInService) IsSignedIn(ctx context.Context, userId int64) (bool, error) {
key := fmt.Sprintf("sign:%d:%02d", time.Now().Year(), time.Now().Month())
val, err := s.rdb.GetBit(ctx, key, userId).Result()
return val == 1, err
}
func (s *SignInService) GetSignInCount(ctx context.Context, year, month int) (int64, error) {
key := fmt.Sprintf("sign:%d:%02d", year, month)
return s.rdb.BitCount(ctx, key, nil).Result()
}业界案例:美团骑手每日签到系统使用 Bitmap,3 亿骑手一年的签到数据仅需约 450MB,用 BITCOUNT 秒级统计月签到率。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| Bitmap 只能存 512MB | 单个 String 最大 512MB,但可以通过多个 key 分片 |
| Bitmap 的 offset 不能太大 | offset 最大 2^32-1(约 42 亿),但大 offset 会分配大量零填充内存 |
| BITCOUNT 可以指定范围 | 可以,BITCOUNT key start end 按字节范围统计 |
2.2 HyperLogLog
TL;DR
HyperLogLog 用 12KB 固定空间估算海量集合的基数(不重复元素数),误差仅 0.81%——适合 UV 统计、独立 IP 计数等对精度不敏感的场景。
Theory(理论)
原理:基于概率算法,利用哈希值前导零的最大数量估算基数。
核心思想:
1. 对每个元素做哈希
2. 统计哈希值二进制表示中前导零的个数
3. 前导零的最大值 k 与基数 n 的关系:n ≈ 2^k
4. 用多个桶(16384 个)取调和平均,降低方差
固定空间:16384 桶 × 6 bit = 98304 bit = 12KB
标准误差:1.04 / sqrt(16384) ≈ 0.81%
核心命令:
| 命令 | 说明 |
|---|---|
| PFADD key element [element ...] | 添加元素 |
| PFCOUNT key [key ...] | 估算基数 |
| PFMERGE destkey sourcekey [sourcekey ...] | 合并多个 HLL |
Practice(实践)
// 真实业务:网站 UV 统计(HyperLogLog 12KB 存千万级 UV)
type UvService struct {
rdb *redis.Client
}
func (s *UvService) RecordVisit(ctx context.Context, pageId, userId string) error {
key := fmt.Sprintf("uv:%s:%s", pageId, time.Now().Format("2006-01-02"))
return s.rdb.PFAdd(ctx, key, userId).Err()
}
func (s *UvService) GetUv(ctx context.Context, pageId string, date time.Time) (int64, error) {
key := fmt.Sprintf("uv:%s:%s", pageId, date.Format("2006-01-02"))
return s.rdb.PFCount(ctx, key).Result()
}
func (s *UvService) GetWeeklyUv(ctx context.Context, pageId string) (int64, error) {
keys := make([]string, 7)
for i := 0; i < 7; i++ {
d := time.Now().AddDate(0, 0, -i)
keys[i] = fmt.Sprintf("uv:%s:%s", pageId, d.Format("2006-01-02"))
}
return s.rdb.PFCount(ctx, keys...).Result()
}业界案例:淘宝双 11 实时 UV 统计使用 HyperLogLog,全站 UV 秒级估算仅需 12KB,误差在 1% 以内可接受。
2.3 Geo
TL;DR
Redis Geo 使用 GeoHash + Sorted Set 实现地理位置存储和查询——适合附近的人、距离计算、范围搜索,但精度有限(约 0.5% 误差)。
Theory(理论)
GeoHash 原理:
1. 将经纬度分别做二分法编码
经度 [-180, 180] → 0/1 编码
纬度 [-90, 90] → 0/1 编码
2. 经纬度编码交叉合并
3. Base32 编码 → 字符串(如 wx4g0s)
GeoHash 特性:
- 前缀相同 → 距离相近(但反之不成立,边界问题)
- 精度可调:5 字符约 2.4km,6 字符约 610m,7 字符约 76m
Redis Geo 实现:
底层是 ZSet,member = 地点名称,score = GeoHash 的 52 位整数
GEORADIUS 查询时:
1. 计算目标点的 GeoHash
2. 确定查询范围的 GeoHash 前缀(8 个相邻格子)
3. ZRANGEBYSCORE 范围查询
4. 过滤精确距离(排除格子边界外的点)
Practice(实践)
// 真实业务:附近门店搜索
type GeoService struct {
rdb *redis.Client
}
// 添加门店位置
func (s *GeoService) AddStore(ctx context.Context, storeId string, lng, lat float64) error {
return s.rdb.GeoAdd(ctx, "stores", &redis.GeoLocation{
Name: storeId,
Longitude: lng,
Latitude: lat,
}).Err()
}
// 搜索附近 5km 的门店,按距离排序
func (s *GeoService) FindNearby(ctx context.Context, lng, lat, radiusKm float64) ([]redis.GeoLocation, error) {
return s.rdb.GeoRadius(ctx, "stores", lng, lat, &redis.GeoRadiusQuery{
Radius: radiusKm,
Unit: "km",
Sort: "ASC", // 按距离升序
Count: 50,
}).Result()
}
// 计算两个门店的距离
func (s *GeoService) GetDistance(ctx context.Context, store1, store2 string) (float64, error) {
return s.rdb.GeoDist(ctx, "stores", store1, store2, "km").Result()
}业界案例:滴滴司机派单系统早期使用 Redis Geo 做附近车辆查询,后迁移到自研空间索引(R-Tree + 网格),Redis Geo 适合中小规模(百万级 POI)。
2.4 Stream
TL;DR
Redis Stream 是 Redis 5.0 引入的日志型数据结构,支持消费者组和 ACK 机制——是 List 作为消息队列的升级版,适合轻量级消息流处理。
Theory(理论)
Stream 结构:
Stream(本质是 Radix Tree 存消息)
├── entry1: id=1715500000000-0, {field1: value1, field2: value2}
├── entry2: id=1715500000001-0, {field1: value1, field2: value2}
└── ...
ID 格式:毫秒时间戳-序列号
消费者组(Consumer Group):
├── group1
│ ├── consumer1: 正在处理 msg3
│ ├── consumer2: 正在处理 msg4
│ └── pending: msg1(PENDING), msg2(ACKED)
Stream vs List vs Kafka:
| 特性 | List | Stream | Kafka |
|---|---|---|---|
| 消息持久化 | 无 | 有(可配置 maxlen) | 有 |
| 消费者组 | 无 | 有 | 有 |
| ACK 机制 | 无 | 有 | 有 |
| 消息回溯 | 无 | 有(按 ID) | 有(按 offset) |
| 吞吐量 | 高 | 中 | 极高 |
| 适用场景 | 简单队列 | 轻量级流处理 | 大规模流处理 |
Practice(实践)
// 真实业务:订单状态变更流(Stream + 消费者组)
type OrderStreamService struct {
rdb *redis.Client
}
// 生产者:发送订单状态变更
func (s *OrderStreamService) PublishOrderEvent(ctx context.Context, orderId, status string) error {
return s.rdb.XAdd(ctx, &redis.XAddArgs{
Stream: "order:events",
ID: "*", // 自动生成 ID
Values: map[string]interface{}{
"orderId": orderId,
"status": status,
"time": time.Now().UnixMilli(),
},
}).Err()
}
// 消费者:处理订单事件
func (s *OrderStreamService) StartConsuming(ctx context.Context, group, consumer string) error {
for {
results, err := s.rdb.XReadGroup(ctx, &redis.XReadGroupArgs{
Group: group,
Consumer: consumer,
Streams: []string{"order:events"},
Count: 10,
Block: 5 * time.Second,
}).Result()
if err != nil {
if err == redis.Nil {
continue
}
return err
}
for _, stream := range results {
for _, msg := range stream.Messages {
s.processOrderEvent(msg.Values)
// ACK 确认
s.rdb.XAck(ctx, "order:events", group, msg.ID)
}
}
}
}
func (s *OrderStreamService) processOrderEvent(values map[string]interface{}) {
orderId := values["orderId"].(string)
status := values["status"].(string)
// 处理订单事件逻辑
_ = orderId
_ = status
}
// 初始化消费者组
func (s *OrderStreamService) InitGroup(ctx context.Context) error {
return s.rdb.XGroupCreateMkStream(ctx, "order:events", "order-group", "0").Err()
}业界案例:Shopify 使用 Redis Stream 做电商订单事件流——订单创建、支付、发货等状态变更通过 Stream 广播给库存、物流、通知等下游服务,替代了部分 Kafka 的轻量级场景。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| Stream 可以替代 Kafka | Stream 适合小规模(单机百万级),大数据量仍需要 Kafka |
| Stream 的消息不会丢失 | 不做 maxlen 限制会无限增长,需要 XTRIM 或配置 maxlen |
| Stream ID 只能自动生成 | 可以自定义 ID,但必须递增 |
3. Redis 持久化
TL;DR
Redis 持久化是数据安全的底线——RDB 快照恢复块但可能丢数据,AOF 日志更实时但文件大,混合持久化(Redis 4.0+)结合两者优势。
3.1 RDB(Redis Database)
Situation(场景)
线上 Redis 重启后数据全丢了?面试官问持久化,核心是 RDB 和 AOF 的权衡——什么场景选什么,以及 fork 的 Copy-On-Write 机制。
Theory(理论)
RDB 原理:
1. fork() 创建子进程(共享父进程内存页)
2. 子进程遍历内存数据,写入 .rdb 文件
3. 写入完成后替换旧的 .rdb 文件
4. 父进程继续处理请求
Copy-On-Write(COW):
- fork 后父子进程共享物理内存页
- 父进程修改数据时,复制该页给父进程,子进程仍读旧页
- 所以 fork 时的内存越大,COW 开销越大
RDB 触发条件:
save 900 1 # 900 秒内 1 次修改
save 300 10 # 300 秒内 10 次修改
save 60 10000 # 60 秒内 10000 次修改
save "" # 禁用 RDBRDB 的优缺点:
| 优点 | 缺点 |
|---|---|
| 文件紧凑,恢复速度快 | 可能丢失两次快照间的数据 |
| 适合备份、灾难恢复 | fork 时内存翻倍风险(COW) |
| 对性能影响小(子进程写) | 大数据集 fork 耗时 |
Practice(实践)
# 生产环境 RDB 配置建议
save 900 1
save 300 10
save 60 10000
# 开启压缩
rdbcompression yes
rdbchecksum yes
# bgsave 失败时停止写入(防止数据不一致)
stop-writes-on-bgsave-error yes
# RDB 文件名
dbfilename dump.rdb业界案例:GitHub 使用 RDB 做 Redis 的冷备份——每天凌晨 bgsave 一次,.rdb 文件上传到 S3,灾难恢复时几分钟即可恢复数 TB 数据。
3.2 AOF(Append Only File)
TL;DR
AOF 记录每条写命令,恢复时重放——比 RDB 更实时,但文件大、恢复慢。重写机制(AOF Rewrite)解决文件膨胀问题。
Theory(理论)
AOF 写盘策略:
| 策略 | 说明 | 数据安全 | 性能 |
|---|---|---|---|
| always | 每个命令都 fsync | 最高(几乎不丢) | 最低(磁盘 IO 瓶颈) |
| everysec(默认) | 每秒 fsync 一次 | 中(最多丢 1 秒) | 中 |
| no | 由操作系统决定 fsync | 最低 | 最高 |
AOF Rewrite 原理:
问题:AOF 文件不断增长(如 INCR 100 次 → 100 条记录)
解决:AOF Rewrite
1. fork 子进程
2. 子进程读取当前内存数据,生成最简命令集(如 100 次 INCR → 1 次 SET)
3. 重写期间父进程的新命令写入 AOF rewrite buffer
4. 子进程完成后,将 buffer 追加到新 AOF 文件
5. 原子替换旧 AOF 文件
触发条件:
- auto-aof-rewrite-percentage 100(增长 100% 时重写)
- auto-aof-rewrite-min-size 64mb(最小 64MB 才重写)
Practice(实践)
# AOF 配置建议
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec # 平衡安全和性能
no-appendfsync-on-rewrite yes # rewrite 期间不 fsync,避免磁盘 IO 竞争
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb3.3 混合持久化(RDB + AOF)
TL;DR
Redis 4.0 引入混合持久化——AOF 文件前半部分是 RDB 格式(快照),后半部分是 AOF 格式(增量日志)——兼顾恢复速度和数据安全。
Theory(理论)
混合持久化原理:
AOF 文件结构(混合模式):
┌─────────────────┬──────────────────────┐
│ RDB 格式数据 │ AOF 格式增量日志 │
│ (全量快照) │ (重写后的写命令) │
└─────────────────┴──────────────────────┘
恢复流程:
1. 先加载 RDB 部分(快)
2. 再重放 AOF 部分(补增量)
三种持久化方案对比:
| 维度 | RDB | AOF | 混合持久化 |
|---|---|---|---|
| 数据安全 | 可能丢快照间隔数据 | 最多丢 1 秒 | 最多丢 1 秒 |
| 恢复速度 | 快 | 慢 | 快 |
| 文件大小 | 紧凑 | 大 | 中 |
| 对性能影响 | fork 时较大 | 持续有 fsync 开销 | 同 AOF |
| 推荐场景 | 备份、容忍分钟级丢失 | 金融级数据安全 | 通用推荐 |
Practice(实践)
# 生产环境推荐配置(混合持久化)
appendonly yes
aof-use-rdb-preamble yes # 开启混合持久化
save 900 1
save 300 10
save 60 10000
appendfsync everysec
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb业界案例:美团 Redis 集群统一使用混合持久化——RDB 部分保证快速恢复(数 GB 数据分钟级),AOF 部分保证数据完整性,AOF Rewrite 在业务低峰期自动触发。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| 开 AOF 就不需要 RDB | RDB 用于快速全量恢复,AOF 用于增量,两者互补 |
| AOF Rewrite 阻塞主线程 | Rewrite 是 fork 子进程执行的,不阻塞 |
| fork 不耗内存 | fork 时 COW 机制下,父进程修改越多,内存复制越多 |
| 持久化完全保证不丢数据 | Redis 是内存数据库,持久化有延迟,极端情况仍可能丢数据 |
Extension(延伸)
- 追问:AOF Rewrite 期间宕机怎么办? → 新版 AOF 文件还没替换旧的,恢复时用旧 AOF + 增量日志
- 追问:为什么 Redis 不用 WAL(Write Ahead Log)? → AOF 就是类似 WAL 的日志,但 Redis 优先内存性能,fsync 策略可配置
- 追问:主从复制时持久化的作用? → 主节点持久化后,从节点重启可以全量同步;无持久化时从节点重启需要主节点内存全量快照
4. Redis 高可用架构
TL;DR
Redis 高可用有三层——主从复制保证数据冗余,Sentinel 实现故障自动切换,Cluster 提供数据分片和水平扩展。理解它们的原理和局限是设计 Redis 架构的基础。
4.1 主从复制
Situation(场景)
单机 Redis 挂了数据全丢、读压力大扛不住——主从复制是最基础的高可用手段,但面试官考的是复制原理、延迟问题和脑裂。
Theory(理论)
复制流程(Redis 7.0 之前的全量+增量):
1. 从节点发送 PSYNC ? -1 给主节点(首次)
2. 主节点执行 bgsave,生成 RDB 文件
3. 主节点将 RDB 文件发送给从节点
4. 从节点加载 RDB,清空旧数据
5. 主节点将 bgsave 期间的写命令写入 replication buffer
6. 主节点将 buffer 中的命令发送给从节点
7. 进入增量复制阶段,主节点每写一条命令就发给从节点
Redis 7.0+ 优化:
- 无磁盘复制(diskless replication):主节点直接通过网络发送 RDB
- 多部分 AOF(MP-AOF):避免单个 AOF 文件过大
复制缓冲区(replication backlog):
主节点维护一个固定大小的循环缓冲区(默认 1MB)
从节点断开重连后,发送 PSYNC <runid> <offset>
如果 offset 在缓冲区内 → 增量同步
如果 offset 不在缓冲区内 → 全量同步
主从延迟:
主从延迟 = 主节点写入时间 - 从节点收到时间
影响因素:
- 网络带宽和延迟
- 主节点写压力(replication buffer 是否溢出)
- 从节点性能(是否能及时处理同步命令)
监控命令:INFO replication → master_repl_offset 和 slave_repl_offset 差值
Practice(实践)
# 从节点配置
replicaof 192.168.1.100 6379
replica-read-only yes
# 主节点配置
min-replicas-to-write 1 # 至少 1 个从节点同步才接受写
min-replicas-max-lag 10 # 从节点延迟不超过 10 秒
# 复制缓冲区
repl-backlog-size 64mb # 增大到 64MB,减少全量同步
repl-diskless-sync yes # 无磁盘复制
repl-diskless-sync-delay 5 # 等待 5 秒,让多个从节点共享同一次 RDB 生成业界案例:新浪微博使用一主多从架构——1 个主节点(写)+ 8 个从节点(读),通过读写分离支撑千万级 QPS。从节点跨机房部署,主节点宕机时手动切换到同城从节点。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| 主从复制是实时的 | 是异步的,存在延迟,极端情况可能丢数据 |
| 从节点可以写 | 默认只读,但可配置 replica-read-only no(不推荐) |
| 主从切换自动完成 | 主从复制本身不自动切换,需要 Sentinel 或手动 |
| 全量同步不影响主节点 | bgsave 会 fork,大数据集时主节点可能卡顿 |
4.2 Sentinel(哨兵)
TL;DR
Sentinel 是 Redis 的自动故障转移方案——通过心跳检测和投票机制实现主从自动切换,但无法解决数据分片问题。
Theory(理论)
Sentinel 架构:
Sentinel 集群(至少 3 个,奇数个)
├── 监控:每秒 ping 主从节点
├── 主观下线(SDOWN):单个 Sentinel 认为节点不可用
├── 客观下线(ODOWN):多数 Sentinel 投票确认下线
└── 故障转移:
1. 选出一个 Sentinel 作为 leader(Raft 算法)
2. Leader 从从节点中选出新主节点(优先级 > 复制偏移量 > runid)
3. 通知其他从节点 replicaof 新主节点
4. 通知客户端切换(通过发布订阅)
Sentinel 的局限:
| 局限 | 说明 |
|---|---|
| 单点写压力 | 只有主节点接受写,无法水平扩展 |
| 数据分片 | 不支持,所有数据在一个节点 |
| 脑裂 | 网络分区时可能同时出现两个主节点(通过 min-replicas 缓解) |
| 一致性 | 异步复制,故障切换可能丢数据 |
Practice(实践)
# sentinel.conf
sentinel monitor mymaster 192.168.1.100 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1// 客户端连接(Go + go-redis)
func NewSentinelClient() *redis.Client {
return redis.NewFailoverClient(&redis.FailoverOptions{
MasterName: "mymaster",
SentinelAddrs: []string{"192.168.1.101:26379", "192.168.1.102:26379", "192.168.1.103:26379"},
})
}业界案例:腾讯游戏早期使用 Sentinel 做 Redis 高可用,后因单主节点写瓶颈迁移到 Redis Cluster。
4.3 Cluster(集群)
TL;DR
Redis Cluster 通过数据分片(16384 槽位)和 Gossip 协议实现去中心化集群——支持水平扩展,是 Redis 高可用的终极方案。
Theory(理论)
槽位(Slot)分片:
Redis Cluster 将数据分为 16384 个槽位(0-16383)
每个 key 通过 CRC16(key) % 16384 计算所属槽位
每个主节点负责一部分槽位
例如 3 主 3 从:
Master A: slots 0-5460
Master B: slots 5461-10922
Master C: slots 10923-16383
每个主节点有 1 个从节点做备份
Gossip 协议:
每个节点每秒随机选择几个节点交换信息:
- 节点 ID、IP、端口
- 负责的槽位
- 节点状态(主/从、是否宕机)
- 节点配置纪元(config epoch)
通过多轮 gossip,集群状态最终一致
MOVED 和 ASK 重定向:
客户端访问 key 时:
1. 计算 key 的槽位
2. 如果槽位在当前连接的节点 → 直接处理
3. 如果槽位不在当前节点 → 返回 MOVED slot node_ip:port
4. 客户端缓存槽位映射,下次直接访问正确节点
槽位迁移时(reshard):
- 源节点返回 ASKING + ASK slot node_ip:port
- 客户端先发送 ASKING 命令,再执行原命令
Cluster 的局限:
| 局限 | 说明 |
|---|---|
| 多 key 操作限制 | 不在同一槽位的 key 不能用于 MGET、事务、Lua 脚本 |
| Hash Tag 解决方案 | 用 {tag} 强制同一槽位,如 user:{1000}:profile 和 user:{1000}:orders |
| 批量操作复杂 | Pipeline 需要按槽位分组发送到不同节点 |
| 客户端复杂度 | 需要支持 Cluster 协议的客户端(JedisCluster、 Lettuce) |
Practice(实践)
// 真实业务:Redis Cluster 连接(go-redis)
func NewClusterClient() *redis.ClusterClient {
return redis.NewClusterClient(&redis.ClusterOptions{
Addrs: []string{"192.168.1.100:6379", "192.168.1.101:6379", "192.168.1.102:6379"},
Password: "password",
})
}
// 使用(自动路由到正确节点)
cluster := NewClusterClient()
cluster.Set(ctx, "user:1000:name", "Alice", 0)
name, err := cluster.Get(ctx, "user:1000:name").Result()业界案例:字节跳动使用 100+ 节点的 Redis Cluster 支撑推荐系统特征存储——通过自动槽位迁移实现在线扩容,Gossip 协议保证集群状态一致性,Hash Tag 确保用户相关特征在同一分片。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| Cluster 是强一致的 | 是最终一致,异步复制存在延迟 |
| Cluster 支持跨槽事务 | 不支持,同一事务的所有 key 必须在同一槽位 |
| Gossip 协议很快 | 大规模集群(100+ 节点)gossip 开销变大,消息延迟增加 |
| 槽位可以任意分配 | 应尽量均匀分配,否则出现热点节点 |
Extension(延伸)
- 追问:Cluster 扩容时数据怎么迁移? → redis-cli --cluster reshard,逐个槽位迁移,迁移期间双写(源节点和新节点)
- 追问:Sentinel 和 Cluster 怎么选? → 数据量小、单节点够用选 Sentinel;数据量大、需要水平扩展选 Cluster
- 追问:Redis Cluster 的脑裂怎么解决? → 配置 min-replicas-to-write 1,网络分区时无主节点可写,避免双主写入
5. Redis 分布式锁
TL;DR
Redis 分布式锁是面试必考点——从 SETNX 到 Redisson 到 RedLock,理解它们的实现原理、缺陷和适用场景,是区分"会用"和"懂原理"的关键。
5.1 SETNX 基础锁
Situation(场景)
秒杀扣库存、订单防重复提交——需要分布式锁保证同一时刻只有一个节点执行关键操作。Redis 分布式锁是最常见的实现方案。
Theory(理论)
最简单的分布式锁:
SETNX lock:order:123 "owner-id" # 不存在才设置,返回 1 表示获取成功
EXPIRE lock:order:123 30 # 30 秒后自动释放
问题:SETNX 和 EXPIRE 不是原子的!
- SETNX 成功后进程挂了,没执行 EXPIRE → 死锁
改进:SET key value NX EX(原子操作):
SET lock:order:123 "owner-id" NX EX 30
参数说明:
- NX: Not eXists,key 不存在才设置
- EX: EXpire,30 秒后过期
- 整个操作是原子的
锁的释放:
问题:直接 DEL lock:order:123?
- 如果锁已经被其他客户端获取 → 误删别人的锁
解决:释放前检查 value 是否是自己设置的(Lua 脚本保证原子性)
Lua 脚本:
if redis.call("get", KEYS[1]) == ARGV[1] then
return redis.call("del", KEYS[1])
else
return 0
end
Practice(实践)
// 真实业务:基于 go-redis 的分布式锁
type DistributedLock struct {
rdb *redis.Client
}
const unlockScript = `
if redis.call("get", KEYS[1]) == ARGV[1] then
return redis.call("del", KEYS[1])
else
return 0
end
`
func NewDistributedLock(rdb *redis.Client) *DistributedLock {
return &DistributedLock{rdb: rdb}
}
func (d *DistributedLock) Lock(ctx context.Context, lockKey, requestId string, expiration time.Duration) (bool, error) {
success, err := d.rdb.SetNX(ctx, lockKey, requestId, expiration).Result()
return success, err
}
func (d *DistributedLock) Unlock(ctx context.Context, lockKey, requestId string) error {
return d.rdb.Eval(ctx, unlockScript, []string{lockKey}, requestId).Err()
}
// 使用
func (s *OrderService) CreateOrder(ctx context.Context, userId string) error {
lockKey := "lock:order:" + userId
requestId := uuid.New().String()
locked, err := s.lock.Lock(ctx, lockKey, requestId, 30*time.Second)
if err != nil {
return err
}
if !locked {
return errors.New("操作太频繁,请稍后重试")
}
defer s.lock.Unlock(ctx, lockKey, requestId)
// 检查是否已存在未支付订单
// 创建新订单
return nil
}常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| SETNX + EXPIRE 是安全的 | 非原子,中间崩溃会死锁 |
| 锁过期时间设越长越好 | 太长导致故障时长时间阻塞,太短导致业务未完成锁已释放 |
| DEL 释放锁就够了 | 必须用 Lua 脚本检查 owner,防止误删 |
| 分布式锁是强一致的 | Redis 是 AP 系统,极端网络分区下锁可能不安全 |
5.2 Redisson(生产级分布式锁)
TL;DR
Redisson 是 Redis 分布式锁的生产级实现——支持看门狗自动续期、可重入、公平锁、读写锁、信号量等高级特性,是 Java 生态的首选。
Theory(理论)
Redisson 锁的核心设计:
1. 加锁:SET key lockValue NX PX 30000
lockValue = UUID + threadId(可重入标识)
2. 看门狗(Watch Dog):
- 默认锁过期时间 30 秒
- 获取锁成功后,启动定时任务每 10 秒续期(延长到 30 秒)
- 业务完成或异常时,停止看门狗
3. 可重入:
- Hash 结构:key -> {threadId: count}
- 同线程重复获取锁 → count + 1
- 释放时 count - 1,count = 0 时才删除锁
4. 公平锁:
- 维护等待队列(ZSet,score = 请求时间戳)
- 新请求添加到队列尾部
- 锁释放时通知队列头部的下一个线程
RedLock(Redisson 的多主节点锁):
RedLock 算法(Redis 作者提出):
1. 向 N 个独立的 Redis 主节点申请锁
2. 计算总耗时,如果获取了超过半数(N/2+1)的锁且总耗时 < 锁过期时间
3. 认为加锁成功
4. 释放时向所有节点发送解锁命令
争议:
- 需要 N 个独立 Redis 实例(非主从)
- 时钟漂移问题(各节点时钟不一致)
- Martin Kleppmann 批评:不是真正的 CP 锁
- 实际生产中很少有公司用 RedLock
Practice(实践)
// 真实业务:Redisson 分布式锁
@Configuration
public class RedissonConfig {
@Bean
public RedissonClient redissonClient() {
Config config = new Config();
config.useClusterServers()
.addNodeAddress("redis://192.168.1.100:6379")
.addNodeAddress("redis://192.168.1.101:6379")
.addNodeAddress("redis://192.168.1.102:6379")
.setScanInterval(2000);
return Redisson.create(config);
}
}
@Service
public class SeckillService {
@Autowired
private RedissonClient redissonClient;
@Autowired
private StringRedisTemplate redisTemplate;
public void seckill(String productId, String userId) {
RLock lock = redissonClient.getLock("seckill:" + productId);
// 尝试加锁,最多等待 3 秒,锁 30 秒自动释放(看门狗续期)
boolean locked = lock.tryLock(3, 30, TimeUnit.SECONDS);
if (!locked) {
throw new RuntimeException("秒杀太火爆,请重试");
}
try {
// 扣减库存
Long stock = redisTemplate.opsForValue().decrement("stock:" + productId);
if (stock == null || stock < 0) {
redisTemplate.opsForValue().increment("stock:" + productId);
throw new RuntimeException("库存不足");
}
// 创建订单
createOrder(productId, userId);
} finally {
lock.unlock();
}
}
// 读写锁(读多写少场景)
public Product getProduct(String productId) {
RReadWriteLock rwLock = redissonClient.getReadWriteLock("product:" + productId);
RLock readLock = rwLock.readLock();
readLock.lock();
try {
String json = redisTemplate.opsForValue().get("product:" + productId);
return JSON.parseObject(json, Product.class);
} finally {
readLock.unlock();
}
}
public void updateProduct(String productId, Product product) {
RReadWriteLock rwLock = redissonClient.getReadWriteLock("product:" + productId);
RLock writeLock = rwLock.writeLock();
writeLock.lock();
try {
redisTemplate.opsForValue().set("product:" + productId, JSON.toJSONString(product));
productRepository.save(product);
} finally {
writeLock.unlock();
}
}
}业界案例:美团支付系统使用 Redisson 分布式锁防止重复支付——同一订单号在 30 秒内只能有一个支付请求处理,看门狗自动续期确保长流程不中断。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| Redisson 锁是 CP 的 | Redisson 基于 Redis,Redis 是 AP 系统,极端情况可能不安全 |
| 看门狗续期永远不会失败 | 如果 Redis 挂了或网络断了,续期失败,锁仍可能过期 |
| RedLock 是银弹 | RedLock 有 clock drift 问题,且需要多个独立实例,实际很少用 |
| 分布式锁可以替代数据库锁 | 分布式锁是粗粒度保护,数据库事务锁是细粒度,两者互补 |
Extension(延伸)
- 追问:Redisson 看门狗怎么实现的? → 获取锁后启动 Netty 的 HashedWheelTimer,每 lockWatchdogTimeout/3(默认 10 秒)执行续期 Lua 脚本
- 追问:Redis 分布式锁和 ZooKeeper 分布式锁怎么选? → Redis 性能好但可能不安全;ZK 是 CP 的,可靠性更高但性能较低。高并发场景选 Redisson,强一致性场景选 ZK/Curator
- 追问:Redis 分布式锁的锁续期问题? → 看门狗自动续期解决了业务执行时间超过锁过期时间的问题,但进程崩溃时看门狗停止,锁最终释放
6. Redis 缓存问题
TL;DR
缓存穿透、击穿、雪崩是 Redis 面试的三座大山——穿透是查不存在的数据,击穿是热点 key 过期,雪崩是大量 key 同时过期。每种问题有不同的防御策略。
6.1 缓存穿透
Situation(场景)
攻击者用不存在的 key 疯狂请求,每次穿透到数据库——数据库扛不住挂了。这是缓存系统最危险的攻击方式之一。
Theory(理论)
什么是缓存穿透?
请求 key = "user:999999"(不存在)
│
├── Redis 查不到 → 穿透到 MySQL
├── MySQL 也查不到
├── 下次同样请求 → 继续穿透
└── 大量此类请求 → DB 被打挂
解决方案对比:
| 方案 | 原理 | 优点 | 缺点 |
|---|---|---|---|
| 缓存空值 | key 不存在也缓存一个 null(TTL 短) | 简单有效 | 占用内存,可能被垃圾 key 填满 |
| 布隆过滤器 | 前置过滤,肯定不存在的直接返回 | 省内存,防攻击 | 有一定误判率,不能删除 |
| 参数校验 | 接口层拦截非法参数 | 最简单 | 只能防已知非法格式 |
| 限流 | 对同一 key 限流 | 通用防护 | 影响正常用户 |
布隆过滤器原理:
1. 初始化:bit 数组全 0(如 100 万 bit = 125KB)
2. 插入:对元素做 k 次哈希,将对应位置 1
3. 查询:对元素做 k 次哈希,如果所有位置都是 1 → 可能存在;如果有 0 → 肯定不存在
误判率公式:
- 最优哈希函数数 k = (m/n) * ln(2)
- 误判率 p ≈ (1 - e^(-kn/m))^k
- m=100万bit, n=10万元素, k=7 → p ≈ 1%
Practice(实践)
// 真实业务:缓存空值 + 布隆过滤器双层防护
type UserService struct {
rdb *redis.Client
bloomFilter *rediscnt.BloomFilter // Redisson 布隆过滤器
userRepo *UserRepository
}
func (s *UserService) GetUser(ctx context.Context, userId int64) (*User, error) {
key := fmt.Sprintf("user:%d", userId)
// 第一层:布隆过滤器
if !s.bloomFilter.Exists(ctx, key) {
return nil, nil // 肯定不存在,直接返回
}
// 第二层:Redis 缓存
json, err := s.rdb.Get(ctx, key).Result()
if err == nil {
if json == "null" {
return nil, nil // 缓存的空值
}
var user User
if err := json.Unmarshal(&user); err == nil {
return &user, nil
}
}
// 第三层:数据库
user, err := s.userRepo.FindById(ctx, userId)
if err != nil {
return nil, err
}
if user == nil {
// 缓存空值,TTL 30 秒(防止攻击时大量空值长期占用内存)
s.rdb.Set(ctx, key, "null", 30*time.Second)
} else {
data, _ := json.Marshal(user)
s.rdb.Set(ctx, key, data, 1*time.Hour)
// 用户注册时加入布隆过滤器
s.bloomFilter.Add(ctx, key)
}
return user, nil
}业界案例:淘宝商品详情页使用 Guava BloomFilter + Redis 双层防护——亿级商品 ID 布隆过滤器仅需约 100MB 内存,拦截了 99% 的非法商品 ID 查询。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| 缓存空值可以永久缓存 | 空值 TTL 应该短(10-60 秒),否则垃圾 key 占满内存 |
| 布隆过滤器没有误判 | 布隆过滤器有误判(把不存在的认为存在),但没有漏判 |
| 布隆过滤器可以删除元素 | 传统布隆过滤器不支持删除,可以用 Counting Bloom Filter 或 Cuckoo Filter |
6.2 缓存击穿
TL;DR
热点 key 过期瞬间,大量请求同时打到数据库——解决方案是互斥锁或逻辑过期,确保只有一个线程重建缓存。
Theory(理论)
什么是缓存击穿?
key = "product:1000"(热门商品,10 万 QPS)
│
├── 缓存过期时间到
├── 10 万个请求同时发现缓存失效
├── 全部打到 MySQL
└── MySQL 瞬间被压垮
解决方案:
| 方案 | 原理 | 适用场景 |
|---|---|---|
| 互斥锁 | 只有一个线程去 DB 查询并重建缓存 | 一致性要求高 |
| 逻辑过期 | 缓存永不过期,值里存过期时间,异步重建 | 一致性要求低 |
| 热点 key 永不过期 | 手动管理更新,不设置 TTL | 更新频率可控的热点数据 |
互斥锁实现:
1. 线程 A 发现缓存失效
2. 获取分布式锁(SET key NX EX 10)
3. 再次检查缓存(双重检查,防止其他线程已重建)
4. 查 DB → 写缓存 → 释放锁
5. 其他线程等待锁释放后读缓存
Practice(实践)
// 真实业务:互斥锁防止缓存击穿
type ProductService struct {
rdb *redis.Client
productRepo *ProductRepository
lock *DistributedLock
}
func (s *ProductService) GetProduct(ctx context.Context, productId int64) (*Product, error) {
key := fmt.Sprintf("product:%d", productId)
// 先查缓存
json, err := s.rdb.Get(ctx, key).Result()
if err == nil {
var product Product
if err := json.Unmarshal(&product); err == nil {
return &product, nil
}
}
// 缓存失效,获取分布式锁
lockKey := fmt.Sprintf("lock:product:%d", productId)
requestId := uuid.New().String()
locked, err := s.lock.Lock(ctx, lockKey, requestId, 10*time.Second)
if err != nil {
return nil, err
}
if !locked {
// 没拿到锁,等待后重试读缓存
time.Sleep(100 * time.Millisecond)
return s.GetProduct(ctx, productId) // 递归重试
}
defer s.lock.Unlock(ctx, lockKey, requestId)
// 双重检查(拿到锁后再次检查缓存)
json, err = s.rdb.Get(ctx, key).Result()
if err == nil {
var product Product
if err := json.Unmarshal(&product); err == nil {
return &product, nil
}
}
// 查 DB 并重建缓存
product, err := s.productRepo.FindById(ctx, productId)
if err != nil {
return nil, err
}
if product != nil {
data, _ := json.Marshal(product)
// 随机 TTL 防雪崩:30-90 分钟
ttl := 30*time.Minute + time.Duration(rand.Intn(60))*time.Minute
s.rdb.Set(ctx, key, data, ttl)
}
return product, nil
}业界案例:京东秒杀商品详情页使用互斥锁 + 本地缓存双层防护——热点商品缓存失效时,分布式锁保证只有一个请求查 DB,本地缓存(Caffeine)在 Redis 失效期间提供兜底。
6.3 缓存雪崩
TL;DR
大量 key 同时过期或 Redis 宕机,导致所有请求打到数据库——解决方案是随机 TTL、多级缓存、熔断限流、高可用架构。
Theory(理论)
什么是缓存雪崩?
场景 1:大量 key 同时过期
- 凌晨 3 点批量设置的缓存同时到期
- 所有请求穿透到 DB
场景 2:Redis 宕机
- Redis 集群故障
- 所有请求直接打到 DB
解决方案矩阵:
| 方案 | 针对场景 | 原理 |
|---|---|---|
| 随机 TTL | 同时过期 | 基础 TTL + random(0, 300) 秒 |
| 多级缓存 | Redis 宕机 | L1 本地缓存(Caffeine)+ L2 Redis |
| 熔断限流 | 请求量过大 | Sentinel/Hystrix 熔断,保护 DB |
| 高可用架构 | Redis 宕机 | Cluster/Sentinel 自动故障转移 |
| 预热 | 启动时 | 系统启动时预加载热点数据 |
Practice(实践)
// 真实业务:随机 TTL + 多级缓存防雪崩
type MultiLevelCacheService struct {
rdb *redis.Client
localCache *cc.Cache // Caffeine 本地缓存
productRepo *ProductRepository
}
type Product struct {
ID int64
Name string
}
func (s *MultiLevelCacheService) GetProduct(ctx context.Context, productId int64) (*Product, error) {
key := fmt.Sprintf("product:%d", productId)
// L1: 本地缓存(10 分钟)
if product, found := s.localCache.Get(key); found {
return product.(*Product), nil
}
// L2: Redis
json, err := s.rdb.Get(ctx, key).Result()
if err == nil {
var product Product
if err := json.Unmarshal(&product); err == nil {
s.localCache.Set(key, &product, 10*time.Minute) // 回填本地缓存
return &product, nil
}
}
// L3: 数据库(带分布式锁防击穿)
product, err := s.loadFromDbWithLock(ctx, productId)
if err != nil {
return nil, err
}
if product != nil {
data, _ := json.Marshal(product)
// 随机 TTL:30-90 分钟,避免同时过期
ttl := 30*time.Minute + time.Duration(rand.Intn(60))*time.Minute
s.rdb.Set(ctx, key, data, ttl)
s.localCache.Set(key, product, 10*time.Minute)
}
return product, nil
}
func (s *MultiLevelCacheService) loadFromDbWithLock(ctx context.Context, productId int64) (*Product, error) {
lockKey := fmt.Sprintf("lock:product:%d", productId)
requestId := uuid.New().String()
locked, err := s.lock.Lock(ctx, lockKey, requestId, 10*time.Second)
if err != nil || !locked {
// 获取锁失败,sleep 后重试
time.Sleep(100 * time.Millisecond)
return s.GetProduct(ctx, productId)
}
defer s.lock.Unlock(ctx, lockKey, requestId)
return s.productRepo.FindById(ctx, productId)
}业界案例:阿里云在双十一期间使用多级缓存 + 熔断降级——Redis 集群承载 90% 流量,Caffeine 本地缓存兜底 5%,剩下 5% 穿透到 DB 时通过 Sentinel 限流保护。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| 随机 TTL 完全解决雪崩 | 只能缓解同时过期,Redis 宕机仍需多级缓存 |
| 本地缓存和 Redis 数据一定一致 | 本地缓存有延迟,最终一致,强一致场景不能用 |
| 雪崩和击穿是一回事 | 击穿是单个热点 key,雪崩是大量 key 同时失效 |
Extension(延伸)
- 追问:缓存预热怎么做? → 系统启动时通过
@PostConstruct或定时任务加载热点数据;大数据量时错峰预热 - 追问:缓存和 DB 一致性问题? → 第 10 章详解,Cache-Aside + 延迟双删是主流方案
- 追问:BigKey 会引发什么问题? → 第 7 章详解,阻塞 Redis、网络拥塞、主从复制延迟
7. Redis 内存管理与淘汰策略
TL;DR
Redis 是内存数据库,内存就是瓶颈——理解过期删除策略、内存淘汰 8 种策略、BigKey/HotKey 排查,是线上 Redis 运维的核心能力。
7.1 过期删除策略
Situation(场景)
设置了 TTL 的 key 什么时候真正删除?面试官通过这个问题考察你对 Redis 内存管理的理解深度。
Theory(理论)
三种过期删除策略对比:
| 策略 | 原理 | 优点 | 缺点 |
|---|---|---|---|
| 定时删除 | 设置过期时间的同时创建定时器,到期立即删除 | 内存友好 | CPU 开销大 |
| 惰性删除 | 访问 key 时才检查是否过期,过期则删除 | CPU 友好 | 内存不友好(过期 key 长期占用) |
| 定期删除 | 每 100ms 随机抽查一批 key,删除过期的 | 折中 | 可能漏删,需要配合惰性删除 |
Redis 实际采用:惰性删除 + 定期删除
惰性删除:
- 每次访问 key 时,检查 expire 字典
- 如果过期 → 删除并返回 null
定期删除:
- 每 100ms 执行一次(serverCron)
- 随机抽查 20 个 key
- 删除其中过期的
- 如果过期比例 > 25%,重复抽查(但最多执行 25ms)
过期键对 RDB/AOF 的影响:
RDB:
- 生成 RDB 时不包含过期键
- 加载 RDB 时,主节点会检查过期键并删除;从节点不检查(依赖主节点同步删除)
AOF:
- 过期键被删除时,追加一条 DEL 命令到 AOF
- AOF Rewrite 时不包含过期键
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| TTL 到期立即删除 | 不一定,依赖惰性/定期删除,可能短暂存在 |
| 过期键不影响内存 | 大量过期键未访问时会长期占用内存 |
| EXPIRE 可以精确到毫秒 | EXPIRE 是秒级,PEXPIRE 是毫秒级 |
7.2 内存淘汰策略
TL;DR
Redis 内存满了怎么办?8 种淘汰策略决定哪些 key 被删除——生产环境最常用的是 allkeys-lru 或 allkeys-lfu。
Theory(理论)
8 种内存淘汰策略:
| 策略 | 范围 | 淘汰逻辑 | 适用场景 |
|---|---|---|---|
| noeviction(默认) | — | 不淘汰,写入时报错 | 不推荐生产 |
| allkeys-lru | 所有 key | 最近最少使用 | 最常用 |
| allkeys-lfu | 所有 key | 最不经常使用(Redis 4.0+) | 有冷热分化的场景 |
| allkeys-random | 所有 key | 随机淘汰 | 几乎不用 |
| volatile-lru | 有过期时间的 key | 最近最少使用 | 需要保留永久 key |
| volatile-lfu | 有过期时间的 key | 最不经常使用 | 同上 |
| volatile-random | 有过期时间的 key | 随机淘汰 | 几乎不用 |
| volatile-ttl | 有过期时间的 key | 快要过期的优先淘汰 | 特殊场景 |
LRU vs LFU:
| 维度 | LRU | LFU |
|---|---|---|
| 依据 | 最近一次访问时间 | 访问频率 |
| 问题 | 突发大量扫描会污染缓存 | 历史频率高但近期不访问的 key 难淘汰 |
| 解决 | — | 衰减因子(lfu-decay-time) |
| Redis 实现 | 近似 LRU(随机采样 5 个) | 16 位计数器(8 位频率 + 8 位衰减时间) |
Redis 近似 LRU:
不是真正的 LRU(维护双向链表开销大)
而是:
1. 每次访问时,记录访问时间到 RedisObject 的 lru 字段(24 bit)
2. 淘汰时,随机采样 maxmemory-samples(默认 5)个 key
3. 淘汰其中 lru 值最小(最久未访问)的
采样数越大越接近真实 LRU,但 CPU 开销越大
Practice(实践)
# 生产环境推荐配置
maxmemory 8gb
maxmemory-policy allkeys-lru
maxmemory-samples 10 # 增大采样数,更接近真实 LRU
# 如果需要区分冷热(如商品详情页)
maxmemory-policy allkeys-lfu
lfu-log-factor 10 # 频率对数因子
lfu-decay-time 1 # 每 1 分钟衰减一次业界案例:美团使用 allkeys-lfu 做商品详情缓存——热门商品访问频率高保留在内存,冷门商品自动淘汰。LFU 的衰减机制确保季节性商品(如月饼)在节后自然被淘汰。
7.3 BigKey 与 HotKey
TL;DR
BigKey(单个 key 过大)和 HotKey(单个 key 访问过高)是 Redis 的两大杀手——理解排查方法和治理方案,是 Redis 运维的必修课。
Theory(理论)
BigKey 定义与危害:
| 维度 | 阈值 | 危害 |
|---|---|---|
| String | > 10KB | 网络拥塞、慢查询 |
| Hash/List/Set/ZSet | 元素数 > 5000 或总大小 > 1MB | 阻塞 Redis(单线程)、主从复制延迟 |
HotKey 定义与危害:
定义:单个 key 的 QPS 超过 10000 或占所在分片总 QPS 的 50%+
危害:
- CPU 飙高(单线程处理)
- 网络带宽打满
- 主从复制延迟(从节点跟不上)
- Cluster 场景下某分片成为热点
排查方法:
| 方法 | 命令/工具 | 说明 |
|---|---|---|
| redis-cli --bigkeys | 命令行 | 扫描全库找出 BigKey |
| redis-cli --hotkeys | 命令行 | 扫描找出 HotKey(需要 maxmemory-policy 为 LFU) |
| MONITOR | 命令 | 实时查看所有命令(性能开销大,慎用) |
| slowlog | 命令 | 查看慢查询 |
| redis-rdb-tools | 工具 | 分析 RDB 文件,统计 key 大小 |
| 自带监控 | INFO | info commandstats 看命令耗时分布 |
Practice(实践)
// BigKey 治理:Hash 分片
type BigKeySplitService struct {
rdb *redis.Client
}
// 将大 Hash 拆分为多个小 Hash(每 1000 个字段一个)
func (s *BigKeySplitService) HSetBig(ctx context.Context, baseKey, field, value string) error {
shard := int(math.Abs(float64(hash(field) % 100))) // 100 个分片
shardKey := fmt.Sprintf("%s:%d", baseKey, shard)
return s.rdb.HSet(ctx, shardKey, field, value).Err()
}
func (s *BigKeySplitService) HGetBig(ctx context.Context, baseKey, field string) (string, error) {
shard := int(math.Abs(float64(hash(field) % 100)))
shardKey := fmt.Sprintf("%s:%d", baseKey, shard)
return s.rdb.HGet(ctx, shardKey, field).Result()
}
// HotKey 治理:本地缓存 + Key 副本
type HotKeyService struct {
rdb *redis.Client
localCache *cc.Cache // Caffeine
}
func (s *HotKeyService) GetWithLocalCache(ctx context.Context, key string) (interface{}, error) {
// 本地缓存 10 秒,减少 Redis 压力
if value := s.localCache.Get(key); value != nil {
return value, nil
}
value, err := s.rdb.Get(ctx, key).Result()
if err != nil {
return nil, err
}
s.localCache.Set(key, value, 10*time.Second)
return value, nil
}
// HotKey 拆分:一个 key 拆成 N 个副本
func (s *HotKeyService) GetWithSharding(ctx context.Context, key string) (string, error) {
shard := rand.Intn(10) // 10 个副本
return s.rdb.Get(ctx, fmt.Sprintf("%s:%d", key, shard)).Result()
}业界案例:
- 阿里巴巴:双 11 期间发现 "商品库存" key 成为 HotKey,通过本地缓存 + 库存分片(每个 SKU 拆成 10 个库存片)解决
- 字节跳动:视频播放量计数使用本地缓存聚合后批量写入 Redis,降低单 key QPS 两个数量级
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| BigKey 只是占用内存 | BigKey 的删除/查询会阻塞 Redis 主线程,导致所有命令延迟 |
| HotKey 可以通过扩容解决 | Cluster 扩容无法解决 HotKey,因为 HotKey 只在一个分片 |
| --bigkeys 可以线上用 | --bigkeys 是扫描全库,大实例会阻塞,建议在从节点执行 |
| 所有 BigKey 都要拆分 | 需要评估拆分后的查询复杂度,有些场景用外部存储(ES/MySQL)更合适 |
Extension(延伸)
- 追问:Redis 的内存碎片怎么解决? →
INFO memory看mem_fragmentation_ratio,> 1.5 说明碎片严重,可以重启或开启activedefrag(Redis 4.0+) - 追问:Redis 的 lazyfree 是什么? → 异步删除大 key(
UNLINK替代DEL),避免阻塞主线程 - 追问:Redis 内存怎么分析? →
MEMORY DOCTOR、MEMORY USAGE key、redis-memory-for-key工具
8. Redis 性能优化
TL;DR
Redis 性能优化的核心思路是减少网络 RTT、减少命令数、避免大 key 操作——Pipeline、Lua 脚本、连接池是最常用的三板斧。
8.1 Pipeline 与批量操作
Situation(场景)
1000 个 key 要查询,一个个 GET 需要 1000 次 RTT(假设 1ms)→ 1 秒才能查完。Pipeline 将多个命令打包发送,一次 RTT 完成所有操作。
Theory(理论)
Pipeline vs 普通操作:
普通模式(1000 次 GET):
客户端 → GET key1 → 服务端 → 客户端 (1 RTT)
客户端 → GET key2 → 服务端 → 客户端 (1 RTT)
... × 1000 次
总时间 = 1000 × RTT
Pipeline 模式:
客户端 → GET key1, GET key2, ..., GET key1000 → 服务端
服务端 → 结果1, 结果2, ..., 结果1000 → 客户端
总时间 = 1 × RTT + 服务端处理时间
注意事项:
| 注意点 | 说明 |
|---|---|
| 不是原子操作 | Pipeline 只是打包发送,命令仍按顺序执行,但不保证原子性 |
| 结果顺序 | 返回结果顺序和发送顺序一致 |
| 数据量控制 | 一次 Pipeline 命令过多会阻塞 Redis,建议每批 100-1000 个 |
| MGET/MSET | 对于同一类型的批量操作,MGET/MSET 比 Pipeline 更高效 |
Practice(实践)
// 真实业务:Pipeline 批量查询商品信息
type ProductBatchService struct {
rdb *redis.Client
}
func (s *ProductBatchService) BatchGetProducts(ctx context.Context, productIds []int64) ([]*Product, error) {
var products []*Product
// 分批 Pipeline,每批 100 个
batchSize := 100
for i := 0; i < len(productIds); i += batchSize {
end := i + batchSize
if end > len(productIds) {
end = len(productIds)
}
batch := productIds[i:end]
pipe := s.rdb.Pipeline()
cmds := make([]*redis.StringCmd, len(batch))
for j, id := range batch {
cmds[j] = pipe.Get(ctx, fmt.Sprintf("product:%d", id))
}
_, err := pipe.Exec(ctx)
if err != nil && err != redis.Nil {
return nil, err
}
for j, cmd := range cmds {
json, err := cmd.Result()
if err == nil {
var product Product
if err := json.Unmarshal(&product); err == nil {
products = append(products, &product)
}
} else {
products = append(products, nil) // 保持位置对应
}
_ = j
}
}
return products, nil
}
// MGET 批量查询(比 Pipeline 更高效)
func (s *ProductBatchService) MGet(ctx context.Context, keys []string) ([]string, error) {
return s.rdb.MGet(ctx, keys...).Result()
}业界案例:拼多多商品搜索使用 Pipeline 批量获取商品属性——单次搜索返回 100 个商品,Pipeline 一次查询所有商品缓存,RTT 从 100ms 降到 2ms。
8.2 Lua 脚本
TL;DR
Lua 脚本在 Redis 服务端原子执行多个命令——解决竞态条件,减少网络往返,适合复杂原子操作(如库存扣减、令牌桶限流)。
Theory(理论)
Lua 脚本的优势:
1. 原子性:整个脚本作为一个命令执行,不会被其他命令打断
2. 减少 RTT:多条命令一次发送
3. 服务端执行:减少网络传输
注意:
- 脚本执行期间会阻塞 Redis 主线程(单线程)
- 脚本复杂度不能太高,避免长时间阻塞
- 推荐 EVALSHA 而非 EVAL(减少脚本传输)
EVAL vs EVALSHA:
| 命令 | 说明 |
|---|---|
| EVAL script numkeys key [key ...] arg [arg ...] | 直接执行脚本 |
| EVALSHA sha1 numkeys key [key ...] arg [arg ...] | 执行缓存的脚本(SHA1 标识) |
| SCRIPT LOAD script | 加载脚本到缓存 |
| SCRIPT EXISTS sha1 | 检查脚本是否已缓存 |
Practice(实践)
// 真实业务:原子库存扣减(Lua 脚本保证原子性)
type StockService struct {
rdb *redis.Client
}
// Lua 脚本:扣减库存,返回扣减后的库存(如果库存不足返回 -1)
const deductStockScript = `
local stock = tonumber(redis.call('get', KEYS[1]));
if stock == nil then return -2; end;
if stock <= 0 then return -1; end;
redis.call('decr', KEYS[1]);
return stock - 1;
`
func (s *StockService) DeductStock(ctx context.Context, productId string) (int64, error) {
sha, err := s.rdb.ScriptLoad(ctx, deductStockScript).Result()
if err != nil {
return 0, err
}
result, err := s.rdb.EvalSha(ctx, sha, []string{"stock:" + productId}).Int64()
if err != nil {
return 0, err
}
return result, nil
}
// 令牌桶限流 Lua 脚本
const rateLimitScript = `
local key = KEYS[1]
local rate = tonumber(ARGV[1])
local capacity = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local requested = tonumber(ARGV[4])
local fill_time = capacity / rate
local ttl = math.floor(fill_time * 2)
local last_tokens = redis.call('get', key)
if last_tokens == false then
last_tokens = capacity
end
local last_updated = redis.call('get', key .. ':last_updated')
if last_updated == false then
last_updated = 0
end
local delta = math.max(0, now - tonumber(last_updated))
local filled_tokens = math.min(capacity, tonumber(last_tokens) + (delta * rate / 1000))
local allowed = filled_tokens >= requested
local new_tokens = filled_tokens
if allowed then
new_tokens = filled_tokens - requested
end
redis.call('setex', key, ttl, new_tokens)
redis.call('setex', key .. ':last_updated', ttl, now)
return allowed and 1 or 0
`
func (s *StockService) RateLimit(ctx context.Context, key string, rate float64, capacity int64) (bool, error) {
sha, err := s.rdb.ScriptLoad(ctx, rateLimitScript).Result()
if err != nil {
return false, err
}
now := time.Now().UnixMilli()
result, err := s.rdb.EvalSha(ctx, sha, []string{key},
rate, capacity, now, 1).Int64()
if err != nil {
return false, err
}
return result == 1, nil
}业界案例:支付宝使用 Lua 脚本实现红包库存扣减——Lua 原子执行"查库存→扣减→记录流水",避免高并发下的超卖问题。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| Lua 脚本能替代事务 | Lua 脚本比事务更灵活,但长时间脚本会阻塞 Redis |
| Lua 脚本一定快 | 复杂脚本在服务端执行,可能阻塞其他命令 |
| EVAL 和 EVALSHA 效果一样 | EVALSHA 避免重复传输脚本,但脚本不在缓存时会报错 |
8.3 连接池与慢查询优化
TL;DR
连接池避免频繁创建连接的开销,慢查询日志定位性能瓶颈——两者是 Redis 性能调优的基础配置。
Theory(理论)
连接池配置:
| 参数 | 说明 | 推荐值 |
|---|---|---|
| maxTotal | 最大连接数 | 50-100(根据 QPS 调整) |
| maxIdle | 最大空闲连接 | 20-50 |
| minIdle | 最小空闲连接 | 10 |
| maxWaitMillis | 获取连接最大等待时间 | 3000ms |
| testOnBorrow | 获取时检测 | false(性能考虑) |
| testWhileIdle | 空闲时检测 | true |
慢查询配置:
slowlog-log-slower-than 10000 # 超过 10ms 记录
slowlog-max-len 128 # 最多保留 128 条慢查询分析:
# 查看慢查询
SLOWLOG GET 10
# 典型慢查询原因:
1. 大 key 操作(DEL bigkey, HGETALL big-hash)
2. 复杂聚合(SINTER large-set1 large-set2)
3. KEYS *(全表扫描,生产禁用)
4. 大量 Pipeline 命令阻塞生产禁用命令:
| 命令 | 原因 | 替代方案 |
|---|---|---|
| KEYS | 全表扫描,O(N) | SCAN |
| FLUSHALL/FLUSHDB | 清空所有数据 | —(配置 rename-command 禁用) |
| DEBUG SEGFAULT | 崩溃调试 | —(禁用) |
| CONFIG SET | 修改配置 | —(限制权限) |
Practice(实践)
// go-redis 连接池配置
func NewRedisClient() *redis.Client {
return redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "password",
DB: 0,
PoolSize: 100, // 连接池大小
MinIdleConns: 10, // 最小空闲连接
MaxRetries: 3, // 最大重试次数
DialTimeout: 5 * time.Second, // 连接超时
ReadTimeout: 3 * time.Second, // 读超时
WriteTimeout: 3 * time.Second, // 写超时
PoolTimeout: 4 * time.Second, // 获取连接超时
})
}业界案例:美团 Redis 客户端统一使用 Lettuce——基于 Netty 的异步非阻塞 IO,单机连接数从 Jedis 的 1000+ 降到 10,CPU 和内存占用显著降低。
9. Redis 线程模型
TL;DR
Redis 是单线程的(命令执行),但 Redis 6.0+ 引入多线程 IO——理解单线程设计的原因和多线程 IO 的优化边界,是回答"Redis 为什么快"的关键。
9.1 单线程模型
Situation(场景)
面试官最爱问:"Redis 是单线程的,为什么还能支持 10 万 QPS?"——这不是在考单线程,而是在考你对 IO 多路复用、内存操作、无锁设计的理解。
Theory(理论)
Redis 单线程指的是什么?
Redis 的单线程是指:
✅ 命令执行是单线程的(核心工作线程)
❌ 不是整个 Redis 只有一个线程
Redis 6.0 之前的线程:
├── 主线程:接收连接 → 解析命令 → 执行命令 → 返回结果
├── bio 线程:关闭文件、AOF 刷盘(后台 IO)
└── 子进程:RDB bgsave、AOF rewrite
Redis 6.0+ 的线程:
├── 主线程:命令执行(仍是单线程)
├── IO 线程:网络读写(多线程,可配置)
├── bio 线程:关闭文件、AOF 刷盘
└── 子进程:RDB bgsave、AOF rewrite
为什么命令执行用单线程?
| 原因 | 说明 |
|---|---|
| 避免锁开销 | 单线程无锁,没有上下文切换、没有锁竞争 |
| 内存操作快 | Redis 操作都是内存操作,瓶颈不在 CPU 而在网络 IO |
| 简化设计 | 不用考虑并发安全,原子性天然保证 |
| 顺序执行 | 命令按到达顺序执行,可预测性强 |
Redis 为什么快?
1. 纯内存操作(纳秒级访问)
2. IO 多路复用(epoll/kqueue),单线程处理大量连接
3. 高效的数据结构(SDS、跳表、整数集合)
4. 避免系统调用(数据在用户态处理)
5. 协议简单(RESP 协议解析快)
IO 多路复用原理:
传统阻塞 IO:
- 每个连接一个线程 → 1 万个连接 = 1 万个线程 → 上下文切换爆炸
IO 多路复用(epoll):
- 一个线程监控多个 socket 的就绪状态
- socket 有数据时才进行读写
- 没有数据时不阻塞,处理其他 socket
epoll 优势(vs select/poll):
- 没有文件描述符数量限制(select 限制 1024)
- 使用事件驱动,只有活跃的 socket 才通知
- 时间复杂度 O(1)(select/poll 是 O(N))
Practice(实践)
# 查看 Redis 使用的多路复用机制
redis-cli INFO server | grep multiplexing_api
# 输出:multiplexing_api:epoll
# 生产环境配置
# redis.conf
tcp-keepalive 300 # TCP keepalive,检测死连接
tcp-backlog 511 # TCP 连接队列
timeout 0 # 客户端空闲不断开(0=永不)常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| Redis 只有一个线程 | 命令执行单线程,但有 bio 线程和子进程 |
| 单线程不能利用多核 | 可以启动多个 Redis 实例(端口不同),每个用一个核 |
| Redis 慢是因为单线程 | 慢通常是因为大 key、复杂命令、网络延迟,不是单线程本身 |
| 多线程一定比单线程快 | 内存操作场景下,单线程无锁往往更快 |
9.2 Redis 6.0+ 多线程 IO
TL;DR
Redis 6.0 引入多线程 IO——主线程仍是单线程执行命令,但网络读写可以并行处理,提升网络密集型场景的性能。
Theory(理论)
多线程 IO 设计:
Redis 6.0+ 多线程模式:
1. 主线程接收新连接
2. IO 线程并行读取客户端请求(socket → 解析命令)
3. 主线程串行执行命令(保持单线程原子性)
4. IO 线程并行写回响应(序列化结果 → socket)
配置:
io-threads 4 # IO 线程数(建议 = CPU 核数)
io-threads-do-reads yes # IO 线程也处理读
多线程 IO 的适用场景:
| 场景 | 效果 |
|---|---|
| 大量小 key 读取 | 明显提升(网络 IO 是瓶颈) |
| 大 value 读取 | 提升有限(主线程执行仍是瓶颈) |
| 写密集型 | 提升有限(写操作本身快,网络不是瓶颈) |
| 复杂命令 | 无提升(主线程执行是瓶颈) |
Redis 7.0 新特性:
- Function:持久化的 Lua 函数(替代 EVALSHA)
- Sharded Pub/Sub:Cluster 模式下按槽位分片的发布订阅
- MP-AOF:多部分 AOF,减少 rewrite 开销
Practice(实践)
# Redis 6.0+ 多线程配置
io-threads 4
io-threads-do-reads yes
# 注意:
# 1. 建议 4-8 个 IO 线程,太多反而有上下文切换开销
# 2. 如果服务器有 8 核,可以配 io-threads 4,留 4 核给主线程和系统
# 3. 默认关闭,需要显式开启业界案例:字节跳动在 Redis 6.0 多线程 IO 上线后,读密集型服务(缓存读取)QPS 提升约 30-50%,但写密集型服务提升不明显,仍保持单线程配置。
Extension(延伸)
- 追问:Redis 为什么不用多线程执行命令? → 内存操作本来就快,多线程需要加锁,锁竞争的开销大于并行收益
- 追问:Redis 和 Memcached 的多线程区别? → Memcached 是多线程处理命令(worker 线程池),Redis 是单线程命令 + 多线程 IO
- 追问:Redis 7.0 的 Function 有什么用? → 持久化的服务端函数,重启后仍然存在,替代 EVALSHA 的脚本缓存
10. Redis 与数据库一致性
TL;DR
缓存与数据库的一致性没有银弹——Cache-Aside 是业界主流,延迟双删是折中方案,最终一致性是大多数场景可接受的现实。
10.1 缓存更新策略
Situation(场景)
写数据时先更新缓存还是先更新数据库?删缓存还是更新缓存?这是 Redis 面试最经典的问题之一,考察你对分布式一致性的理解。
Theory(理论)
四种缓存更新策略:
| 策略 | 写操作 | 读操作 | 优点 | 缺点 |
|---|---|---|---|---|
| Cache-Aside(旁路缓存) | 先写 DB,再删缓存 | 先读缓存,miss 读 DB 并回填 | 简单、灵活 | 有短暂不一致窗口 |
| Read-Through | 只写 DB | 读缓存,miss 由缓存层自动读 DB | 对应用透明 | 需要缓存框架支持 |
| Write-Through | 同时写 DB 和缓存 | 读缓存 | 强一致 | 写延迟高 |
| Write-Behind | 只写缓存,异步刷 DB | 读缓存 | 写性能极高 | 可能丢数据 |
Cache-Aside 的两种方案对比:
方案 A:先更新数据库,再删除缓存(推荐)
1. 写 DB
2. 删缓存
问题:如果删缓存失败 → 缓存和 DB 不一致
解决:消息队列补偿删除、Canal 订阅 binlog 删缓存
方案 B:先删除缓存,再更新数据库
1. 删缓存
2. 写 DB
问题:删缓存后、写 DB 前,其他线程读 DB 旧数据回填缓存 → 不一致
解决:延迟双删
为什么更新缓存不如删除缓存?
更新缓存的问题:
1. 写数据库后更新缓存 → 如果两个并发写,后写 DB 的先更新缓存 → 缓存是旧值
2. 缓存计算成本高 → 更新缓存需要重新计算,删缓存让下次读时懒加载
3. 写放大 → 频繁更新导致缓存频繁变动
删除缓存的优势:
1. 简单,不会引入复杂的竞态条件
2. 懒加载,下次读时才重建
3. 适合读多写少场景
Practice(实践)
// 真实业务:Cache-Aside 模式
type ProductCacheService struct {
rdb *redis.Client
productRepo *ProductRepository
}
// 读:先读缓存,miss 读 DB
func (s *ProductCacheService) GetProduct(ctx context.Context, productId int64) (*Product, error) {
key := fmt.Sprintf("product:%d", productId)
// 先读缓存
json, err := s.rdb.Get(ctx, key).Result()
if err == nil {
var product Product
if err := json.Unmarshal(&product); err == nil {
return &product, nil
}
}
// miss 读 DB
product, err := s.productRepo.FindById(ctx, productId)
if err != nil {
return nil, err
}
if product != nil {
data, _ := json.Marshal(product)
s.rdb.Set(ctx, key, data, 1*time.Hour)
}
return product, nil
}
// 写:先写 DB,再删缓存
func (s *ProductCacheService) UpdateProduct(ctx context.Context, product *Product) error {
err := s.productRepo.Save(ctx, product)
if err != nil {
return err
}
key := fmt.Sprintf("product:%d", product.ID)
return s.rdb.Del(ctx, key).Err()
}10.2 延迟双删与 Binlog 监听
TL;DR
延迟双删解决"删缓存后、写 DB 前"的并发读问题;Canal 监听 Binlog 实现最终一致——是生产环境最常用的两种补偿方案。
Theory(理论)
延迟双删:
1. 先删除缓存
2. 更新数据库
3. 休眠 500ms(主从同步延迟 + 读操作完成时间)
4. 再次删除缓存
为什么有效?
- 步骤 1 删缓存后,并发读会打到 DB
- 步骤 2 更新 DB
- 步骤 3 等待一段时间,确保并发读已回填旧值到缓存
- 步骤 4 再次删除缓存,清除旧值
- 下次读 → 读 DB 新值 → 回填新缓存
休眠时间怎么定?
- 主从同步延迟(通常 < 100ms)
- 业务读操作时间
- 经验值:200-1000ms
Canal + 消息队列方案:
Canal 监听 MySQL Binlog → 解析变更 → 发送 MQ → 消费者删缓存
优点:
- 和业务代码解耦
- 最终一致性强
- 不依赖业务层的删除操作
架构:
MySQL → Canal Server → Kafka → Consumer → Redis DEL
Practice(实践)
// 延迟双删实现
type ProductServiceWithDelay struct {
rdb *redis.Client
productRepo *ProductRepository
}
func (s *ProductServiceWithDelay) UpdateProduct(ctx context.Context, product *Product) error {
key := fmt.Sprintf("product:%d", product.ID)
// 第一次删除
s.rdb.Del(ctx, key)
// 更新数据库
err := s.productRepo.Save(ctx, product)
if err != nil {
return err
}
// 异步延迟删除(避免阻塞主线程)
go func() {
time.Sleep(500 * time.Millisecond)
s.rdb.Del(context.Background(), key)
}()
return nil
}// Canal + Kafka 监听方案
@Component
public class CanalConsumer {
@KafkaListener(topics = "canal-product")
public void onMessage(ConsumerRecord<String, String> record) {
CanalMessage message = JSON.parseObject(record.value(), CanalMessage.class);
if ("UPDATE".equals(message.getType()) || "DELETE".equals(message.getType())) {
for (CanalRow row : message.getData()) {
Long productId = row.getId();
redisTemplate.delete("product:" + productId);
}
}
}
}业界案例:阿里巴巴使用 Canal + RocketMQ 做缓存同步——MySQL 写操作通过 Binlog 异步同步到 Redis,延迟在 100ms 以内,支撑双 11 万亿级数据一致性。
常见误区
| ❌ 误区 | ✅ 正确理解 |
|---|---|
| 延迟双删保证强一致 | 延迟双删只是降低不一致概率,不是强一致 |
| Canal 方案没有延迟 | Canal 有延迟(通常 10-100ms),是最终一致 |
| 先更新缓存再更新 DB 也行 | 缓存更新成功、DB 失败时,缓存是脏数据 |
| 强一致必须用分布式事务 | 大多数缓存场景接受最终一致,强一致代价太高 |
Extension(延伸)
- 追问:读写穿透(Read-Through)和 Cache-Aside 怎么选? → 有成熟缓存框架(如 Caffeine、Spring Cache)用 Read-Through;自定义逻辑用 Cache-Aside
- 追问:缓存和 DB 强一致怎么实现? → 2PC/XA 分布式事务(性能差)或 Paxos/Raft 状态机(复杂),大多数场景不需要
- 追问:并发写怎么保证缓存一致性? → 分布式锁串行化写入 + 版本号乐观锁
11. Redis 实战场景
TL;DR
Redis 的实战价值在于用正确的数据结构解决正确的问题——限流、排行榜、计数器、会话、消息队列是最高频的五个场景。
11.1 限流
Situation(场景)
接口被刷、秒杀超卖、爬虫攻击——限流是保护系统的第一道防线。Redis 是实现限流最常用的工具。
Theory(理论)
三种限流算法:
| 算法 | 原理 | 优点 | 缺点 |
|---|---|---|---|
| 计数器 | 固定窗口计数 | 简单 | 窗口边界突刺 |
| 滑动窗口 | 细分窗口,统计窗口内请求 | 平滑 | 内存占用大 |
| 令牌桶 | 以固定速率产生令牌,请求消耗令牌 | 允许突发 | 实现复杂 |
| 漏桶 | 请求入桶,以固定速率漏出 | 绝对平滑 | 不能应对突发 |
Practice(实践)
// 真实业务:滑动窗口限流(ZSet 实现)
type RateLimiter struct {
rdb *redis.Client
}
// 滑动窗口限流
func (s *RateLimiter) IsAllowed(ctx context.Context, key string, windowSize, maxRequests int64) (bool, error) {
redisKey := "rate:limit:" + key
now := time.Now().UnixMilli()
windowStart := now - windowSize*1000
const luaScript = `
redis.call('zremrangeByScore', KEYS[1], 0, ARGV[1])
local current = redis.call('zcard', KEYS[1])
if current < tonumber(ARGV[2]) then
redis.call('zadd', KEYS[1], ARGV[3], ARGV[3])
redis.call('expire', KEYS[1], ARGV[4])
return 1
else
return 0
end
`
result, err := s.rdb.Eval(ctx, luaScript, []string{redisKey},
windowStart, maxRequests, now, windowSize/1000).Int64()
if err != nil {
return false, err
}
return result == 1, nil
}
// 令牌桶限流(Lua 脚本实现)
func (s *RateLimiter) TokenBucket(ctx context.Context, key string, rate float64, capacity, requested int64) (bool, error) {
// 见 8.2 Lua 脚本示例
return false, nil
}业界案例:阿里云 API 网关使用 Redis + 令牌桶实现全站限流——不同接口配置不同 QPS 阈值,超限时返回 429,保护后端服务。
11.2 排行榜
TL;DR
ZSet 是 Redis 最擅长的场景之一——按 score 排序、范围查询、排名统计,游戏排行榜、电商销量榜、视频热榜都依赖它。
Practice(实践)
// 真实业务:视频热度排行榜(ZSet + 时间衰减)
type VideoRankingService struct {
rdb *redis.Client
}
// 热度分 = 播放量 × 1 + 点赞 × 3 + 评论 × 5 + 分享 × 10
func (s *VideoRankingService) UpdateHeatScore(ctx context.Context, videoId string) error {
key := fmt.Sprintf("ranking:daily:%s", time.Now().Format("2006-01-02"))
// 获取各项数据(实际生产从 Redis 获取)
views := s.rdb.Incr(ctx, "video:views:"+videoId).Val()
likes := s.getLikes(videoId)
comments := s.getComments(videoId)
shares := s.getShares(videoId)
score := float64(views)*1 + float64(likes)*3 + float64(comments)*5 + float64(shares)*10
// 使用时间衰减:score = raw_score / (hours_since_publish + 2)^1.5
hours := s.getHoursSincePublish(videoId)
decayedScore := score / math.Pow(hours+2, 1.5)
return s.rdb.ZAdd(ctx, key, redis.Z{Score: decayedScore, Member: videoId}).Err()
}
// 获取 Top 100
func (s *VideoRankingService) GetTop100(ctx context.Context) ([]redis.Z, error) {
key := fmt.Sprintf("ranking:daily:%s", time.Now().Format("2006-01-02"))
return s.rdb.ZRevRangeWithScores(ctx, key, 0, 99).Result()
}
// 获取视频排名
func (s *VideoRankingService) GetVideoRank(ctx context.Context, videoId string) (int64, error) {
key := fmt.Sprintf("ranking:daily:%s", time.Now().Format("2006-01-02"))
return s.rdb.ZRevRank(ctx, key, videoId).Result()
}
func (s *VideoRankingService) getLikes(videoId string) int64 { return 0 }
func (s *VideoRankingService) getComments(videoId string) int64 { return 0 }
func (s *VideoRankingService) getShares(videoId string) int64 { return 0 }
func (s *VideoRankingService) getHoursSincePublish(videoId string) float64 {
return 1.0
}业界案例:B 站视频排行榜使用 Redis ZSet + 时间衰减算法——新视频有热度加成,老视频热度衰减,确保榜单新鲜度。亿级视频、百万级日更新,ZSet 查询 P99 < 10ms。
11.3 计数器与会话
Practice(实践)
// 真实业务:视频播放量计数(String + INCR)
type ViewCounter struct {
rdb *redis.Client
}
func (s *ViewCounter) IncrementView(ctx context.Context, videoId string) error {
key := fmt.Sprintf("video:views:%s", videoId)
return s.rdb.Incr(ctx, key).Err()
// 异步批量写入数据库(定时任务或消息队列)
}
// 真实业务:用户会话管理(Hash 存会话属性)
type SessionService struct {
rdb *redis.Client
}
type Session struct {
UserId int64
Username string
LoginTime int64
}
func (s *SessionService) CreateSession(ctx context.Context, sessionId string, user *User) error {
key := "session:" + sessionId
return s.rdb.HSet(ctx, key, map[string]interface{}{
"userId": user.ID,
"username": user.Username,
"loginTime": time.Now().UnixMilli(),
}, 30*time.Minute).Err()
}
func (s *SessionService) GetSession(ctx context.Context, sessionId string) (*Session, error) {
key := "session:" + sessionId
result, err := s.rdb.HGetAll(ctx, key).Result()
if err != nil {
return nil, err
}
if len(result) == 0 {
return nil, nil
}
session := &Session{
UserId: parseInt(result["userId"]),
Username: result["username"],
LoginTime: parseInt(result["loginTime"]),
}
// 续期
s.rdb.Expire(ctx, key, 30*time.Minute)
return session, nil
}业界案例:微信使用 Redis Hash 存储用户在线状态——每个用户一个 Hash,包含在线状态、最后心跳时间、设备信息,ZSet 维护最近活跃用户列表,支持亿级在线用户实时状态查询。
面试速查表
高频问题 TOP 20
| # | 问题 | 核心关键词 | 参考章节 |
|---|---|---|---|
| 1 | Redis 为什么快? | 内存 + 单线程 + IO 多路复用 + 高效数据结构 | 9.1 |
| 2 | Redis 是单线程的吗? | 命令执行单线程,6.0+ 多线程 IO | 9 |
| 3 | String 底层实现 | SDS + int/embstr/raw 编码 | 1.1 |
| 4 | Hash 的底层编码 | ziplist / hashtable 转换条件 | 1.2 |
| 5 | ZSet 底层结构 | 跳表 + 哈希表,为什么不用红黑树 | 1.5 |
| 6 | Redis 持久化 RDB vs AOF | 快照 vs 日志,混合持久化 | 3 |
| 7 | Redis 主从复制原理 | PSYNC + 复制缓冲区 + COW | 4.1 |
| 8 | Redis Cluster 槽位分片 | 16384 槽 + Gossip + MOVED | 4.3 |
| 9 | Redis 分布式锁实现 | SET NX EX + Lua 释放 + Redisson | 5 |
| 10 | RedLock 争议 | 时钟漂移 + 不是真正的 CP | 5.2 |
| 11 | 缓存穿透/击穿/雪崩 | 布隆过滤器 + 互斥锁 + 随机 TTL | 6 |
| 12 | 缓存与数据库一致性 | Cache-Aside + 延迟双删 + Canal | 10 |
| 13 | Redis 内存淘汰策略 | 8 种策略,LRU/LFU 区别 | 7.2 |
| 14 | BigKey / HotKey 排查 | --bigkeys / --hotkeys / 拆分 | 7.3 |
| 15 | Pipeline vs Lua | 批量发送 vs 服务端原子执行 | 8 |
| 16 | Redis 过期删除策略 | 惰性删除 + 定期删除 | 7.1 |
| 17 | Redis 事务 | MULTI/EXEC/WATCH,不是真正的 ACID | 扩展 |
| 18 | Redis 6.0 多线程 IO | IO 线程读写,主线程执行命令 | 9.2 |
| 19 | 限流算法实现 | 计数器 / 滑动窗口 / 令牌桶 | 11.1 |
| 20 | Redis 实战场景 | 排行榜 / 计数器 / 会话 / 消息队列 | 11 |
类比速记
| 概念 | 类比 |
|---|---|
| Redis 单线程 | 单车道高速公路(没有并道冲突,但车多会堵) |
| Pipeline | 快递批量发货(一次发一车,而不是一车一送) |
| Lua 脚本 | 预制菜(厨房一次性做好,不用一个个炒) |
| 缓存穿透 | 查无此人还反复查档案室(布隆过滤器 = 门口的查询机) |
| 缓存击穿 | 热门商品标签刚好掉了(互斥锁 = 一个人去补标签) |
| 缓存雪崩 | 所有商品标签同时掉了(随机 TTL = 错峰换标签) |
| 分布式锁 | 公共洗手间门锁(进去就锁,出来就开) |
| 令牌桶限流 | 游乐园发门票(固定速率发,游客排队领) |
| ZSet 跳表 | 带快速通道的楼梯(每层有跳板,跳得更快) |
| RDB | 拍照备份(快但可能漏掉拍照期间的修改) |
| AOF | 写日记(全但恢复慢,日记太多要重写) |
本文档由 kimi-k2.6 模型生成,面向 Senior/Staff 级别后端开发面试准备。 核心方法论:原理 + 实战 + 源码,STAR 框架组织答案,误区对比加深理解。 代码示例同时包含 Go 和 Java 双语言实现。