redis 面试题
阅读方式:Redis 面试是一条由浅入深的追问链,不要按知识点背。面试官从「为什么快」切开, 一层层往下挖:快 → 数据怎么存(内存淘汰 / 底层结构)→ 宕机丢多少(持久化)→ 缓存出问题怎么办(三大问题 / 一致性)→ 主挂了怎么办(主从 / 哨兵 / Cluster)→ 并发控制(事务 / 分布式锁)→ 线上排障(Pipeline / 大 key 热 key)。
每个结论后面都要能再接一层「为什么」和「出了事怎么办」——这是 2026 年大厂 Redis 面的筛选标准。
重点索引
标记说明:🔥🔥🔥 核心必背(2026 高频,优先吃透) | 🔥🔥 高频 | 🔥 进阶加分🎙️ = 配了 90 秒口述版,面试前可直接照着练。
| 编号 | 题目 | 重点 | 口述版 | 一句话抓手 |
|---|---|---|---|---|
| Q1 | Redis 为什么快 | 🔥🔥🔥 | 🎙️ | 五层:内存 / 单线程 / 多路复用 / 数据结构 / C |
| Q2 | 过期删除与内存淘汰 | 🔥🔥 | — | 惰性 + 定期;8 种淘汰重点看 3 种 |
| Q3 | ZSet 为什么用跳表 | 🔥🔥 | — | 范围查询 + 实现简单;dict + skiplist |
| Q4 | SDS 相比 C 字符串 | 🔥 | — | len / 二进制安全 / 防溢出 / 预分配 |
| Q5 | RDB / AOF / 混合宕机丢多少 | 🔥🔥🔥 | 🎙️ | 1 秒窗口;恢复优先 AOF |
| Q6 | 穿透、击穿、雪崩 | 🔥🔥🔥 | 🎙️ | 不存在 / 单点过期 / 批量失效 |
| Q7 | 缓存与数据库一致性 | 🔥🔥🔥 | 🎙️ | 最终一致;Cache-Aside + 延迟双删 |
| Q8 | 主从全量与增量同步 | 🔥🔥 | — | RDB + 缓冲区;repl_backlog + offset |
| Q9 | 哨兵与脑裂 | 🔥🔥🔥 | 🎙️ | 监控 / 通知 / 切换;异步复制 + 分区 |
| Q10 | Cluster 槽与 MOVED/ASK | 🔥🔥 | — | 16384 槽;2KB 位图是折中 |
| Q11 | 事务支持回滚吗 | 🔥 | — | 不支持;执行期错误继续执行 |
| Q12 | 分布式锁与看门狗 | 🔥🔥🔥 | 🎙️ | SET NX PX + Lua;续期;主从丢锁 |
| Q13 | Pipeline 与事务区别 | 🔥🔥 | — | 客户端批量 vs 服务端排队 |
| Q14 | 大 key / 热 key | 🔥🔥 | — | 发现靠监控,处理靠拆分与本地缓存 |
一、基础与线程模型(开场必问,决定追问深度)
Q1 Redis 为什么快? 🔥🔥🔥
🎙️ 90 秒口述版
我不会只答「因为在内存里」,那个答案太薄。我一般分五层讲。
第一层纯内存操作,读写延迟纳秒级,这是底座。第二层单线程执行命令,避免上下文切换和锁竞争,还天然保证命令原子性。第三层 I/O 多路复用,基于 epoll,一个线程管上万连接,把瓶颈从 CPU 挪到网络 I/O 上。第四层是极致优化的数据结构,SDS、跳表、压缩列表,单操作复杂度极低。第五层 C 语言实现,贴近操作系统,没有高级语言运行时的开销。
这里我会主动接一个陷阱追问:6.0 之后还是单线程吗?答案是 6.0 引入的是多线程 I/O,只把网络请求收发和协议解析交给多线程,核心命令执行仍然是单线程,单线程模型的本质没变——所以「原子性」这个结论依然成立。
答题骨架:五层
- 纯内存操作:读写延迟纳秒级,性能底座。
- 单线程执行命令:避免上下文切换和锁竞争,天然保证命令原子性。
- I/O 多路复用:基于 epoll 单线程管理上万连接,瓶颈从 CPU 转移到网络 I/O。
- 极致优化的数据结构:SDS、跳表、压缩列表等,单操作时间复杂度极低。
- C 语言实现:贴近操作系统,无高级语言运行时开销。
踩分点 / 追问方向
- 「6.0+ 还是单线程吗?」——多线程 I/O 只负责网络收发与协议解析,命令执行仍单线程,本质未变。
- 「既然单线程,为什么还要关注慢命令?」——单线程意味着一条慢命令会阻塞后续所有命令,这正是
KEYS、大 key 删除、大范围ZRANGE危险的根源(见 Q14 与附录)。 - 「为什么不把数据都放内存就更慢了?」——磁盘 I/O 会直接破坏纳秒级延迟;Redis 用异步方式落盘,兼顾速度与持久化。当设置了
maxmemory且达到上限,达到限值后不能继续插入新值。
Q2 过期键删除策略和内存淘汰机制 🔥🔥
答题骨架
过期删除是 惰性删除 + 定期删除 的组合:
- 惰性删除:访问 key 时才检查是否过期,对 CPU 友好,但永不被访问的过期 key 会堆积内存。
- 定期删除:每 100ms 随机抽样检查并清理(
hz配置控制频率),在 CPU 与内存之间取平衡。
内存淘汰 8 种策略(Redis 4.0 后新增 volatile-lfu / allkeys-lfu),生产重点关注三个:
| 策略 | 适用场景 |
|---|---|
allkeys-lru | 通用缓存场景首选 |
allkeys-lfu | 冷热区分明确、热点固定(如热榜) |
volatile-lru / volatile-lfu | 只淘汰设了过期时间的 key,保护永久数据不被误淘汰 |
踩分点 / 追问方向
- 「Redis 的 LRU 是严格的吗?」——近似 LRU:通过随机抽样(默认 5 个候选,
maxmemory-samples可调)实现,不维护全量链表,用少量精度换内存和性能。 - 「LFU 好在哪?」——4.0 引入,区分「曾经热但最近不热」和「一直不热」比 LRU 更准,参数
lfu-log-factor/lfu-decay-time控制计数与衰减。 - 「大量 key 同一时间过期要注意什么?」——过期时间加随机值打散,避免集中失效引发雪崩(见 Q6);同时会短时抬升 CPU(清理)和 DB 负载(回填),需提前监控内存水位与过期 key 数量。
- 「内存回收底层怎么做?」——每个键值都是对象,由 jemalloc 等分配器管理;4.0+ 提供
UNLINK以非阻塞方式逐步释放,避免一次性删除大对象阻塞主线程;超过maxmemory时按上述策略淘汰。
二、数据结构与底层设计(区分「会用」和「懂原理」)
Q3 ZSet 为什么用跳表,不用红黑树 / B+ 树? 🔥🔥
答题骨架
这题是数据结构维度的「题眼」:
- 范围查询高效:
ZRANGE、ZRANK只需在底层有序链表上顺序遍历,天然高效;平衡树做范围查询需要中序遍历或复杂的节点拼接。 - 实现复杂度远低于红黑树:插入删除只维护多层索引指针,没有旋转和再平衡开销。
- 并发扩展性好:跳表更容易做无锁 / 细粒度锁优化(虽然 Redis 命令执行是单线程,但设计上保留了扩展性)。
踩分点 / 追问方向
- 「ZSet 只有跳表吗?」——不是。底层是 dict + skiplist 组合:dict 负责 O(1) 按成员查分数(
ZSCORE),skiplist 负责按分数排序和范围操作。 - 「小数据量呢?」——先用一个连续内存结构省内存:元素数 < 128 且每个元素 < 64 字节时用 ziplist(Redis 7.0+ 改用 listpack),超过阈值才转 skiplist + dict。
Q4 SDS 相比 C 字符串解决了什么? 🔥
答题骨架
SDS(简单动态字符串)记录 len 和分配容量,因此:
- 获取长度 O(1),而非 C 字符串的 O(n) 遍历。
- 二进制安全:不以
\0判断结束,可存任意二进制数据。 - 杜绝缓冲区溢出:拼接前检查容量并扩容。
- 减少内存重分配:空间预分配 + 惰性释放。
延伸:String 类型的底层编码有 int / embstr / raw 三种,短字符串用 embstr 一次分配、连续存储,进一步降低分配开销。
三、持久化(2026 面试已从「有哪两种」升级为「宕机丢多少」)
Q5 RDB、AOF 和混合持久化,宕机时分别丢多少数据? 🔥🔥🔥
🎙️ 90 秒口述版
这题我会直接落到「宕机丢多少」和「恢复多快」两个可量化指标上,而不是背概念。
RDB 是 fork 子进程做周期性快照,宕机就丢最后一次快照之后的所有写入,但恢复快——直接加载二进制文件。AOF 是追加写命令,配 everysec 每秒 fsync,最多丢约 1 秒,恢复要重放命令所以慢。4.0 之后的混合持久化,AOF 重写时前半段是 RDB 格式、后面追加 AOF,损失窗口和 everysec 一样约 1 秒,但恢复速度接近 RDB——本质是用 RDB 承载存量加速恢复、用 AOF 追加增量控制损失。
两个必答的追问。第一,同时开了 RDB 和 AOF 用哪个恢复?用 AOF,因为它更完整。第二,AOF 重写期间的新写入会丢吗?不会——子进程重写的同时,主进程把新命令写进 AOF 重写缓冲区和旧 AOF,重写完再把缓冲区追加到新文件。
最后补一句工程约束:fork 和 AOF 重写都吃 CPU 和内存,大实例上要避免在主节点做阻塞式
save,把持久化压力放到从节点或用BGSAVE。
答题骨架
| 方式 | 触发 / 机制 | 宕机数据损失 | 恢复速度 |
|---|---|---|---|
| RDB | fork 子进程,周期性快照 | 丢最后一次快照后的全部写入 | 快(直接加载二进制) |
| AOF(everysec) | 追加写命令,每秒 fsync | 最多丢约 1 秒 | 慢(重放命令) |
| 混合持久化(4.0+) | AOF 重写时前半段 RDB 格式,后续追加 AOF | 同 everysec,约 1 秒 | 接近 RDB |
关键结论:同时开启 RDB 和 AOF 时,恢复优先用 AOF,因为它通常更完整。混合持久化是「恢复速度」与「数据完整性」的工程折中。
踩分点 / 追问方向
- 「AOF 重写期间新写入会丢吗?」——不会。重写由子进程完成,主进程同时把新命令写入 AOF 重写缓冲区和旧 AOF,重写完成后把缓冲区内容追加到新 AOF。
- 「
appendfsync三个选项的取舍?」——always每条 fsync,几乎不丢但最慢;everysec折中(默认);no交给 OS 刷盘,最快但宕机可能丢较多。 - 「主从架构下持久化放哪?」——主节点避免阻塞式
save;数据关键时让从节点开 AOF(每秒同步),主节点专注服务。早期「Master 最好不做任何持久化」的说法以丢数据为代价,不要再当标准答案。 - 「fork 会有什么问题?」——fork 瞬间复制页表、可能阻塞主线程;COW 期间父子进程共享内存页,写入密集时内存占用上升。
四、缓存三大问题 + 一致性(公共必考区,几乎每场后端面试必现)
Q6 穿透、击穿、雪崩的区分与方案 🔥🔥🔥
🎙️ 90 秒口述版
这题我先把三者定义分清楚,因为穿透和击穿最容易被混为一谈。
穿透是查一个根本不存在的数据,缓存没有、DB 也没有,请求每次都穿过缓存打到 DB;首选布隆过滤器拦截,退而求其次缓存空值加短过期。击穿是单个热点 key 恰好过期那一瞬,大量并发同时打 DB;对策是互斥锁重建、逻辑过期,或者热点 key 永不过期。雪崩是大量 key 同时过期或者 Redis 整体挂了,方案要从两个维度答:过期时间加随机值打散,以及多级缓存加熔断降级来扛住单点故障。
区分的口诀我自己是这么记的:穿透是「数据本就不存在」,击穿是「数据存在但缓存恰好在那一刻没了」,雪崩是「批量一起失效」。面试官如果追线上场景,我会讲一次真实止血——先限流和熔断保住 DB,再回填缓存,最后回头查批量过期的原因。
答题骨架
| 问题 | 核心特征 | 首选举措 |
|---|---|---|
| 穿透 | 查不存在的数据,缓存和 DB 都没有 | 布隆过滤器拦截;缓存空值 + 短过期 |
| 击穿 | 单个热点 key 过期瞬间,大量并发打 DB | 互斥锁重建;逻辑过期;热点 key 永不过期 |
| 雪崩 | 大量 key 同时过期或 Redis 整体不可用 | 过期时间加随机值;多级缓存;熔断降级 |
踩分点 / 追问方向
- 「穿透和击穿怎么区分?」——穿透是「数据本就不存在」,击穿是「数据存在但缓存恰好在那一刻没了」。
- 「雪崩的根因是什么?」——批量失效或单点故障,所以要分别从「打散过期时间」和「集群高可用」两个维度回答。
- 「缓存空值有什么坑?」——要设短 TTL,否则大量不存在的 key 会白占内存;且写入期间若 DB 新增了该数据,会出现短暂不一致。
- 「线上真遇到雪崩怎么止血?」——先限流 / 熔断保住 DB,再分批回填缓存,事后追查批量过期原因。
Q7 缓存与数据库一致性怎么保证? 🔥🔥🔥
🎙️ 90 秒口述版
我先定前提:生产上追求的是最终一致性。要强一致就得上分布式事务,性能不可接受。
主流方案是 Cache-Aside 加延迟双删:先删缓存,再更新数据库,延迟一小段时间后再删一次缓存——这个延迟要大于一次读请求的耗时加上主从同步延迟,否则第一轮删完之后,并发读把旧值又回填了。
这里有两个必答的追问。第一,为什么是删除缓存而不是更新缓存?因为并发写场景下,两次更新的执行顺序可能导致缓存里留下旧值;删除是幂等的,把回填交给下一次读,不一致窗口更可控。第二,延迟双删根治了吗?没有——延迟时间难精确设定,第二次删除失败还会留脏数据。一致性要求极高的场景,要走「更新 DB + 发消息异步删缓存 + 失败重试兜底」,或者订阅 binlog 来删,而不是赌一个固定延迟。
答题骨架
先明确前提:生产上追求最终一致性,强一致需分布式事务,性能不可接受。
主流方案 Cache-Aside + 延迟双删:
- 先删除缓存;
- 更新数据库;
- 延迟一段时间(大于一次读请求耗时 + 主从同步延迟),再次删除缓存。
为什么是「删除」而不是「更新缓存」:并发写下两次更新的先后顺序可能让缓存留下旧值;删除幂等,把回填交给 Cache-Aside 的下一次读,不一致窗口更可控。
踩分点 / 追问方向
- 「延迟双删根治了吗?」——没有。降低概率但不根治:延迟时间难精确设定,第二次删除失败仍有脏数据。
- 「更高要求的场景怎么做?」——「更新 DB + 发消息异步删缓存 + 重试兜底」,或订阅 binlog(canal)删缓存。
- 「先更新 DB 还是先删缓存?」——推荐先更新 DB 再删缓存;「先删缓存再更新 DB」更容易被并发读回填旧值,需要延迟双删补救。
五、高可用:主从 → 哨兵 → Cluster(由浅入深的追问链)
Q8 主从复制的全量同步和增量同步 🔥🔥
答题骨架
- 全量同步:slave 首次连接时,master 执行
bgsave生成 RDB,同时用复制缓冲区记录期间的写命令;RDB 发送完毕后再补发缓冲区中的命令。 - 增量同步:依赖
repl_backlog环形缓冲区和offset。slave 断连重连后,若 offset 仍在 backlog 范围内,只同步缺失部分,避免再次全量。
踩分点 / 追问方向
- 「怎么判断该全量还是增量?」——slave 上报自己的 runid 和 offset;runid 匹配且 offset 在 backlog 内则走增量(PSYNC),否则全量。
- 「backlog 太小会怎样?」——断连期间写入超过缓冲区大小,offset 被覆盖,只能全量同步——所以高写入量场景要调大
repl-backlog-size。 - 「主从复制是同步还是异步?」——异步。这是 Q9 脑裂丢数据的根源。
Q9 哨兵的核心作用与脑裂 🔥🔥🔥
🎙️ 90 秒口述版
哨兵我一般三句话概括:监控、通知、自动故障转移。至少 3 个哨兵节点,通过选举 leader 来执行切换。
关键的追问是「切换会不会丢数据」——会,两个来源。第一是主从异步复制,master 挂掉时还有写入没到 slave,这些就没了。第二是脑裂:网络分区把老 master 孤立了,但它还在接写,同时哨兵选出了新 master;分区恢复后老 master 被降级,分区期间写进去的数据全部丢失。
工程解法是配
min-replicas-to-write 1和min-replicas-max-lag 10——主节点至少要有一个健康从节点、且复制延迟不超过 10 秒才允许写入。这样网络分区时老 master 发现自己没有健康从节点,自动拒绝写入,从源头堵住脑裂丢数据。代价是可用性下降:从节点全挂时主节点也拒绝写,这是有意的取舍。还有一层要承认:异步复制带来的那点数据丢失,哨兵本身解决不了,只能靠业务幂等或对账兜底。
答题骨架
哨兵三件事:监控、通知、自动故障转移。至少 3 个节点,通过选举 leader 执行切换。
哨兵切换会丢数据吗?会。 两个来源:
- 主从异步复制:master 挂掉时部分写入尚未到达 slave。
- 脑裂:网络分区导致旧 master 仍在接受写入,新 master 已被选出;恢复后旧 master 降级,分区期间的写入全部丢失。
脑裂的工程解法:配置 min-replicas-to-write 1 和 min-replicas-max-lag 10——主节点至少有一个健康从节点且复制延迟不超过 10 秒才允许写入;网络分区时主节点自动拒绝写入,从源头堵住数据丢失。
踩分点 / 追问方向
- 「这套配置的代价?」——从节点全不健康时主节点也拒绝写入,牺牲可用性换一致性,是有意的取舍。
- 「异步复制导致的丢失能靠哨兵解决吗?」——不能,只能靠业务幂等、对账补偿。
- 「Sentinel 和 Cluster 的分工?」——Sentinel 着眼于高可用(master 宕机自动提升 slave);Cluster 着眼于扩展性(单机内存不足时分片存储)。
Q10 Cluster 的 16384 个槽与 MOVED / ASK 🔥🔥
答题骨架
- 槽位计算:
slot = CRC16(key) % 16384。 - 节点间通过 Gossip 协议交换槽位映射;客户端访问任意节点,节点发现槽不归自己管就返回 MOVED 重定向。
- 扩容 / 缩容迁移期间,槽尚未完全迁移时返回 ASK 重定向,引导客户端临时访问目标节点。
为什么是 16384 而不是 65536:心跳包中槽位位图的大小是关键。16384 槽的位图为 2KB,65536 则为 8KB,集群规模增大时心跳包体积显著膨胀。16384 是槽粒度与心跳开销之间的工程折中。
踩分点 / 追问方向
- 「MOVED 和 ASK 的区别?」——MOVED 表示槽已永久迁走,客户端应更新本地槽位映射;ASK 表示槽正在迁移中,本次临时去目标节点,映射暂不更新。
- 「跨槽多键操作怎么办?」——Cluster 不支持跨槽的 MSET、事务等,除非用
{}哈希标签把相关 key 强制映射到同一槽,例如user:{100}:name与user:{100}:age。 - 「客户端怎么找到节点?」——任意节点都可访问,重定向机制保证最终到达正确节点;主流客户端会缓存槽位表减少重定向。
六、事务、Lua 与分布式锁
Q11 Redis 事务支持回滚吗? 🔥
答题骨架
不支持。 MULTI / EXEC 把命令排队后顺序执行:
- 执行期错误(如类型错误):Redis 继续执行剩余命令,不回滚。
- 入队期语法错误:整个事务在
EXEC时被拒绝执行——这层「事前检查」拦下了大部分严重错误。
设计哲学:执行期错误通常是编程错误,回滚无法修复逻辑问题,反而增加内核复杂度、拖慢性能。
对比:
DISCARD可主动放弃事务;WATCH提供乐观锁式的执行前检查。
Q12 分布式锁:从 SETNX 到 Redisson 看门狗 🔥🔥🔥
🎙️ 90 秒口述版
基础实现我会写成
SET lock_key unique_value NX PX 30000——NX 保证互斥,PX 防死锁,unique_value 用来标识持有者。释放的时候必须用 Lua 脚本先 GET 比对身份再 DEL,不能分两步做,否则两步之间锁可能已过期被别人拿到,就会误删别人的锁。固定过期时间有个硬伤:业务执行时间不确定,可能业务没完锁先过期。Redisson 的看门狗就是解这个——加锁成功后后台线程默认每 10 秒把锁续到 30 秒,业务不结束不让锁过期;业务主动释放或客户端宕机后续期停止,锁最终自然过期,不会永久死锁。
最后是高阶追问,也是最能拉开差距的:主从架构下锁会丢吗?会。master 加锁成功但还没同步到 slave 就宕机,哨兵把 slave 提上去,锁就凭空消失了。RedLock 想用多数节点加锁缓解,但它依赖时钟假设、GC 停顿这些前提,争议很大,我不会把它当标准答案吹。更务实的答法是承认主从切换存在锁失效窗口,业务层用 fencing token 或幂等兜底。
答题骨架
正确的基础实现:SET lock_key unique_value NX PX 30000
NX保证互斥,PX防死锁,unique_value释放时校验持有者身份。- 释放必须用 Lua 脚本先
GET比对再DEL,否则两步之间锁可能已过期并被他人获取,造成误删。
Redisson 看门狗:业务执行时间不确定,固定过期时间可能「业务没完锁先过期」。看门狗在加锁成功后启动后台线程,默认每 10 秒把锁续期到 30 秒;业务结束或客户端宕机后续期停止,锁最终自然过期,不会永久死锁。
踩分点 / 追问方向
- 「主从架构下锁会丢吗?」——会。master 加锁成功后未同步到 slave 就宕机,哨兵提升slave,锁「凭空消失」。
- 「RedLock 是标准答案吗?」——不是。它依赖时钟假设、受 GC 停顿影响,存在争议。务实答法是承认失效窗口,业务层用 fencing token 或幂等兜底。
- 「为什么不能简单 DEL?」——见上,误删他人锁;必须 Lua 保证「比对 + 删除」原子性。
七、性能与生产排障
Q13 Pipeline 和事务的区别? 🔥🔥
答题骨架
| 维度 | Pipeline | 事务(MULTI / EXEC) |
|---|---|---|
| 作用位置 | 客户端侧批量发送 | 服务端侧排队执行 |
| 核心收益 | 减少网络 RTT(不逐条等响应) | 命令作为整体按序执行 |
| 原子性 | 不保证,中间某条失败不影响后续 | 按序执行,但不回滚 |
两者的共同点是「批量」,但 Pipeline 优化的是网络往返,事务约束的是执行顺序。生产上两者可以叠加使用(Pipeline 里装一个事务)以同时减少 RTT 和保证顺序。
⚠️ 常见错误:把 Pipeline 说成「原子操作,要么全成功要么全失败」——这是错的,Pipeline 没有任何原子性保证。
Q14 大 key / 热 key 怎么发现和处理? 🔥🔥
答题骨架
大 key
- 发现:
redis-cli --bigkeys扫描、SLOWLOG慢查询、监控used_memory异常。 - 处理:原则是拆分。大 Hash 按字段拆成多个小 Hash,大 ZSet 按分数区间或业务维度拆,大 String 考虑压缩或迁移到其他存储。
- 删除:4.0+ 用
UNLINK非阻塞逐步清理;4.0 之前先SCAN读部分数据再删,避免一次性删除阻塞。清理 Hash 内失效数据用HSCAN+HDEL。
热 key
- 发现:客户端埋点统计、
MONITOR抽样(生产慎用)、代理层监控。 - 处理:本地缓存挡在最前面;热 key 复制到多个分片(如
foo复制出foo2/foo3/foo4分散到不同分片);读写分离让从节点分担读压力。复制方案需联动改代码,且带来多 key 一致性挑战,仅建议作为临时止血手段。
踩分点 / 追问方向
- 「内存水位怎么监控?」——设内存使用率告警(如超过 70%)、1 小时内增长率告警(如超过 20%),把告警变预警。
- 「为什么大 key 危险?」——删除阻塞主线程、迁移困难、分片内存不均、网络传输慢。
- 「热 key 复制的代价?」——更新从 1 个 key 变成 N 个 key,一致性挑战大,仅作临时方案。
附录:其他高频小知识点
A1 批量查 key:为什么用 SCAN 不用 KEYS
KEYS prefix* 会一次性扫描全部 key 并返回。Redis 单线程执行命令,KEYS 会导致线程阻塞一段时间,线上服务停顿,直到指令执行完毕。生产环境用 SCAN:无阻塞地增量提取指定模式的 key,但有一定重复概率,客户端做一次去重即可,整体耗时比 KEYS 长。
延伸:Redis 6.0+ 的 I/O 多线程不改变命令执行的单线程本质,所以「慢命令阻塞」依然成立。
A2 用 Redis 实现异步队列
- List 方案:生产者
LPUSH queue_name task_data,消费者BRPOP queue_name timeout。BRPOP从队列尾部弹出任务(LPUSH 从头进、BRPOP 从尾出),队列为空时阻塞等待直到超时。 - Pub/Sub 方案:
PUBLISH channel_name task_data/SUBSCRIBE channel_name。
Pub/Sub 的缺点:消息丢失(订阅者不在线就收不到)、接收顺序不确定、连接与频道关系增加系统复杂性、无确认机制导致可靠性差、订阅者过多时扩展性受限。需要可靠性时优先用 Stream 或专业 MQ(见 RabbitMQ 笔记)。
延时队列:用 ZSet 实现——把任务作为 member,score 设为执行时间戳:
ZADD delay_queue <timestamp> <task_data>
ZRANGEBYSCORE delay_queue 0 <current_timestamp> WITHSCORES
ZREMRANGEBYSCORE delay_queue 0 <current_timestamp>定时轮询到期任务转入待处理队列。注意:多消费者并发取任务时需保证原子性(用 Lua 脚本「查 + 删」),并考虑任务重试与持久化。
A3 内存优化与容量上限
- 尽量用 Hash:用户对象不要为姓名、邮箱等各建一个 key,而是放进一张 Hash,字段少时底层用紧凑编码,内存占用极小。
- 容量上限:一个 Redis 实例最多约
2^32 - 1个 key;List / Set / Sorted Set 最大元素数同样约2^32 - 1。真正的上限是可用内存。
A4 持久化数据与缓存怎么扩容
- 缓存场景:可用一致性哈希做动态扩缩容(多见于客户端分片方案);使用官方 Cluster 时则按哈希槽迁移。
- 持久化存储场景:需要固定的 key-to-nodes 映射,节点数不宜频繁变化;若必须动态变化,要用能在运行时重新平衡的系统——官方 Redis Cluster 通过槽迁移支持这一点。
- 扩容过程中要保证数据一致性(靠复制机制同步)、关注数据迁移与重新分配、保证可用性(负载均衡分发请求)。
⚠️ 不要把「RDB / AOF」说成扩容方式——它们是持久化方式,与扩容无关。扩容靠主从、集群分片或客户端分片。
A5 Redis 常见性能问题
- 主节点执行阻塞式
save(调度rdbSave)会阻塞主线程,快照大时服务间断暂停——用BGSAVE,或把持久化压力放到从节点。 - AOF 不重写会不断增大,拖慢主节点重启恢复速度;
BGREWRITEAOF重写期间占用大量 CPU / 内存,可能短暂服务暂停。 - 主从复制:为速度与连接稳定性,slave 与 master 最好在同一局域网。
附:2026 面试趋势提示
大厂 Redis 的筛选标准已从「知不知道」转向「能不能画出机制、算得出损失、给得出止血方案」。典型信号:
- 持久化不再问「有哪两种」,而是问「混合持久化下宕机丢多少」;
- 缓存问题不再只问定义,而是问「你线上遇到的雪崩是什么场景,怎么止血的」;
- 分布式锁不再只问 SETNX,而是追问「看门狗什么情况下会失效」「主从切换锁丢了怎么办」。
准备时把上述七个模块的追问链各走通一遍,确保每个结论后面都能再接一层「为什么」和「出了事怎么办」。
