面试题集锦:Redis 核心问答大全

通识对照:Redis 数据结构选型:先访问模式,再底层编码

面试题集锦:Redis 核心问答大全

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


Generated by kimi-k2.6 model

面向 Senior/Staff 级别后端开发岗位的 Redis 系统性面试准备文档。涵盖数据结构、持久化、高可用、分布式锁、缓存、性能优化等核心知识点,深度解析原理 + 实战 + 源码。


目录

  1. Redis 基础数据结构
  2. Redis 高级数据结构
  3. Redis 持久化
  4. Redis 高可用架构
  5. Redis 分布式锁
  6. Redis 缓存问题
  7. Redis 内存管理与淘汰策略
  8. Redis 性能优化
  9. Redis 线程模型
  10. Redis 与数据库一致性
  11. 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 + listpackziplist 替换为 listpack(解决连锁更新)

quicklist 结构:

quicklist
├── head → quicklistNode(ziplist) → quicklistNode(ziplist) → ... → tail
│
每个 quicklistNode 包含一个 ziplist
配置:list-max-ziplist-size = -2(每个 ziplist 不超过 8KB)
      list-compress-depth = 0(两端不压缩)

List 的核心操作:

操作时间复杂度说明
LPUSH/RPUSHO(1)头/尾插入
LPOP/RPOPO(1)头/尾弹出
LRANGEO(S+N)范围查询,N 是返回元素数
LINDEXO(N)按索引查,需要遍历 ziplist
LTRIMO(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/SREMO(1)添加/删除
SISMEMBERO(1)判断是否存在
SINTER/SUNION/SDIFFO(N*M)集合运算,数据量大时谨慎
SRANDMEMBERO(N)随机取 N 个元素
SPOPO(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 的核心操作:

操作时间复杂度说明
ZADDO(log N)添加/更新
ZRANGE/ZREVRANGEO(log N + M)按排名范围查
ZRANGEBYSCOREO(log N + M)按 score 范围查
ZRANK/ZREVRANKO(log N)查排名
ZREMO(log N)删除
ZINCRBYO(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 valueO(1)设置某一位
GETBIT key offsetO(1)获取某一位
BITCOUNT keyO(N)统计 1 的个数
BITOP AND/OR/XOR/NOTO(N)位运算
BITPOS key bitO(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:

特性ListStreamKafka
消息持久化无有(可配置 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 可以替代 KafkaStream 适合小规模(单机百万级),大数据量仍需要 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 ""         # 禁用 RDB

RDB 的优缺点:

优点缺点
文件紧凑,恢复速度快可能丢失两次快照间的数据
适合备份、灾难恢复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 64mb

3.3 混合持久化(RDB + AOF)

TL;DR

Redis 4.0 引入混合持久化——AOF 文件前半部分是 RDB 格式(快照),后半部分是 AOF 格式(增量日志)——兼顾恢复速度和数据安全。

Theory(理论)

混合持久化原理:

AOF 文件结构(混合模式):
┌─────────────────┬──────────────────────┐
│  RDB 格式数据    │  AOF 格式增量日志     │
│  (全量快照)     │  (重写后的写命令)    │
└─────────────────┴──────────────────────┘

恢复流程:
1. 先加载 RDB 部分(快)
2. 再重放 AOF 部分(补增量)

三种持久化方案对比:

维度RDBAOF混合持久化
数据安全可能丢快照间隔数据最多丢 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 就不需要 RDBRDB 用于快速全量恢复,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:

维度LRULFU
依据最近一次访问时间访问频率
问题突发大量扫描会污染缓存历史频率高但近期不访问的 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 大小
自带监控INFOinfo 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

#问题核心关键词参考章节
1Redis 为什么快?内存 + 单线程 + IO 多路复用 + 高效数据结构9.1
2Redis 是单线程的吗?命令执行单线程,6.0+ 多线程 IO9
3String 底层实现SDS + int/embstr/raw 编码1.1
4Hash 的底层编码ziplist / hashtable 转换条件1.2
5ZSet 底层结构跳表 + 哈希表,为什么不用红黑树1.5
6Redis 持久化 RDB vs AOF快照 vs 日志,混合持久化3
7Redis 主从复制原理PSYNC + 复制缓冲区 + COW4.1
8Redis Cluster 槽位分片16384 槽 + Gossip + MOVED4.3
9Redis 分布式锁实现SET NX EX + Lua 释放 + Redisson5
10RedLock 争议时钟漂移 + 不是真正的 CP5.2
11缓存穿透/击穿/雪崩布隆过滤器 + 互斥锁 + 随机 TTL6
12缓存与数据库一致性Cache-Aside + 延迟双删 + Canal10
13Redis 内存淘汰策略8 种策略,LRU/LFU 区别7.2
14BigKey / HotKey 排查--bigkeys / --hotkeys / 拆分7.3
15Pipeline vs Lua批量发送 vs 服务端原子执行8
16Redis 过期删除策略惰性删除 + 定期删除7.1
17Redis 事务MULTI/EXEC/WATCH,不是真正的 ACID扩展
18Redis 6.0 多线程 IOIO 线程读写,主线程执行命令9.2
19限流算法实现计数器 / 滑动窗口 / 令牌桶11.1
20Redis 实战场景排行榜 / 计数器 / 会话 / 消息队列11

类比速记

概念类比
Redis 单线程单车道高速公路(没有并道冲突,但车多会堵)
Pipeline快递批量发货(一次发一车,而不是一车一送)
Lua 脚本预制菜(厨房一次性做好,不用一个个炒)
缓存穿透查无此人还反复查档案室(布隆过滤器 = 门口的查询机)
缓存击穿热门商品标签刚好掉了(互斥锁 = 一个人去补标签)
缓存雪崩所有商品标签同时掉了(随机 TTL = 错峰换标签)
分布式锁公共洗手间门锁(进去就锁,出来就开)
令牌桶限流游乐园发门票(固定速率发,游客排队领)
ZSet 跳表带快速通道的楼梯(每层有跳板,跳得更快)
RDB拍照备份(快但可能漏掉拍照期间的修改)
AOF写日记(全但恢复慢,日记太多要重写)

本文档由 kimi-k2.6 模型生成,面向 Senior/Staff 级别后端开发面试准备。 核心方法论:原理 + 实战 + 源码,STAR 框架组织答案,误区对比加深理解。 代码示例同时包含 Go 和 Java 双语言实现。