04.4.10.1 Redis与本地缓存
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.4 Rust / 04.4.10 缓存消息队列与后台任务
04.4.10.1-001 Rust 生态中连接 Redis 的主力 crate 是哪个,同步与异步两条链路如何区分?
一句话结论
主力 crate 是 redis(redis-rs),它同时提供同步连接与异步连接:同步 API 用于阻塞上下文或脚本,异步 API 通过 runtime feature(如 tokio-comp)在 Tokio 任务中使用,Web 服务默认走异步链路。
概念解释
redis crate 封装 RESP 协议与命令编码,类型上区分 Client、同步 Connection 与异步连接。异步能力由 feature 开关按运行时启用,不在默认编译面里。Web 后端运行在异步运行时上,不能在 async 任务里调同步连接,否则阻塞 worker 线程;连接句柄按需克隆或经连接池分发。
原理流程
Cargo.toml引入redis,按运行时开启对应 feature。Client::open(url)解析连接配置。- 同步链路:
get_connection()拿到阻塞连接。 - 异步链路:
get_async_connection().await拿到异步连接,或包一层连接管理器。 - 命令通过连接上的方法或
cmd(...)发送,反序列化到目标类型。
代码或图示
[dependencies]
redis = { version = "*", features = ["tokio-comp", "connection-manager"] }
use redis::Client;
let client = Client::open("redis://127.0.0.1/")?;
// 异步:let mut conn = client.get_async_connection().await?;
常见误区
- 在 async resolver 里调用同步连接:阻塞运行时 worker,拖慢并发。
- 未启用 runtime feature 就用异步连接:编译期缺 trait 与连接类型。
追问
- 连接能跨任务克隆共享吗?答:异步连接可包
ConnectionManager或进连接池分发;裸连接不是并发安全共享句柄,具体共享方式以 docs.rs/redis 当前版本为准。 - 同步客户端适合什么场景?答:命令行工具、离线脚本、不依赖运行时的任务;Web 服务避免使用。
04.4.10.1-002 异步客户端的 runtime feature 怎么选,connection-manager 解决什么问题?
一句话结论
异步 feature 按项目运行时选择(Tokio 用 tokio-comp,async-std 用对应 feature);connection-manager 提供可克隆、内部带断线重连的连接句柄,便于在多任务间共享而不用自建连接池。
概念解释
redis crate 不绑定单一运行时,异步后端由 feature 编译进来。裸异步连接断线后需要手动重连;ConnectionManager 包装连接,克隆句柄共享同一连接并在后台维护重连,适合单实例少量连接场景。高并发下更常见做法是连接池(deadpool-redis / bb8),每个任务借取独立连接。
原理流程
- 确认项目运行时:Tokio 任务开启
tokio-comp。 - 引入
connection-managerfeature。 - 建立异步连接后构造
ConnectionManager。 - 句柄可克隆传入不同任务,断线由管理器后台重连。
- 连接数需求高时改用连接池,按借用隔离连接。
代码或图示
use redis::{Client, AsyncConnectionConfig};
let client = Client::open("redis://127.0.0.1/")?;
// 待确认:ConnectionManager 构造方式与配置项以 docs.rs/redis 当前版本为准
// let manager = ConnectionManager::new(conn).await?;
常见误区
- 运行时 feature 与项目不符:异步类型实现不匹配,编译报错。
- 把
ConnectionManager当连接池:它解决共享与重连,不限连接数量;高并发仍需池化。
追问
- 断线重连期间命令会怎样?答:管理器重连过程中的命令可能失败或排队,业务需处理重试;具体语义以库文档为准。
- 何时直接用裸异步连接?答:单任务长连接场景(如订阅消费者),自己管理生命周期更直接。
04.4.10.1-003 Redis 连接 URL 如何书写,密码、库号与 TLS 在连接配置中放在哪?
一句话结论
URL 格式为 redis://[用户名:密码@]主机:端口/库号,TLS 用 rediss:// 方案;复杂配置(TLS 证书、连接超时)通过连接配置结构或 builder 传入,不在 URL 里堆全部参数。
概念解释
连接 URL 承载最小连接信息:协议、认证、主机端口、逻辑库号。redis:// 明文,rediss:// 表示 TLS。生产环境密码不写进代码库,从配置/环境变量读取(与 04.4.13.2 配置管理衔接)。URL 解析失败、认证失败与网络错误分别映射为 redis::RedisError 的不同类别。
原理流程
- 从配置读取主机、端口、密码、库号,组装 URL。
Client::open解析 URL 并校验格式。- 建立连接,认证与选库在握手阶段完成。
- TLS 场景使用
rediss://或显式 TLS 配置。 - 连接错误按类别处理:网络、认证、协议错误分别告警。
代码或图示
redis://127.0.0.1:6379/0
rediss://:password@redis.internal:6379/1
常见误区
- 把密码硬编码进 URL 提交仓库:违反密钥管理规则,应走配置注入。
- URL 库号与业务逻辑假设不一致:多业务共用实例时串库污染数据。
追问
- 连接超时在哪设置?答:连接配置/builder 中设置连接超时与命令超时;具体配置项名以 docs.rs/redis 当前版本为准。
- 哨兵或集群地址怎么配?答:不在单节点 URL 内,使用客户端对应集群/哨兵配置方式;集群路由见本章集群题。
04.4.10.1-004 deadpool-redis 连接池如何工作,基本配置包含哪些项?
一句话结论
deadpool-redis 基于 deadpool 异步池化框架,按 max_size 维护连接,任务 get() 借用连接、归还后复用;配置含池大小、等待超时、回收检查等,避免每次命令新建 TCP 连接。
概念解释
直连模式下每次请求新建连接成本高,连接池预先建立并复用连接。deadpool 是 Rust 常用异步池化库,deadpool-redis 包装 redis 客户端。借用时池内有空闲连接直接返回,无空闲则等待;等待超时返回错误。连接失效在借用或归还时回收,坏连接被剔除重建。
原理流程
- 构造
Manager(持有 Redis 客户端与配置)。 - 按
max_size建立池,启动时可预热部分连接。 - 任务调用
pool.get().await借用连接。 - 用完归还池内;连接报错则标记废弃并重建。
- 池满时新请求按等待超时排队,不无限扩张。
代码或图示
[dependencies]
deadpool-redis = "*"
// 待确认:Pool/Manager 构造签名与配置字段以 docs.rs/deadpool-redis 当前版本为准
// let manager = Manager::from_config(config, Runtime::Tokio1);
// let pool = Pool::builder(manager).max_size(20).build()?;
常见误区
- 池大小按 CPU 核数拍脑袋:应结合 Redis 服务端连接上限、并发量与命令耗时压测确定。
- 借连接后长事务占用:池被占满,其他请求等待超时。
追问
- 连接池放哪一层共享?答:放进应用状态(axum State 等),全生命周期共享池句柄,不在请求内新建池。
- 坏连接如何被发现?答:借用时健康检查或命令报错触发回收;具体探测策略以 deadpool 实现为准。
04.4.10.1-005 bb8 连接池与 deadpool-redis 有什么差异,选型看什么?
一句话结论
两者都是异步连接池:bb8 基于 bb8 框架做按需扩容与回收,deadpool 基于 deadpool 框架;差异主要在池化框架生态、API 风格与运行时适配,业务层通常按团队熟悉度与现有依赖选择。
概念解释
bb8 是 Rust 早期流行的异步连接池框架,bb8-redis 提供 Redis 适配;deadpool 设计偏轻量、配置直观,在异步 Web 项目中使用广泛。两者职责相同:限制连接总数、复用连接、剔除坏连接。选型不必泛化优劣,重点核对当前版本维护状态、API 成熟度与项目已有池化依赖。
原理流程
- 列出项目现有异步池化使用情况(是否已引入 deadpool/bb8)。
- 核对两个 Redis 适配包的当前版本与维护状态。
- 压测借用等待时间、连接复用率与坏连接回收表现。
- 选定后把池句柄注入应用状态。
- 仓储层只依赖借用接口,便于后续替换。
代码或图示
deadpool-redis:deadpool 框架,builder 配置 max_size/超时
bb8-redis:bb8 框架,ConnectionManager 适配按需创建与回收
常见误区
- 同一项目混用两套连接池:连接数预算与监控口径混乱。
- 凭旧资料断定某池「性能差」:版本迭代后表现需实测核对。
追问
- 池层之上需要再做封装吗?答:建议仓储接口屏蔽池细节,业务代码只取连接执行命令。
- 连接池指标暴露什么?答:池大小、空闲数、等待数、等待超时次数,接入可观测性。
04.4.10.1-006 连接池大小、等待超时与连接生命周期配置如何确定?
一句话结论
池大小由并发量、命令平均耗时与 Redis 服务端连接上限推算;等待超时防止无限排队;空闲回收与健康检查剔除失效连接,配置需压测校准而非固定值。
概念解释
池太小:请求排队等待,延迟上升;池太大:Redis 连接数被打满,服务端拒绝新连接。估算参考:连接数 ≈ 并发请求数 × 单请求占用连接时长占比,再结合服务端上限留余量。等待超时是兜底:池耗尽时快速失败而不是挂死。空闲连接定期检查,避免拿到半开连接。
原理流程
- 压测得出单命令平均耗时与峰值并发。
- 按 Little 定律估算所需连接数,留出冗余。
- 对照 Redis 服务端
maxclients与多实例共享预算。 - 设置等待超时、空闲回收与健康检查参数。
- 线上观测等待队列与连接复用率,回调参数。
代码或图示
估算:所需连接 ≈ 峰值并发 × 平均命令耗时 / 单连接可服务时长
约束:总连接 < Redis maxclients × 实例数 × 安全系数
常见误区
- 池大小设成 100 起步:超出 Redis 承受能力,服务端先报错。
- 不设等待超时:池耗尽后请求永久挂起,线程/任务堆积。
追问
- 长命令(大 hash 读取)对池影响?答:占用连接时间长,等效放大连接需求;应拆分命令或限制返回体积。
- 多业务共享实例怎么分配连接?答:按业务重要性分配池预算,互相隔离避免一个业务占满。
04.4.10.1-007 常用字符串与结构命令在 redis-rs 中如何调用,返回值如何反序列化?
一句话结论
标量命令用连接方法(get/set/set_ex/incr),结构命令用 cmd(...) 传参;返回值通过 FromRedisValue 反序列化为 String、i64、Vec<String> 或结构体。
概念解释
redis-rs 把 RESP 回复映射为 Rust 类型:标量值可转基本类型,数组转 Vec,键值对转元组向量或 Map。命令分两类:便捷方法覆盖常用命令,cmd(name) 拼装任意命令并追加参数。序列化进 Redis 的值通常是字符串/字节,复杂对象先序列化为 JSON 或二进制格式。
原理流程
- 选择命令方法或
cmd拼装。 - 追加键与参数,注意参数顺序与 Redis 文档一致。
- 执行并把回复反序列化为目标类型。
- 类型不匹配时返回
RedisError,按错误类别处理。 - 复杂对象在应用层先做序列化再写入。
代码或图示
use redis::AsyncCommands;
// 便捷方法(异步需 AsyncCommands trait)
let _: () = conn.set_ex("key", "value", 60).await?;
let v: String = conn.get("key").await?;
let n: i64 = conn.incr("counter", 1).await?;
// 结构命令
redis::cmd("HSET").arg("hash").arg("field").arg("1").query_async(&mut conn).await?;
常见误区
- 参数顺序写错:Redis 命令语义依赖参数位置,库不做语义校验。
- 直接把复杂结构体当命令值传入:需先序列化为字符串/字节。
追问
FromRedisValue如何为自定义类型实现?答:实现该 trait 解析 RESP 回复;常用做法是取回String/Value再反序列化。- 命令不存在或参数错误返回什么?答:服务端错误转为
RedisError,错误类别可用于区分可重试与参数错误。
04.4.10.1-008 String、Hash、List、Set、ZSet 分别适合什么缓存场景?
一句话结论
String 承载单值/计数器/序列化对象;Hash 存对象字段便于局部更新;List 做队列/时间线;Set 去重与交集;ZSet 按分数排序(排行榜、延迟队列);选型按访问模式与字段更新粒度决定。
概念解释
数据类型选错会导致多余命令或内存浪费。对象整体缓存用 String 存序列化体;字段需独立读写用 Hash,避免每次序列化整对象。List 头尾操作适合消息缓冲;Set 判断成员存在与集合运算;ZSet 按分数范围取排行。复杂关系不要硬塞进单一类型,必要时组合多键并注意一致性。
原理流程
- 梳理访问模式:读整体还是读字段、是否排序、是否去重。
- 整体读写选 String;字段局部读写选 Hash。
- 顺序队列选 List;成员存在性选 Set;排序范围选 ZSet。
- 评估内存与命令复杂度(如 ZSet 范围操作)。
- 组合类型时设计键命名空间与失效策略。
代码或图示
String:session、缓存对象、计数器
Hash:用户资料(字段级更新)
List:任务缓冲、最新动态
Set:标签、共同好友、去重集合
ZSet:排行榜、按分数排序的延迟队列
常见误区
- 所有对象都用 String 存 JSON:改一个字段也要整对象读写与重序列化。
- 用 List 做去重:成员重复无法拦截,应选 Set。
追问
- Hash 大对象要不要拆?答:字段过多或单值过大形成大 key,需拆分;大 key 治理见本章后续题。
- 多类型组合如何保证一致?答:用事务/Lua 保证相关键操作原子性,或接受短暂不一致并设计补偿。
04.4.10.1-009 管道化(pipeline)解决什么问题,redis-rs 中如何提交?
一句话结论
管道化把多条命令一次性发送、批量等待回复,减少网络往返次数;用 Pipeline 收集命令后一次执行,命令间无依赖时收益最大。
概念解释
逐条命令是「发送-等待」往返,RTT 累积明显。pipeline 在客户端攒一批命令写入 TCP 缓冲,服务端依次执行,回复批量返回。它不等同于事务:pipeline 只优化网络往返,不保证原子性,中间命令失败不回滚后续。批量取数(mget)与批量写入都适合管道。
原理流程
- 创建
Pipeline,依次追加命令与参数。 - 命令写入客户端缓冲,不立即等待回复。
- 一次提交发送整批,服务端顺序执行。
- 批量取回回复,按命令顺序解析。
- 有依赖关系的命令不能随意批量,需等待前序结果。
代码或图示
use redis::Pipeline;
let replies: Vec<redis::Value> = Pipeline::new()
.set("a", "1")
.set("b", "2")
.get("a")
.query_async(&mut conn)
.await?;
常见误区
- 把 pipeline 当事务:命令失败不会回滚已执行命令。
- 批量过大:单批命令与回复占用内存,服务端阻塞其他请求,需分批。
追问
- pipeline 与
mget/mset关系?答:多值原生命令一次语义完成;pipeline 是通用批发送手段,两者可结合。 - 管道内命令能读取前序命令结果吗?答:不能同步读取,需等整批回复;依赖前序结果的逻辑要拆分批次。
04.4.10.1-010 Redis 事务 MULTI/EXEC 在 redis-rs 中如何使用,原子性边界是什么?
一句话结论
事务用 MULTI 入队命令、EXEC 提交,保证命令按顺序连续执行、不被其他客户端命令穿插;但事务内某条命令报错不会回滚已执行命令,也不提供隔离级别的回滚语义。
概念解释
Redis 事务把多条命令打包,EXEC 期间顺序执行,期间不插入其他连接的命令。它与关系型事务不同:不支持失败回滚,语法错误导致整批不执行,运行期错误只影响出错命令。需要「检查条件 + 原子执行」时配合 WATCH 或改用 Lua 脚本。redis-rs 提供事务辅助函数把键、预检查与命令打包。
原理流程
WATCH关注冲突键(可选,做乐观锁)。MULTI开启事务,命令入队。- 提交命令序列。
EXEC连续执行整批。- 出错命令不回滚前序;
WATCH键被改动则事务中止。
代码或图示
// 待确认:transaction 辅助函数签名以 docs.rs/redis 当前版本为准
// redis::transaction(&mut conn, &["key"], |conn| {
// let v: i64 = conn.get("key")?;
// conn.set("key", v + 1)?;
// Ok(())
// })?;
常见误区
- 以为 Redis 事务能像数据库一样回滚:运行期错误不撤销已执行写入。
- 事务内做复杂判断:判断逻辑应在入队前或放进 Lua,事务只打包命令。
追问
- WATCH 解决什么问题?答:监视键在事务期间是否被改动,改动则中止事务,用于乐观并发控制。
- 事务与 Lua 怎么选?答:需要服务端原子判断与多步逻辑用 Lua;仅命令打包顺序执行用事务。
04.4.10.1-011 pipeline、transaction 与 Lua 三者的原子性和网络语义有何区别?
一句话结论
pipeline 只批量传输、无原子性;transaction 保证命令连续执行不穿插、不回滚;Lua 在服务端原子执行整段脚本,可做条件判断与多步修改,原子性最强。
概念解释
三者常被混淆。pipeline 是网络层批处理,命令独立执行;transaction 是命令打包顺序执行,提供「不被穿插」保证;Lua 脚本作为单段服务端程序运行,执行期间独占处理(单线程模型下),内部读写判断一体完成。需要读-判断-写一致性时,优先 Lua;只需减少往返用 pipeline。
原理流程
- 无依赖批量命令:选 pipeline 省 RTT。
- 要求命令连续不穿插、无回滚需求:选 transaction。
- 需要条件判断、多键原子修改:选 Lua 脚本。
- 评估脚本复杂度与执行时长,避免长脚本阻塞 Redis。
- 按场景组合:Lua 内完成原子操作,外层 pipeline 批量提交不同脚本。
代码或图示
pipeline: 批量发送,各自独立,不保证原子
transaction:MULTI/EXEC 连续执行,不穿插,失败不回滚
Lua: 服务端整段原子执行,可读-判断-写一体
常见误区
- 用 transaction 承载条件扣减:判断与写入分离,并发下超卖。
- 长 Lua 脚本做重计算:阻塞 Redis 单线程,影响所有客户端。
追问
- Lua 内能否调用其他脚本?答:Redis 脚本间不能直接互相调用;复杂逻辑拆分或在应用层编排。
- 事务执行期间其他客户端在做什么?答:EXEC 整批连续执行,期间命令排队等待;WATCH 提供中止条件。
04.4.10.1-012 Lua 脚本在 Redis 中如何保证原子性,redis-rs 里如何调用?
一句话结论
Lua 脚本在 Redis 服务端单线程内整段执行,执行期间不被其他命令打断,因此脚本内的读-判断-写是原子的;redis-rs 用 Script 加载脚本,按键与参数调用并取回结果。
概念解释
分布式锁释放、库存扣减、限额判断等场景需要「读取当前值、判断条件、写回」不可分割,事务难以表达条件判断,Lua 在服务端完成这一闭环。脚本只应做轻量逻辑:读取键、比较、写入,避免循环大集合。脚本首次执行可 EVAL,后续用 SHA 校验和复用 SCRIPT LOAD 的脚本。
原理流程
- 编写 Lua:读取键值、条件判断、写入结果,返回明确值。
Script::new构造脚本对象。- 绑定键与参数,
invoke_async发送执行。 - 服务端原子执行脚本,回复结果。
- 业务按返回值判断成功/冲突,处理重试。
代码或图示
use redis::Script;
let script = Script::new(
"if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
else return 0 end"
);
// script.key("lock").arg(token).invoke_async(&mut conn).await?;
常见误区
- 脚本内遍历大 key 集合:执行时间长,阻塞 Redis。
- 脚本参数与键位置混用:
KEYS与ARGV语义固定,集群下键必须落在同槽。
追问
- 脚本出错会怎样?答:运行期错误返回错误,已执行部分不回滚;脚本设计应保证中途状态一致。
- 为什么释放锁要用脚本而不是 DEL?答:先比对唯一值再删除,避免误删他人持有的锁;纯 DEL 无判断步骤。
04.4.10.1-013 SCRIPT LOAD 与 SHA 复用如何减少脚本传输开销?
一句话结论
SCRIPT LOAD 先把脚本上传到服务端缓存并返回 SHA1,后续用 EVALSHA 按校验和调用,避免每次传输完整脚本;脚本变更后需注意旧 SHA 失效与集群各节点缓存。
概念解释
EVAL 每次携带脚本正文,脚本较长时占用带宽。LOAD 后服务端缓存脚本,调用只传 SHA1。redis-rs 的 Script 内部处理脚本加载与调用流程。集群模式下脚本缓存分布在各节点,首次访问可能需要补发脚本;脚本修改后 SHA 变化,客户端缓存需更新。
原理流程
- 首次:脚本正文发送到服务端,缓存并得到 SHA1。
- 后续调用:按 SHA1 引用脚本执行。
- 集群:路由到未缓存节点时补发脚本。
- 脚本内容变更:新版本新 SHA,旧缓存自然淘汰。
- 监控 NOSCRIPT 类错误并补传脚本。
代码或图示
SCRIPT LOAD "<脚本>" → 返回 sha1
EVALSHA sha1 numkeys key arg ...
常见误区
- 集群下假设所有节点已缓存脚本:首次跨节点调用可能 NOSCRIPT。
- 修改脚本内容却复用旧 SHA:执行旧逻辑,行为与预期不符。
追问
- 脚本缓存会被淘汰吗?答:Redis 按内存策略与脚本缓存规则管理;NOSCRIPT 时重新加载即可。
- 如何确认当前版本脚本调用方式?答:以 docs.rs/redis
ScriptAPI 与 Redis 命令文档为准。
04.4.10.1-014 发布订阅(PUBLISH/SUBSCRIBE)在 Rust 侧如何使用,有哪些可靠性边界?
一句话结论
订阅端用 SUBSCRIBE 监听频道并循环接收消息,发布端 PUBLISH 投递;发布订阅是「 fire and forget 」,离线订阅者收不到历史消息,不保证持久化与消费确认。
概念解释
Pub/Sub 适合广播通知(缓存失效事件、配置刷新),不适合可靠任务队列。订阅连接进入消息循环,断开期间发布的消息直接丢失;没有消费确认、重试与积压保留。需要持久化消费、消费组与重试时用 Stream 或外部 MQ。Rust 异步订阅用专用订阅连接,循环处理消息直到断开。
原理流程
- 订阅端建立连接,
SUBSCRIBE到频道。 - 进入消息循环,逐条接收并处理事件。
- 发布端向频道
PUBLISH消息。 - 在线订阅者收到,离线期间消息不保留。
- 处理失败不重投,业务自行决定补偿。
代码或图示
// 待确认:AsyncPubSub 订阅 API 以 docs.rs/redis 当前版本为准
// let mut pubsub = conn.into_pubsub();
// pubsub.subscribe("cache:invalidate").await?;
// while let Some(msg) = pubsub.on_message().await { ... }
常见误区
- 用 Pub/Sub 下订单任务:消息丢失、无确认,业务不可靠。
- 订阅连接与命令连接混用:订阅进入循环后不能再跑普通命令。
追问
- 频道消息能持久化吗?答:原生 Pub/Sub 不持久化;要历史消息用 Stream。
- 广播缓存失效事件怎么防丢失?答:接受最终一致,失效事件配合短 TTL 兜底;关键数据不依赖事件必达。
04.4.10.1-015 Stream 的 XADD 与 XREAD 如何工作,消息模型与 List/PubSub 有何不同?
一句话结论
Stream 是持久化日志结构:XADD 追加消息并生成 ID,XREAD 按 ID 范围读取;消息保留在服务端,支持历史回溯,区别于 List 取出即删与 Pub/Sub 不持久化。
概念解释
每条 Stream 条目含 ID(时间戳-序号)与键值对。生产者追加消息,消费者按位置读取;未消费消息留存,可重读历史。XREAD 可阻塞等待新消息。Stream 支持消费者组拆分消费与确认机制,是 Redis 内置轻量消息队列方案。可靠性仍需结合业务:消费者处理后需确认,失败消息进入待处理列表追踪。
原理流程
- 生产者
XADD追加条目,指定字段与值,得到消息 ID。 - 消费者
XREAD按最后读取 ID 拉取新消息。 - 阻塞模式下等待新条目到达。
- 处理完成后在消费组模式下
XACK确认。 - 未确认消息通过
XPENDING追踪与重新分发。
代码或图示
XADD orders '*' orderId 1001 status paid
XREAD COUNT 10 BLOCK 5000 STREAMS orders $
常见误区
- 把 Stream 当无界队列不清理:条目持续占用内存,需设置长度淘汰策略。
- 读取后不确认:消费组视角消息一直待处理,重复消费风险累积。
追问
- 消息 ID 如何生成?答:默认时间戳-序号,也可指定;ID 单调递增是读取位置的依据。
- 单 Stream 积压如何治理?答:监控长度与待确认数,过期条目按
MAXLEN修剪。
04.4.10.1-016 消费组 XREADGROUP、XACK 与 XPENDING 分别解决什么问题?
一句话结论
消费组把 Stream 消息分给一组消费者并行处理:XREADGROUP 拉取并标记为待处理,XACK 确认完成,XPENDING 查看未确认消息用于重试与重分配。
概念解释
消费组内每条消息只投递给组内一个消费者。读取时消息进入「待处理」状态,消费者处理完 XACK 移除;处理失败或宕机的消息留在 pending 列表,可通过 XPENDING 查看、 Claim 转给其他消费者。这提供了最基础的消费可靠性:消息不丢、可追踪、可重投,但死信、重试退避等仍需业务实现。
原理流程
- 创建消费组,指定起始 ID。
- 消费者
XREADGROUP按组拉取消息,记录消费者名。 - 业务处理成功后
XACK确认。 - 失败消息保留在 pending,超时后被 Claim 重新分发。
- 监控 pending 数量与滞留时长,识别卡死消费者。
代码或图示
XGROUP CREATE orders group1 '$'
XREADGROUP GROUP group1 consumer-1 COUNT 10 STREAMS orders '>'
XACK orders group1 <message-id>
XPENDING orders group1
常见误区
- 不区分消费者名:重分配与待处理追踪无法按实例区分。
- 处理完忘记 XACK:消息反复出现在 pending,重复消费。
追问
- 消费者宕机后消息怎么办?答:pending 消息超时后由其他消费者 Claim 接管;需要业务实现超时判定与转移。
- 消费组能重复消费历史吗?答:组内已确认消息不重复投递;新组可从指定 ID 重读历史。
04.4.10.1-017 Stream 与 Kafka/RabbitMQ 等外部 MQ 在 Rust 后端如何取舍?
一句话结论
Stream 适合轻量异步解耦、积压可控、单机 Redis 可承载的场景;需要多副本持久化、回溯消费、复杂路由、高吞吐堆积时选外部 MQ,Stream 不替代专业消息队列。
概念解释
Stream 依托 Redis 部署,接入成本低,够用在任务缓冲、事件通知、轻量消费组。局限:持久化与高可用依赖 Redis 部署形态,大规模堆积、消费语义(重试死信、延迟级别、消息顺序保证)与多租户隔离不如专业 MQ。架构上先评估消息量级、可靠性要求与消费模式,再决定 Redis 内队列还是外部 MQ(外部 MQ 章节见 04.4.10.2)。
原理流程
- 评估消息量级、峰值吞吐与积压容忍度。
- 确认可靠性要求:持久化、确认、重试、死信、顺序。
- 轻量场景选 Stream,复用现有 Redis 基础设施。
- 复杂堆积与多语义场景引入外部 MQ。
- 消费者接口抽象,隔离底层队列实现便于替换。
代码或图示
Stream:低接入成本、轻量消费组、复用 Redis、堆积能力有限
外部 MQ:多副本持久化、高吞吐、复杂路由与消费语义、独立运维
常见误区
- 用 Stream 承载订单主链路:Redis 故障或积压直接影响交易可靠性。
- 为简单通知引入重型 MQ:运维成本与收益不匹配。
追问
- Stream 消息能跨节点复制吗?答:取决于 Redis 高可用部署形态;跨机房与副本语义需核对部署方案,标注待确认项实测。
- 业务如何抽象队列层?答:定义 enqueue/dequeue/ack 接口,Stream 与 MQ 各自实现,业务不绑定具体命令。
04.4.10.1-018 分布式锁为什么用 SET key value NX PX,各参数分别保证什么?
一句话结论
NX 保证键不存在才设置(互斥),PX 设置过期时间防死锁,value 存唯一标识用于安全释放;三者组合才是最小可用的 Redis 分布式锁。
概念解释
简单 SET key value 不互斥:并发请求都能写入。NX(not exists)让只有一个客户端抢到键。不加过期时间,持锁进程崩溃后锁永久残留。过期时间防死锁;唯一标识保证释放时只删自己的锁。锁粒度、超时时间与业务执行时长要匹配,过短被提前释放,过长故障恢复慢。
原理流程
- 生成请求唯一标识(UUID 或随机串)。
SET lock:<资源> <唯一值> NX PX <毫秒>尝试抢锁。- 返回成功即持有锁,执行业务。
- 业务完成后用脚本比对标识再删除。
- 抢锁失败按策略重试或快速失败。
代码或图示
let locked: bool = conn
.set_nx_ex("lock:order:1001", token, 5_000)
.await?;
常见误区
- 只用
SETNX不加过期:崩溃后死锁。 - value 固定为常量:释放时无法区分持有者,可能误删他人锁。
追问
- 锁超时小于业务执行时间会怎样?答:锁自动释放,其他客户端进入,出现并发临界区;需要续期机制。
PX时间怎么定?答:按业务 P99 执行时长留余量,结合超时重试策略评估。
04.4.10.1-019 释放锁为什么必须用 Lua 脚本比对唯一值,直接 DEL 有什么问题?
一句话结论
释放锁要「比对 value 是否等于自己的标识,相等才删除」,这两步必须原子;Lua 脚本在服务端完成比对与删除,直接 DEL 会误删已经过期后被他人持有的锁。
概念解释
场景:A 持锁超时自动释放,B 抢到同一锁;A 业务完成后执行 DEL,把 B 的锁删掉,C 又进入临界区。先 GET 比对再 DEL 分两步,中间存在并发窗口。Lua 把比对与删除合并为一次原子操作,只在标识匹配时删除。释放失败(锁已不属于自己)不应再补救删除。
原理流程
- 业务完成,取出持有时生成的唯一标识。
- 执行 Lua:读取键值,等于标识则
DEL,否则返回未匹配。 - 脚本原子执行,比对与删除之间无穿插。
- 返回值判断是否成功释放。
- 不匹配说明锁已易主,记录告警不做二次删除。
代码或图示
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
else
return 0
end
常见误区
- 应用层 GET 判等后再 DEL:两步之间锁可能已过期易主。
- 释放时删除不带标识校验:并发误删他人锁。
追问
- 锁 owner 信息还能记录什么?答:value 可编码实例标识与线程/请求 ID,便于排查;注意不要放敏感信息。
- 释放脚本返回 0 如何处理?答:视为锁已过期或被抢占,记日志告警,业务侧检查临界区是否需要补偿。
04.4.10.1-020 锁续期(看门狗)解决什么问题,实现上有哪些风险?
一句话结论
看门狗在业务未完成时定期延长锁过期时间,防止执行超时导致锁提前释放;风险是续期任务与业务生命周期绑定,进程异常后续期停止,且续期逻辑本身要避免无限延长。
概念解释
业务时长波动大时,固定 TTL 难以兼顾安全:设短了临界区被抢占,设长了故障恢复慢。续期机制由后台任务在到期前刷新 TTL,业务结束停止续期。Rust 侧可用 Tokio 周期任务配合取消信号。风险:续期任务泄漏、进程挂掉后续期停止但锁仍在、续期期间网络抖动导致刷新失败。
原理流程
- 抢锁成功后启动续期任务,周期小于 TTL。
- 每次续期先比对标识,匹配才延长过期。
- 业务完成发送取消信号,停止续期并释放锁。
- 续期失败(连接错误/标识不匹配)中止业务。
- 设置最大持锁时长兜底,防止无限续期。
代码或图示
抢锁(TTL 5s) → 后台每 2s 比对标识并 PEXPIRE → 业务完成取消 → 脚本释放
兜底:最大持锁时长,超时强制告警并停止续期
常见误区
- 续期任务不随业务结束取消:任务泄漏,锁被无限延长。
- 续期不校验标识:把别人的锁续期了。
追问
- Rust 侧续期任务怎么管理?答:用
tokio::spawn加JoinHandle与取消标志,业务结束即 abort/停止;具体任务结构按 04.4.7.1 运行时章节。 - 续期失败怎么办?答:视为锁可能已丢失,停止写入临界区并告警;不要盲目继续执行业务。
04.4.10.1-021 基于 Redis 的分布式锁有哪些已知坑:误释放、重入、主从切换、时钟?
一句话结论
常见坑包括误删他人锁、不可重入、主从切换时锁未同步丢失、过期时间依赖时钟漂移;工程上按场景选择锁方案,高一致场景需要更严格的协调机制(如 Redlock 评估或外部协调服务)。
概念解释
单点 Redis 锁在主从异步复制下,锁写入主节点后未同步到从节点就故障切换,新主上无锁记录,另一客户端可抢到。重入问题:同一线程重复获取同一锁需要计数模型。时钟漂移影响 TTL 计算。这些坑决定 Redis 锁适合「低概率冲突、可容忍偶发并发」的场景;强一致临界区要评估 ZooKeeper/etcd 等协调服务,或接受方案局限并加业务兜底。
原理流程
- 核对场景:冲突后果是否严重,能否容忍偶发重复执行。
- 防误释放:唯一标识 + Lua 释放。
- 评估重入需求:需要时设计计数锁结构。
- 评估主从切换丢锁风险:关键链路加幂等与业务校验兜底。
- 强一致要求改用成熟协调组件,不自行堆砌 Redis 命令。
代码或图示
坑点清单:
误释放:唯一值 + Lua 比对删除
重入:需计数模型,普通 NX 锁不可重入
主从切换:异步复制窗口内锁可能丢失
时钟:TTL 基于节点时间,注意漂移
常见误区
- 把 Redis 锁当强一致互斥:未评估主从复制与故障切换窗口。
- 临界区操作不做幂等:锁失效后重复执行造成重复下单/扣减。
追问
- Redlock 是否解决主从丢锁?答:多节点投票算法降低概率,但仍有时钟与网络争议;是否采用需结合一致性要求,方案细节以官方文档为准。
- 业务兜底怎么做?答:关键操作加幂等键、数据库唯一约束、状态机校验,锁失效后重复请求被业务层拦截。
04.4.10.1-022 cache-aside(旁路缓存)模式的读写流程是什么,为什么是最常用模式?
一句话结论
读路径先查缓存,未命中查库并回填缓存;写路径先更新数据库再删除缓存;它把缓存作为旁路副本,业务数据以数据库为准,实现简单且与现有存储解耦。
概念解释
cache-aside 由应用层显式管理缓存:读时缓存miss 才回源,写时更新库后使缓存失效。对比「读写都走缓存层」的模式,旁路模式缓存故障时可降级直连数据库,数据权威源清晰。写后删缓存而不是更新缓存,避免并发写导致缓存值错乱;缓存短暂不一致窗口由 TTL 兜底。
原理流程
- 读:查缓存,命中返回;未命中查数据库。
- 回填缓存(设 TTL),返回数据。
- 写:先在数据库完成更新。
- 删除对应缓存键。
- 下次读触发回填;缓存故障时降级直连库。
代码或图示
读:cache → miss → DB → 回填 cache
写:DB 更新 → 删除 cache(不是更新 cache 值)
常见误区
- 写后更新缓存而不是删除:并发覆盖下缓存值可能比数据库旧。
- 缓存未命中时不设 TTL:脏数据永久驻留。
追问
- 先删缓存还是先更新库?答:见本章一致性专题;常见顺序是先更新库再删缓存,配合延迟双删应对并发窗口。
- 缓存击穿时如何避免大量请求同时回源?答:互斥重建或单飞加载,见击穿专题。
04.4.10.1-023 什么是缓存穿透,布隆过滤器与空值缓存分别怎么防护?
一句话结论
穿透指查询数据库不存在的数据,缓存也不命中,请求直达数据库;布隆过滤器在缓存前判断「一定不存在」,空值缓存把不存在结果短 TTL 记下,两者都挡住无效回源。
概念解释
穿透常见于恶意构造不存在的 ID 或拼写错误。布隆过滤器是概率结构:判断不存在则一定不存在,判断存在可能有误判;把已有 ID 集合放入过滤器,请求先过过滤器。空值缓存对查无结果的键缓存短生命周期空标记,避免反复查库。布隆适合大规模主键集合,空值缓存适合零星未命中结果,两者可叠加。
原理流程
- 启动/预热时把合法主键集合写入布隆过滤器。
- 请求先查过滤器:判定不存在直接返回空。
- 判定存在再查缓存;缓存未命中查库。
- 库中无记录则缓存空值(短 TTL)。
- 数据新增时同步更新过滤器或定期重建。
代码或图示
请求 → 布隆过滤器(不存在→直接空) → 缓存 → DB
DB 无记录 → 缓存空值(短 TTL) → 后续请求不再回源
常见误区
- 布隆过滤器不随数据新增更新:新注册用户被误判不存在。
- 空值缓存 TTL 过长:脏空结果长期占用缓存。
追问
- 布隆过滤器误判会怎样?答:误判存在会放行到缓存/库,不影响正确性,只少挡一部分流量。
- Rust 侧布隆过滤器用什么实现?答:可选本地布隆库或 Redis 模块;本地结构随多实例各自维护,具体 crate 与维护状态需核对 docs.rs。
04.4.10.1-024 什么是缓存击穿,互斥重建与单飞(single flight)如何防止并发回源?
一句话结论
击穿指热点键过期瞬间,大量并发请求同时未命中并回源压垮数据库;互斥锁只放一个请求重建缓存,其余等待或返回旧值,单飞合并并发加载请求。
概念解释
与穿透(数据不存在)不同,击穿针对存在的热点数据。键过期后高并发同时 miss,数据库被瞬时打满。防护:重建前抢锁,持锁者查库回填,其他等待结果;或用 single flight 组件把并发相同键的加载合并为一次。等待超时可返回旧值/降级数据,避免线程堆积。
原理流程
- 缓存未命中,尝试获取重建锁(短 TTL)。
- 持锁者查库、回填缓存后释放锁。
- 未持锁者短暂等待缓存回填,或先返回旧值/空值。
- 等待超时走降级,不无限阻塞。
- 热点数据可配合逻辑过期与异步刷新。
代码或图示
miss → 抢重建锁 → 持有者: DB → 回填 cache → 释放锁
其余: 等待回填 / 返回旧值 / 降级
常见误区
- 重建锁 TTL 过长:持锁者宕机后热点长时间不可重建。
- 等待方无限循环重试:请求堆积,应用线程占满。
追问
- 本地缓存场景怎么做 single flight?答:本地组件记录加载中状态,相同键的后续请求等待同一加载结果;与 moka
get_with能力衔接。 - 逻辑过期是什么?答:缓存值内嵌过期时间,后台异步刷新,请求不等待重建;适合可容忍短暂旧值的热点。
04.4.10.1-025 什么是缓存雪崩,TTL 抖动与分批预热如何缓解大面积同时失效?
一句话结论
雪崩指大量缓存键在同一时刻失效或缓存整体故障,请求集中回源压垮数据库;TTL 加随机抖动避免同时过期,分批预热与多级缓存分散冲击,故障时降级限流兜底。
概念解释
雪崩成因:批量键 TTL 相同同时到期、Redis 整体故障、大面积脏数据被淘汰。防护分三层:写入 TTL 加随机偏移避免同期失效;启动分批预热热点数据;缓存故障时限流直连库并降级返回。监控缓存命中率与回源量,提前发现失效潮。
原理流程
- 写缓存时基础 TTL 加随机抖动(如 ±10%)。
- 批量数据分批加载,避免预热同时涌入。
- 热点数据本地缓存兜底 Redis 故障。
- 缓存异常时开启限流,控制回源数据库的请求比例。
- 观测命中率与数据库负载,恢复后逐步放开。
代码或图示
TTL = 基础秒数 + random(0, 抖动范围)
预热:分批加载,间隔与批量大小可控
降级:Redis 不可用 → 限流 + 旧值/空值 + 直连库兜底
常见误区
- 所有缓存写同一固定 TTL:到期时刻整齐,形成失效峰。
- 缓存故障时不做限流:数据库被全量流量打垮,故障扩大。
追问
- 雪崩与击穿区别?答:击穿是单热点键过期并发回源;雪崩是大面积失效或整体故障。
- 多级缓存如何缓解?答:本地缓存承接一部分读请求,Redis 故障时本地副本兜底;一致性与失效广播见后续专题。
04.4.10.1-026 写数据时先更新数据库还是先删缓存,两种顺序各有什么并发问题?
一句话结论
常见做法是「先更新数据库,再删除缓存」;先删缓存再更新库在并发读写下更容易产生旧值回填,两种顺序都存在短暂不一致窗口,需配合延迟双删或订阅 binlog 收敛。
概念解释
顺序一:先删缓存再更新库。并发读在库更新前 miss,把旧值回填缓存,脏数据驻留到 TTL。顺序二:先更新库再删缓存。并发读在删缓存前读到旧缓存,写入完成后缓存已删,下次读回填新值;风险是删缓存失败留下旧值。缓存本质是副本,无法与数据库强一致,工程目标是缩小窗口并兜底。
原理流程
- 先更新库:写事务提交成功。
- 删除对应缓存键;删除失败进入重试/补偿队列。
- 并发读在删除前可能持有旧缓存,删除后下次读回填新值。
- 关键业务加延迟双删或订阅数据库变更刷新缓存。
- TTL 作为最终兜底,保证脏数据有限期。
代码或图示
先更新库 → 删缓存(推荐)
风险:删缓存失败 → 旧值残留;补偿:重试删除/订阅变更
先删缓存 → 更新库(不推荐)
风险:并发读旧值回填 → 脏数据驻留至 TTL
常见误区
- 认为删缓存失败可以忽略:旧值长期驻留,必须有补偿重试。
- 追求缓存与库实时一致:旁路模式做不到强一致,按业务容忍度定窗口。
追问
- 删除缓存失败怎么补偿?答:失败入重试队列,有限次重试后记录告警;或由 binlog 订阅异步刷新/删除。
- 读多写少场景选哪种?答:先更新库再删缓存更稳;写并发高时评估延迟双删成本。
04.4.10.1-027 延迟双删用来解决什么问题,延迟时长如何确定?
一句话结论
延迟双删在更新库后先删一次缓存,延迟一个读并发窗口再删第二次,清理并发读回填的旧值;延迟时长按读请求耗时与事务窗口估算,不是固定魔法值。
概念解释
先更新库再删缓存后,仍可能有并发读在删除前拿到旧缓存;若缓存被旧值回填,第二次延迟删除清掉它。流程:更新库 → 删缓存 → 等待(覆盖一次读写往返时长)→ 再删缓存。延迟过短第二次删除赶不跑回填,过长旧值暴露窗口扩大。延迟任务由后台调度或消息延迟队列执行,不能阻塞主写路径。
原理流程
- 业务写事务提交。
- 第一次删除缓存键。
- 提交延迟任务(时长覆盖典型读链路耗时)。
- 延迟到点第二次删除同一键。
- 第二次删除失败仍走补偿队列;TTL 兜底残留旧值。
代码或图示
写库 → 删 cache → 延迟 N ms → 再删 cache
N 参考:数据库读耗时 + 缓存读写耗时 + 余量
常见误区
- 在请求线程内 sleep 等待:阻塞业务响应,延迟必须异步执行。
- 延迟时长拍脑袋固定:应结合 P99 读耗时压测调整。
追问
- 延迟双删能替代 binlog 订阅吗?答:不能,双删只处理删除瞬间的并发回填;变更来源复杂时订阅数据库事件更可靠。
- 第二次删除需要比对值吗?答:二次删除为失效意图,直接删键即可;若期间有新写入回填新值,需评估误删风险,必要时按版本号删除。
04.4.10.1-028 订阅数据库变更(binlog)刷新缓存如何工作,相比应用侧双删有什么优势?
一句话结论
通过监听数据库 binlog 变更事件,异步删除或刷新对应缓存,把缓存一致性从应用写路径解耦;优势是覆盖应用侧遗漏的删除路径,劣势是引入订阅组件与延迟,属于最终一致方案。
概念解释
应用内删缓存可能漏路径(后台批量更新、SQL 直改、多服务写同一表)。订阅 binlog 捕获所有行变更,按表与主键映射缓存键,异步失效缓存。链路:数据库 binlog → 订阅组件(如 Canal 类方案)→ 消息 → 缓存失效逻辑。延迟在秒级以内,缓存 TTL 兜底。Rust 服务消费变更消息执行删除,不直接耦合数据库内部工具链。
原理流程
- 部署 binlog 订阅组件,解析行变更事件。
- 事件按表映射到缓存键规则。
- 投递到消息通道,服务消费者删除/刷新缓存。
- 失败重试与死信告警。
- 缓存 TTL 作为最终一致性兜底。
代码或图示
DB binlog → 订阅组件 → 消息队列 → 消费者: 删除 cache:<table>:<id>
映射规则:表名 + 主键 → 缓存键;批量变更按行展开
常见误区
- 以为订阅是实时强一致:仍有订阅延迟,窗口内读到旧值。
- 变更事件不做幂等:重复消息导致重复删除(删除幂等,刷新需防旧值覆盖新值)。
追问
- 刷新缓存为什么要防旧值覆盖?答:异步刷新若先查库后写缓存,慢查询结果可能晚到覆盖新值;删除比回填更安全。
- Rust 侧如何接入?答:消费 MQ 变更消息执行失效;具体订阅组件按基础设施选型,服务端只依赖消息接口。
04.4.10.1-029 大 key 有什么危害,如何识别与拆分?
一句话结论
大 key 指单键体积过大或集合元素过多,危害是阻塞 Redis 单线程、网络传输慢、内存倾斜与删除卡顿;识别靠 MEMORY USAGE、DEBUG 扫描与监控,拆分按字段/分片/分页打散。
概念解释
大 key 场景:单个 String 数 MB,Hash/List/Set/ZSet 元素成千上万。危害:读写阻塞其他命令,复制与持久化压力大,删除时同步释放内存卡顿。识别:抽样 MEMORY USAGE,扫描大集合;线上避免全量 KEYS。拆分:对象字段拆 Hash 分片,长列表分段键,大集合按业务维度拆分;删除用异步 UNLINK。
原理流程
- 监控命令与内存,定位大键类型与体积。
- 抽样
MEMORY USAGE key确认大小。 - 设计拆分方案:字段分片、分段键、元素分批迁移。
- 迁移期间双写过渡,校验数据完整。
- 旧大键用
UNLINK异步删除,避免阻塞。
代码或图示
识别:MEMORY USAGE / 元素计数 / 慢日志
拆分:user:100:profile → 按字段分片;长列表 → user:100:feed:0..n
删除:UNLINK 异步释放,不用阻塞 DEL 大键
常见误区
- 线上执行
KEYS *扫描:阻塞 Redis,应用 SCAN 分批。 - 大 key 直接 DEL:同步释放大块内存造成卡顿,优先 UNLINK。
追问
- 大 key 与热 key 区别?答:大 key 是体积维度,热 key 是访问频率维度;两者可能叠加。
- 集合元素上限怎么定?答:按命令复杂度与单键内存评估,超出即分片;具体阈值压测确定。
04.4.10.1-030 热 key 如何识别,本地缓存与请求分散能缓解什么?
一句话结论
热 key 是访问频率极高的少数键,可能把单节点打满;识别靠热点统计与代理监控,缓解手段是本地缓存副本、多副本分散与读写分离,避免所有请求压到同一 Redis 节点。
概念解释
热点数据(首页配置、爆款商品、全局公告)集中访问同一键,单节点 CPU/网卡成为瓶颈。识别:Redis 代理或客户端统计命令频次,按键排序。缓解:本地缓存承接高频读;Redis 侧对可复制数据做多副本键分散;读流量走从节点。注意本地缓存一致性窗口与副本失效广播。
原理流程
- 统计各键访问频次,输出热 key 排行。
- 评估热键数据是否可容忍短暂旧值。
- 加本地缓存副本,缩短回源 Redis 路径。
- 可复制数据拆多副本键,请求按哈希分散。
- 读请求路由到从节点分担主节点压力。
代码或图示
识别:命令频次统计 / 代理热点监控
缓解:本地缓存 → 多副本键 → 读从节点
失效:更新后广播失效各副本与本地缓存
常见误区
- 热 key 只靠扩容 Redis 实例:单键仍落单节点,扩容不解决热点集中。
- 本地缓存热数据不设失效:数据变更后各实例旧值长期不一致。
追问
- 热 key 本地副本 TTL 怎么定?答:按数据变更频率与一致性容忍度,短 TTL + 失效广播组合。
- 如何判断热点是否压垮节点?答:看单节点 CPU、网卡、命令排队与慢日志,对比整体集群水位。
04.4.10.1-031 Redis 集群分片如何路由键,hash tag 解决什么问题?
一句话结论
集群按 hash slot 把键分配到节点,命令按键槽位路由;hash tag({})强制相关键落到同一槽,保证多键操作与事务/Lua 在同节点执行。
概念解释
Redis Cluster 把 16384 个槽分配给节点,键经 CRC16 计算槽位。单键命令自动路由;多键命令、事务、Lua 要求所有键同槽,否则报错。hash tag 取 {} 内子串计算槽位,相关键用相同 tag 落到一起。Rust 客户端维护槽位映射,槽位迁移时刷新路由。
原理流程
- 客户端计算键槽位,路由到对应节点。
- 多键操作前确认槽位一致。
- 相关键设计统一 hash tag,如
order:{1001}:items。 - 节点扩缩容时槽位迁移,客户端更新映射。
- 跨槽操作拆分到单键命令,避免集群报错。
代码或图示
键:user:{1001}:profile 与 user:{1001}:orders
tag 内 1001 决定槽位 → 两键同槽,可多键操作
常见误区
- 多键事务不带 hash tag:集群下跨槽报错,事务失败。
- 假设客户端自动合并跨槽命令:集群不支持跨节点事务,需应用层拆分。
追问
- 集群下 Lua 脚本有什么约束?答:脚本涉及的键必须同槽;跨槽脚本无法在单节点原子执行。
- 槽位迁移期间命令会怎样?答:客户端按重定向响应刷新槽位映射;迁移细节以集群部署文档为准。
04.4.10.1-032 缓存值序列化选 serde_json 还是 MessagePack,体积与兼容性如何权衡?
一句话结论
JSON 可读性好、调试方便、跨语言通用,体积较大;MessagePack 二进制紧凑、体积与带宽更优,调试不直观;选型按缓存体积预算、跨语言消费与排障需求决定。
概念解释
Redis 值序列化格式影响网络带宽、内存占用与反序列化成本。JSON 文本可读,人工排查方便,前后端与多语言通用;二进制格式(MessagePack、bincode 等)压缩体积小但需消费端匹配格式。复杂对象选稳定格式;跨服务共享缓存必须双方格式一致。序列化 schema 演进要考虑旧缓存反序列化兼容。
原理流程
- 评估单值大小、访问频次与带宽预算。
- 跨语言/人工排查优先 JSON;内部高频大对象评估二进制格式。
- 封装序列化层,格式可替换。
- 缓存键带格式/版本前缀,格式切换时旧值可识别。
- 压测序列化耗时与体积,确认收益。
代码或图示
[dependencies]
serde_json = "*"
rmp-serde = "*" # MessagePack 序列化,待确认 crate 维护状态
常见误区
- 二进制格式不做版本标注:格式演进后旧缓存反序列化失败。
- 为省体积选不可读格式,线上排障困难:权衡可观测性。
追问
- bincode 适合跨语言缓存吗?答:不适合,格式与 Rust 类型耦合;跨语言选 MessagePack/JSON。
- 序列化性能瓶颈在哪?答:大对象反序列化 CPU 成本;热点小对象格式差异影响有限。
04.4.10.1-033 序列化与反序列化在缓存链路中如何影响性能,怎么优化?
一句话结论
缓存命令本身快,瓶颈常在应用层序列化/反序列化;优化方向是减少大对象序列化、复用缓冲区、选择紧凑格式、避免缓存不必要字段,并在压测中确认耗时占比。
概念解释
每次回填与读取都要序列化对象。大对象(嵌套结构、长列表)序列化占用 CPU 与内存临时分配。优化:缓存粒度拆分,只缓存需要字段;复用 serde 缓冲区;紧凑格式降体积;避免高频缓存大列表。序列化错误与类型不匹配要进入错误监控,不能静默丢弃。
原理流程
- 压测定位耗时:命令网络 vs 序列化 vs 业务组装。
- 缩小缓存对象字段与体积。
- 序列化复用缓冲区,减少临时分配。
- 评估紧凑格式的体积/CPU 权衡。
- 监控序列化失败率与缓存值大小分布。
代码或图示
链路:业务对象 → 序列化 → 网络 → 反序列化 → 业务对象
优化:字段裁剪 / 缓冲区复用 / 格式选型 / 拆分大对象
常见误区
- 缓存整张大对象:字段用不到也付出序列化成本。
- 忽略反序列化临时内存:高并发下分配压力大。
追问
- 零拷贝在 Redis 值上可行吗?答:网络传输与反序列化边界内有限;Rust 侧缓存字符串切片借用需结合连接生命周期评估。
- 序列化失败如何兜底?答:记错误指标,降级直连库;不要把损坏缓存值反复回填。
04.4.10.1-034 Redis 的过期删除策略是什么,惰性删除与定期清理如何配合?
一句话结论
Redis 采用惰性删除(访问时检查过期)加定期抽样清理(后台周期扫描)结合;过期键不是到点立刻移除,而是在访问时或后台抽样时被清理。
概念解释
惰性删除:每次读/写键前检查 TTL,过期则删除并返回未命中。定期清理:后台周期抽样带 TTL 的键,清理已过期比例高的样本。两者配合避免单线程被过期清理占满,也避免过期键长期占内存。理解这一策略有助于解释「内存中仍能看到过期键」「统计数量偏大」等现象。
原理流程
- 键写入时设置 TTL 与过期时间戳。
- 访问该键时先检查是否过期,过期即删除。
- 后台任务周期抽样带 TTL 键,清理过期项。
- 过期比例高时增加本轮清理强度(受配置约束)。
- 内存达上限再触发淘汰策略。
代码或图示
惰性:请求 → 检查 TTL → 过期则 DEL → 返回 miss
定期:后台抽样 → 清理过期键 → 调整下轮样本
常见误区
- 以为过期键到点立刻消失:未被访问也未被抽样到时仍占内存。
- 用
KEYS统计键数判断实际有效数据:过期未清理键会被计入。
追问
- 内存占用与过期键关系?答:大量过期未清理键会推高内存,配合淘汰策略与 TTL 设计控制。
- 如何确认过期策略配置?答:以 Redis 服务端配置文档为准;客户端不改变服务端过期行为。
04.4.10.1-035 maxmemory 淘汰策略有哪些,缓存场景通常选哪种?
一句话结论
淘汰策略分「不淘汰」与按 LRU/LFU/随机淘汰 volatile 或 allkeys;纯缓存场景通常选 allkeys-lru 或 allkeys-lfu,允许内存满时淘汰冷数据,持久化数据不应使用易淘汰策略。
概念解释
达到 maxmemory 后:noeviction 拒绝写入;volatile-* 只淘汰设 TTL 的键;allkeys-* 淘汰全部键。LRU 近似最近最少使用,LFU 统计访问频率。缓存场景数据可重建,选 allkeys 系列让冷数据被淘汰;存会话/任务状态等不可丢数据时,要避免易淘汰策略并预留内存。
原理流程
- 明确键是否可重建:可重建缓存 vs 不可丢状态。
- 可重建缓存:选 allkeys-lru/lfu。
- 不可丢数据:预留内存或 noeviction,写入侧限流。
- 监控内存水位与淘汰次数。
- 调整 maxmemory 与键 TTL 控制占用。
代码或图示
noeviction:内存满拒绝写
volatile-lru/lfu:只淘汰带 TTL 键
allkeys-lru/lfu:淘汰任意冷键(纯缓存常用)
常见误区
- 缓存与持久状态混在同一实例:淘汰策略误删不可丢数据。
- 不设 maxmemory:内存无限增长直至系统级问题。
追问
- LRU 与 LFU 怎么选?答:长热点、偶发扫描用 LFU 防冷数据污染;常见访问模式下 LRU 足够;具体样本策略以 Redis 版本实现为准。
- 淘汰会通知应用吗?答:不会主动通知,应用通过缓存 miss 回源;本地缓存需自行处理淘汰。
04.4.10.1-036 Redis 高可用形态有哪些:主从复制、哨兵、集群分别解决什么?
一句话结论
主从复制提供读副本与数据备份,哨兵负责主节点故障自动切换,集群提供分片扩容与高可用;选型按数据量、读写压力与可用性要求分层组合。
概念解释
单节点有单点风险。主从:写主节点,异步复制到从节点,读可分流。哨兵:监控主从,故障时选举切换新主,客户端感知新主。集群:数据分片到多节点,每节点可配副本,横向扩容。异步复制窗口内主故障可能丢失最近写入;强一致需求需评估方案局限。
原理流程
- 数据量小、读多:主从 + 哨兵保障高可用。
- 数据量或写压力大:集群分片,副本在节点内高可用。
- 客户端配置拓扑连接,故障切换后刷新路由。
- 监控复制延迟、节点状态与切换事件。
- 备份与持久化策略按数据重要性配置。
代码或图示
主从:主写从读,异步复制
哨兵:监控 + 自动故障转移
集群:槽位分片 + 副本 + 横向扩容
常见误区
- 把主从复制当强一致备份:异步复制有延迟窗口。
- 哨兵与集群混用概念:哨兵管单主组转移,集群管分片。
追问
- 故障切换期间写入会怎样?答:切换窗口内连接可能报错,客户端需重连重试;未复制到从的写入可能丢失。
- Rust 客户端如何感知拓扑?答:按连接配置支持哨兵/集群模式,槽位与主从信息由客户端刷新;具体配置以 redis-rs 文档为准。
04.4.10.1-037 哪些 Redis 命令容易阻塞,应用层如何规避大返回与慢命令?
一句话结论
全量遍历、大集合读取、大 key 删除与复杂聚合命令阻塞单线程;应用层避免 KEYS、限制返回体积、分批扫描、用异步删除,慢命令进监控。
概念解释
Redis 单线程执行命令,重命令期间其他客户端排队。风险命令:KEYS * 全扫描、HGETALL 大 Hash、SMEMBERS 大 Set、LRANGE 0 -1 长列表、大 key DEL。规避:SCAN 分批、分页取集合、限定 count、UNLINK 异步删大键。慢日志统计执行时长,接口层限制单次返回条数。
原理流程
- 审查命令模式,识别全量遍历与大集合读取。
- 遍历改
SCAN/HSCAN分批。 - 集合读取分页,限制单批条数。
- 大键删除用
UNLINK。 - 接入慢日志与命令耗时监控,定位阻塞点。
代码或图示
避免:KEYS * / 大 HGETALL / 大 SMEMBERS / 全量 LRANGE
替代:SCAN 分批 / 分页读取 / UNLINK
常见误区
- 后台清理任务用
KEYS全量扫:阻塞线上实例。 - 一次返回大列表再在应用层裁剪:传输与序列化双重浪费。
追问
- 慢命令日志在哪看?答:Redis 服务端 slowlog;客户端记录命令耗时与返回体积。
- 阻塞命令影响面多大?答:单实例上所有命令排队,从节点复制也受影响;集群下按节点隔离。
04.4.10.1-038 用 INCR 配合 EXPIRE 做计数器与限流,原子性如何保证?
一句话结论
INCR 原子自增计数;首键写入时设置过期时间实现窗口计数,限流判定读计数是否超阈值;计数与过期分开两步时注意并发下的 TTL 设置竞争。
概念解释
计数器场景:接口访问次数、每日签到、限额。INCR 单命令原子。TTL 问题:首次自增后 EXPIRE,并发下多请求同时判断键不存在,重复设过期;可用 Lua 把「自增 + 首次设 TTL」合并原子执行。限流按窗口(固定窗口/滑动窗口)结合阈值判断,超限拒绝。
原理流程
- 键按业务 + 窗口标识构造。
INCR自增,返回当前值。- 首次(值为 1)设置过期时间;并发场景用 Lua 保证只设一次。
- 判定当前值是否超阈值。
- 窗口过期自动清理计数。
代码或图示
let count: i64 = conn.incr("rate:user:1001", 1).await?;
if count == 1 { let _: () = conn.expire("rate:user:1001", 60).await?; }
常见误区
- 先 GET 判断再 INCR:判断与自增之间有并发窗口。
- TTL 每次请求都刷新:计数窗口被无限延长,限流失效。
追问
- 固定窗口与滑动窗口区别?答:固定窗口临界突刺;滑动窗口用 ZSet 记录时间戳或分段计数,成本更高。
- 计数器需要持久化吗?答:限流计数可容忍丢失;业务计数(库存)不能只靠 Redis,需数据库对账兜底。
04.4.10.1-039 缓存预热怎么做,启动时与定时预热分别解决什么问题?
一句话结论
预热在流量到来前把热点数据加载进缓存,避免冷启动大面积 miss;启动预热覆盖已知热点,定时/主动刷新应对数据更新与周期性热点,预热要分批限速避免冲击数据库。
概念解释
新实例上线或缓存清空后,直接承接流量会回源数据库。预热流程:梳理热点键清单(高频接口、配置、排行),分批从库加载回填缓存。启动预热在部署后、切流前完成;定时预热刷新周期数据;变更事件主动失效而非全量预热。预热脚本限速执行,避免一次性压垮数据库。
原理流程
- 梳理热点数据清单与访问优先级。
- 启动阶段分批加载,控制批次大小与间隔。
- 验证热点键命中率达标后切流。
- 定时任务刷新周期型热点。
- 数据变更走事件失效,不依赖全量重预热。
代码或图示
热点清单 → 分批 DB 查询 → 回填 cache(限速)→ 命中率达标 → 切流
周期数据:定时刷新;变更数据:事件失效 + 懒回填
常见误区
- 启动时全量加载所有数据:数据库与缓存同时被冲击。
- 预热后不校验命中率:切流仍有大量 miss。
追问
- 预热失败怎么处理?答:记录未预热键,流量到来时懒加载;降级保护数据库限流。
- 多实例预热重复吗?答:共享 Redis 只需预热一次;本地缓存各实例分别预热。
04.4.10.1-040 缓存故障时的降级策略有哪些,如何避免数据库被连带打垮?
一句话结论
降级手段包括:限流控制回源比例、返回旧值/空值/默认值、本地缓存兜底、只读降级;核心是缓存故障时不让全量请求直达数据库,按业务优先级分层放行。
概念解释
Redis 不可用或大面积 miss 时,数据库承接全部读流量,容易被打垮。降级链路:探测缓存健康度 → 触发限流 → 非核心接口返回默认/旧值,核心接口有限回源 → 本地缓存副本承接 → 缓存恢复后逐步放开。降级策略要预先演练,错误与超时进入监控,避免故障期间静默失败。
原理流程
- 监控缓存连接错误、超时与命中率下跌。
- 触发降级开关,按接口优先级限流回源。
- 非核心读返回旧值/空值/静态默认。
- 本地缓存与预留副本兜底热点。
- 缓存恢复后观察数据库负载,逐步解除限流。
代码或图示
缓存故障 → 限流回源 → 本地缓存/旧值/默认值 → 核心接口有限放行 → 恢复后逐步放开
常见误区
- 故障时所有请求直连库:数据库成为第二个单点。
- 降级返回空值不标注:客户端把空值当真实数据展示。
追问
- 降级数据如何标识?答:响应带降级标记或头部,前端展示兜底提示;监控区分正常 miss 与降级返回。
- 缓存连接超时设多久?答:按接口预算设置短超时,快速失败走降级,不等待长连接挂起。
04.4.10.1-041 缓存一致性按业务如何分级,哪些场景必须强一致,哪些接受最终一致?
一句话结论
一致性要求按业务分级:金额、库存、权限等强敏感数据优先查库或短缓存;展示类、统计类数据接受最终一致;分级决定 TTL、失效策略与是否走缓存。
概念解释
缓存引入副本必然有一致性窗口。强一致场景(扣款、权限判定、库存)不宜依赖缓存旧值,可加短 TTL + 主动失效 + 关键路径直查。最终一致场景(详情页、推荐列表、展示计数)容忍秒级旧值。设计时明确每类数据的容忍窗口,而不是所有数据同一套缓存策略。
原理流程
- 按业务划分一致性等级:强敏感 / 可短暂旧值 / 可延迟。
- 强敏感:短 TTL、变更主动失效、关键判定直查库。
- 可容忍:常规旁路缓存 + TTL 兜底。
- 低敏感:长 TTL,定时刷新。
- 监控不一致投诉与对账数据。
代码或图示
强一致:库存/金额/权限 → 直查或短 TTL + 主动失效
最终一致:详情/列表/展示计数 → 旁路缓存 + TTL
常见误区
- 权限标识也长缓存:旧权限导致越权访问窗口。
- 为所有数据追求强一致:缓存失去减负意义。
追问
- 强一致数据能不能用缓存加速读?答:可缓存只读副本做展示,判定逻辑以库为准;缓存结果标注用途。
- 一致性窗口怎么度量?答:从变更提交到缓存失效/回填的时间差,结合订阅延迟与 TTL 评估。
04.4.10.1-042 缓存 Key 设计有哪些规范,命名空间、版本与 TTL 如何规划?
一句话结论
键名按「业务域:类型:标识」分层命名,带版本前缀便于格式切换,避免空格与特殊字符;TTL 按数据等级分组规划,键设计要支持批量失效与排查。
概念解释
键是缓存接口的一部分,命名混乱导致无法批量管理与排查。规范:小写冒号分段,业务前缀隔离多实例共享;版本前缀(v1:)应对序列化格式演进;对象键含主键;集合键标注分片/分页。避免过短无意义键,避免把敏感信息编码进键。TTL 分组:临时数据短,配置类长,不可重建数据另设策略。
原理流程
- 定义键规则:
版本:业务:类型:标识。 - 同一对象的相关键用统一标识(可配合 hash tag)。
- 格式/结构升级时新版本前缀隔离旧缓存。
- 按数据等级规划 TTL 区间。
- 清理脚本按前缀扫描(SCAN),支持批量失效。
代码或图示
v1:user:profile:1001
v1:order:items:1001
v1:cfg:feature:home
常见误区
- 键名含环境/实例信息导致无法跨环境排查:环境隔离放前缀段,不混入标识。
- 不同业务共用无前缀键:互相覆盖或难以清理。
追问
- 批量失效怎么做?答:按前缀 SCAN 匹配后删除;大前缀分批限速,避免阻塞。
- 键里能放手机号等隐私标识吗?答:避免明文隐私,用哈希标识或内部 ID。
04.4.10.1-043 如何用 Redis 实现唯一约束与幂等键,SETNX 语义在并发下如何保证?
一句话结论
SET NX 仅在键不存在时写入成功,可做唯一占位与幂等记录;返回是否设置成功判断冲突,配合 TTL 自动清理过期幂等记录,业务侧再用数据库约束兜底。
概念解释
场景:防止重复提交、订单幂等、用户名占用。Redis SETNX/set_nx 单命令原子判断+写入,并发下只有一个请求成功。幂等键通常带业务标识与过期时间;重要唯一约束仍需数据库唯一索引兜底,Redis 只做前置拦截。幂等记录保存请求结果,重复请求直接返回首次结果。
原理流程
- 生成幂等键(业务类型 + 业务唯一标识)。
SET NX PX占位,成功才执行业务。- 业务结果写入幂等记录,重复请求返回结果。
- TTL 到期清理;唯一约束数据库索引兜底。
- 占位失败按「重复请求」处理,不重复执行写操作。
代码或图示
let inserted: bool = conn
.set_nx_ex("idem:order:create:abc123", "processing", 86_400)
.await?;
常见误区
- 只靠 Redis 防重:Redis 故障或键过期后重复提交直达库,需数据库唯一约束。
- 幂等记录不存结果:重复请求无法返回首次响应,只能拦截。
追问
- 幂等 TTL 多长?答:按业务允许重复提交窗口定,覆盖重试周期即可,避免长期占内存。
- 占位后业务失败如何释放?答:失败删除占位键允许重试;成功则保留结果记录到 TTL。
04.4.10.1-044 用 ZSet 做排行榜如何实现加分、取名次与分页,分数并列怎么处理?
一句话结论
ZSet 成员为对象标识,分数为排行值;ZINCRBY 加分,ZREVRANGE 按分数倒序分页,ZRANK 取名次;分数并列需加次要排序键保证顺序稳定。
概念解释
排行榜场景:积分榜、销量榜、热度榜。ZSet 按分数排序,成员唯一。加分原子更新分数;范围查询取 Top N;名次按分数位置。并列分数时成员顺序不保证业务可读,可把「分数 + 时间戳/序号」编码为复合分数,或查询时处理并列。榜单周期重置用新键或清理成员。
原理流程
- 成员写入/更新分数:
ZADD/ZINCRBY。 - 倒序取 Top N:
ZREVRANGE start stop WITHSCORES。 - 查成员名次:
ZRANK/ZREVRANK。 - 并列场景设计复合分数或并列规则。
- 周期榜单换新键,旧键到期清理。
代码或图示
ZADD rank:weekly 100 user:1001
ZINCRBY rank:weekly 10 user:1001
ZREVRANK rank:weekly user:1001
ZREVRANGE rank:weekly 0 9 WITHSCORES
常见误区
- 并列分数顺序依赖成员名:不可预测,需明确并列规则。
- 大榜单全量取出分页:按范围分页,限制单批条数。
追问
- 榜单数据如何持久化?答:Redis 榜单可重建,周期快照落库;崩溃后从数据源重算。
- 多维度排行怎么做?答:每维度一个 ZSet,或复合分数编码维度;跨维度排序在应用层处理。
04.4.10.1-045 用 Set 做去重与集合交集,适合哪些场景,性能边界是什么?
一句话结论
Set 承载唯一成员,SADD 去重,SISMEMBER 判断存在,交并差集做集合运算;适合标签、共同好友、已读集合,大集合运算需评估成员规模与节点内存。
概念解释
去重场景:文章已读、用户标签、设备集合。Set 成员唯一,添加重复无效。集合运算(交集/并集/差集)在 Redis 侧完成,减少应用层拉取全量。大集合运算消耗 CPU 与内存,集群下跨槽集合运算受限;成员编码与过期策略按业务设计。
原理流程
- 成员加入:
SADD,重复成员自动忽略。 - 存在判断:
SISMEMBER。 - 集合关系:
SINTER/SUNION/SDIFF。 - 大集合分页或限量取成员。
- 集合过期随 TTL 或成员清理。
代码或图示
SADD tag:article:1001 rust
SISMEMBER tag:article:1001 rust
SINTER friends:1001 friends:1002 # 共同好友
常见误区
- 大集合做全量交集聚类:CPU 与内存峰值高,限速分批。
- 集群跨槽集合运算:需相关键同 hash tag,否则不支持。
追问
- 已读集合无限增长怎么办?答:按时间分段或只保留近期;历史已读落库,缓存保留活跃窗口。
- Set 与 ZSet 去重区别?答:Set 无序,ZSet 带分数可排序;只需存在性用 Set。
04.4.10.1-046 会话与 Token 存 Redis 有哪些设计要点,过期与刷新如何管理?
一句话结论
会话/Token 以标识为键存储身份与元数据,设置过期时间;刷新与登出主动失效,存储只放必要声明,敏感信息不入缓存。
概念解释
无状态 Token 本身携带声明,Redis 存储用于服务端可撤销会话:登录态、刷新令牌、强制下线名单。键设计:session:<token-id>,值含用户 ID、设备、过期时间。TTL 与令牌有效期对齐;刷新时轮换标识,登出删除键。会话数据变更(角色调整)需同步失效旧会话。
原理流程
- 登录成功生成会话标识,写入 Redis 含身份与元数据。
- 请求校验取会话,检查存在与未过期。
- 临近过期按策略刷新,轮换会话标识。
- 登出/强制下线删除会话键。
- 权限变更后失效相关会话。
代码或图示
session:<jti> → { userId, device, issued_at }
TTL = 会话有效期;刷新轮换 jti;登出 DEL
常见误区
- 会话键不设过期:登出遗漏后僵尸会话长期驻留。
- 缓存存密码等敏感字段:会话只放公开声明与引用 ID。
追问
- 多端登录会话怎么管?答:按用户维度维护会话标识集合,支持单端/全端下线;具体模型与认证章节衔接。
- Redis 故障对登录态影响?答:服务端会话不可用时降级策略需预定义;无状态 JWT 可缓解但撤销能力下降,权衡见 04.4.11.1。
04.4.10.1-047 如何用 Hash 设计对象二级索引,字段更新与一致性注意什么?
一句话结论
Hash 把对象字段映射为 field-value,支持字段级读写;二级索引按查询维度维护独立键,写入时多键更新需原子或补偿,避免索引与主数据漂移。
概念解释
对象缓存用 Hash 便于局部更新:改一个字段不用序列化整对象。二级索引(按状态、分类、时间排序)需要额外键(Set/ZSet)指向主键。写入主对象时同步更新索引,多键操作在单节点用事务/Lua,跨节点接受最终一致并做对账。索引键设计要支持按维度清理。
原理流程
- 主对象存 Hash:
HSET user:1001 name age。 - 查询维度建索引:状态 Set、时间 ZSet。
- 写入/更新时先改主对象,再维护索引。
- 多键一致性用事务/Lua(同槽)或异步补偿。
- 定期对账主数据与索引,修复漂移。
代码或图示
HSET user:1001 name Ann age 30
SADD idx:user:status:active 1001
ZADD idx:user:created <ts> 1001
常见误区
- 只更新主对象不维护索引:按维度查不到或查到旧状态。
- 索引不随删除清理:陈旧成员指向已删对象。
追问
- Hash 字段值类型有限制吗?答:field/value 为字符串;结构化值在字段内再序列化,复杂对象评估 String 整体缓存。
- 索引重建怎么做?答:从主数据全量重算索引键,分批切换,旧索引到期清理。
04.4.10.1-048 redis-rs 的错误类型如何分类,哪些错误可重试,哪些必须拒绝?
一句话结论
RedisError 携带错误类别与消息:网络/连接类可重连重试,命令参数/语法类不可重试,服务端业务错误按语义处理;应用层区分可重试与致命错误并记录指标。
概念解释
错误来源:连接断开、超时、认证失败、命令语法错误、服务端运行错误、类型不匹配。可重试:临时网络抖动、连接重置(配合退避)。不可重试:参数错误、键类型不符、认证失败。重试要有上限与退避,避免故障风暴。错误包装进领域错误,日志保留原始类别。
原理流程
- 捕获
RedisError,读取错误类别/详情。 - 网络/超时类:有限次退避重试。
- 参数/类型类:不重试,记录缺陷并返回业务错误。
- 认证/配置类:告警并停止重试。
- 错误指标按类别上报监控。
代码或图示
match conn.get::<_, String>("k").await {
Ok(v) => Ok(v),
Err(e) if e.is_connection_refusal() => retry(),
Err(e) => { metrics::redis_error(&e.to_string()); Err(e.into()) }
}
常见误区
- 所有错误无限重试:参数错误被反复执行,放大故障。
- 错误消息直接透传给客户端:内部细节泄漏(与 GraphQL 错误脱敏一致)。
追问
- 错误类别判断 API 有哪些?答:以 docs.rs/redis
RedisError方法为准;连接、超时、服务端错误可分类处理。 - 重试幂等性要求?答:写操作重试必须幂等,避免重复扣减/重复下单。
04.4.10.1-049 批量读取缓存如何用 mget 减少往返,部分键未命中如何回源?
一句话结论
MGET 一次取多键,减少 RTT;返回值按顺序对应键,未命中位置为 nil;应用层拆分命中与缺失,批量查库后回填,避免逐条往返。
概念解释
列表页常需批量取关联对象。逐条 GET 累积往返,MGET 一次取回。响应与请求键顺序一致,缺失键返回空。应用层:拆分命中键与缺失键 → 批量查库(IN 查询)→ 回填缓存 → 组装结果。注意返回体积与键数量上限,分批 mget。
原理流程
- 收集待缓存键列表。
MGET批量取回,按顺序解析。- 拆分命中值与缺失键。
- 缺失键批量查数据源,回填缓存。
- 组装完整结果返回。
代码或图示
let keys: Vec<String> = ids.iter().map(|i| format!("v1:item:{i}")).collect();
let vals: Vec<Option<String>> = conn.mget(keys).await?;
// vals 与 keys 顺序一致;None 对应未命中
常见误区
- 缺失键逐个查库:批量场景退化为 N+1。
- 单批 mget 键过多:返回体积大,分批控制。
追问
- mget 与 pipeline 关系?答:mget 是原生多值命令;pipeline 可批多条不同命令,按需选择。
- 回填批量数据注意什么?答:批量回填限速,失败部分记录;不要因单条失败丢弃整批结果。
04.4.10.1-050 缓存仓储层如何封装,业务代码应依赖什么抽象?
一句话结论
在业务与 Redis 之间封装缓存仓储接口:get/set/delete/批量取与失效,业务依赖接口而非具体命令;封装内统一序列化、键规则、降级与指标,便于替换实现与测试替身。
概念解释
直接在 handler 写 Redis 命令会导致键规则、序列化与重试逻辑散落。仓储层抽象:按业务对象定义缓存接口(get_profile、invalidate_profile),内部实现 Redis 读写、序列化、键构造与错误处理。测试时用内存替身实现接口。缓存与数据库访问分层:缓存未命中由仓储层触发回源还是由服务层编排,需统一约定。
原理流程
- 定义业务缓存 trait:按对象与操作划分方法。
- Redis 实现负责键规则、序列化、TTL、错误分类。
- 服务层调用缓存接口,不接触 redis-rs 类型。
- 注入实现(生产 Redis / 测试内存替身)。
- 指标与降级在封装层统一埋点。
代码或图示
trait ProfileCache {
async fn get(&self, id: u64) -> Option<Profile>;
async fn put(&self, p: &Profile);
async fn invalidate(&self, id: u64);
}
常见误区
- 封装层暴露原始连接:业务仍可写任意命令,规则被绕过。
- 缓存接口与数据库接口混用:职责不清,一致性策略分散。
追问
- 回源逻辑放缓存层还是服务层?答:推荐服务层编排「缓存 miss → 查库 → 回填」,缓存层只做存取,便于事务与一致性控制。
- 如何做缓存层单元测试?答:trait 抽象 + 内存实现替身,断言命中、回填与失效调用。
04.4.10.1-051 moka 在 Rust 本地缓存中承担什么角色,如何引入?
一句话结论
moka 是 Rust 高性能内存缓存库,提供容量/权重控制、TTL、并发加载与近似 LFU 淘汰;作为进程内缓存承接热点读,与 Redis 组成多级缓存。
概念解释
本地缓存驻留应用进程内存,访问无网络开销,适合热点小对象。moka 封装了并发哈希表、淘汰策略与过期管理,API 区分同步缓存与异步缓存(配合运行时)。它不跨进程共享:每个实例持有自己的副本,一致性需通过失效广播或短 TTL 控制。引入时按是否在 async 上下文选择对应缓存类型。
原理流程
Cargo.toml引入moka,按运行时需要 feature。- 构造缓存实例,配置容量/权重与过期策略。
- 业务读路径先查本地缓存,命中直接返回。
- 未命中经加载回调取数并写入缓存。
- 淘汰与过期由库后台维护。
代码或图示
[dependencies]
moka = "*"
// 待确认:缓存构造 API 以 docs.rs/moka 当前版本为准
// use moka::sync::Cache;
// let cache = Cache::new(10_000);
常见误区
- 把本地缓存当分布式共享存储:多实例副本互不可见,更新需广播失效。
- 本地缓存无容量上限:进程内存被无限占用。
追问
- moka 同步与异步缓存怎么选?答:async 上下文用异步缓存类型,避免阻塞运行时;具体类型名以 docs.rs 为准。
- 本地缓存适合存什么?答:只读配置、热点详情、字典表;易变大对象与强敏感数据谨慎放入。
04.4.10.1-052 moka 的容量与权重(max_capacity / per-entry weight)如何配置?
一句话结论
max_capacity 按条目数限制缓存规模;权重模式下每条目可带自定义 weight,max_weight 控制总权重,适合条目大小差异大、按内存占用淘汰的场景。
概念解释
条目数限制简单,但每条对象大小不一时,按数量淘汰不能反映内存占用。moka 权重模式给每个条目分配权重(如估算字节数),总权重超上限触发淘汰。权重估算由业务提供,库按权重计数。配置时区分条目缓存与权重缓存两种构造方式,具体 builder 方法以当前版本文档为准。
原理流程
- 评估条目大小是否均一:均一用条目容量,差异大用权重。
- 构造缓存设置
max_capacity或max_weight。 - 写入条目时提供权重值(按估算字节/字段数)。
- 总权重超限时按淘汰策略移除条目。
- 监控缓存占用与淘汰次数回调。
代码或图示
// 伪代码:权重模式
// let cache = Cache::builder().max_weight(10_000_000).build();
// cache.insert(key, value, 3_000); // 条目权重 3000
常见误区
- 权重估算忽略字符串/集合实际容量:内存占用被低估。
- 权重设为 0:条目不占额度,可无限驻留。
追问
- 淘汰按什么策略?答:moka 采用近似 LFU(TinyLFU)思路,结合访问频率与新近度;详见后续题。
- 容量怎么定?答:按进程内存预算与热点数据量压测,预留对象元数据与哈希表开销。
04.4.10.1-053 moka 的 time_to_live 与 time_to_idle 有什么区别?
一句话结论
time_to_live 从写入起固定存活到期即失效;time_to_idle 从最后一次访问起算,长期未访问才过期,持续被访问的条目可续期。
概念解释
两种过期语义覆盖不同诉求。TTL(存活时间)保证数据陈旧上限,适合需要强制刷新的数据。Idle(空闲时间)清理冷门条目,频繁访问的热点不被过早淘汰。可单独使用,也可组合:两条时间都设置时先到期者生效。本地缓存过期由库后台扫描与访问时检查共同完成。
原理流程
- 写入条目记录写入时间与最后访问时间。
- TTL 模式:当前时间超写入时间 + TTL 即失效。
- Idle 模式:当前时间超最后访问时间 + idle 即失效。
- 组合配置下任一条件满足即淘汰。
- 访问命中时刷新最后访问时间(仅 idle 语义生效)。
代码或图示
// 伪代码
// Cache::builder()
// .time_to_live(Duration::from_secs(300))
// .time_to_idle(Duration::from_secs(60))
// .build()
常见误区
- 混淆两种语义:用 idle 期望强制刷新,热点条目被反复续期永不过期。
- 过期时间不区分数据等级:配置类与易变数据同一 TTL。
追问
- 过期条目何时真正移除?答:访问时检查 + 后台清理结合;未访问的过期条目可能短暂驻留内存。
- 本地缓存 TTL 比 Redis 短还是长?答:本地副本一致性窗口更敏感,通常 TTL 更短,并配合失效广播主动剔除。
04.4.10.1-054 TinyLFU 淘汰策略的基本原理是什么,相比经典 LRU 有什么优势?
一句话结论
TinyLFU 用频率统计(计数素描)估计条目热度,结合新近度过滤冷数据;相比 LRU 只看最后访问位置,它对扫描突发与偶发访问更稳健,不易被一次性大量冷数据挤掉热点。
概念解释
经典 LRU 按最近访问排序,批量冷数据扫描会把热点挤出。TinyLFU 维护小体积频率估计结构,区分「高频真热点」与「偶发访问」,新条目先经过新近度窗口再决定进入主缓存。moka 采用该类近似策略。工程上不必手写频率统计,理解其对突发扫描的免疫力即可;命中率差异需压测验证。
原理流程
- 条目访问时更新频率估计计数。
- 新进入条目先在 admit/窗口阶段观察。
- 超容量时按频率与新近度淘汰低价值条目。
- 冷数据(低频率)优先被移除。
- 热点在频繁访问下保留在缓存中。
代码或图示
LRU:按最后访问时间排序,冷扫描冲掉热点
TinyLFU:频率估计 + 新近度窗口,抗一次性冷数据冲击
常见误区
- 以为淘汰策略决定绝对最优命中率:工作负载不同,LRU/LFU 表现需按实际访问模式压测。
- 自行实现频率计数替代库:引入复杂度与一致性风险。
追问
- 频率统计有误差吗?答:素描结构是近似估计,存在小概率误判;目的是小内存换大体量热度估计。
- 本地缓存淘汰与 Redis 淘汰策略要一致吗?答:不必一致,两层数据特性不同;各自按工作负载配置。
04.4.10.1-055 moka 的 get_with 如何实现并发加载,single flight 解决什么问题?
一句话结论
get_with 在缓存未命中时执行加载回调并写入;相同键的并发请求共享同一次加载结果(single flight),避免缓存击穿时多个任务同时回源。
概念解释
本地缓存击穿场景:热点键过期瞬间,多个并发任务同时未命中。若各自执行回调查库,形成本地击穿。get_with 把加载中状态按键记录,后续同键请求等待同一结果。回调只执行一次,结果回填后并发方都拿到。这与 Redis 层互斥重建思路一致,但发生在进程内。
原理流程
- 读缓存:命中直接返回。
- 未命中且无加载中记录:执行
get_with回调取数。 - 同键后续请求发现加载中,等待共享结果。
- 回调成功写入缓存,通知等待方。
- 回调失败按策略返回错误,不写入缓存。
代码或图示
// 伪代码:get_with 接收 key 与异步/同步加载闭包
// let v = cache.get_with(&key, || repo.find(id)).await?;
常见误区
- 回调内做阻塞重计算:占用加载通道,single flight 下放大影响。
- 回调返回错误也写入缓存:失败结果被缓存,后续一直拿到错误。
追问
- 加载中等待有超时吗?答:按库实现与回调超时控制;等待方应设上限,避免回调卡死拖垮所有同键请求。
get_with与手动get+insert区别?答:手动写法无 single flight 合并,并发未命中会重复加载。
04.4.10.1-056 本地缓存如何避免击穿,加载回调与互斥策略怎么配合?
一句话结论
本地层用 single flight 合并同键加载;跨进程击穿由 Redis 层互斥或单飞兜底;热点数据可加逻辑过期与异步刷新,请求不等重建。
概念解释
击穿分两层:进程内并发(moka get_with 合并)与多实例同时回源(Redis 锁/单飞)。防护组合:本地合并 → Redis 层防多实例同时打库 → 逻辑过期后台刷新。回调要轻量、可重试;失败不缓存错误值。热点永不过期场景用后台异步刷新保证新鲜度。
原理流程
- 本地未命中:
get_with合并进程内并发加载。 - 需要回源数据库时,经 Redis 层互斥或 single flight 限制单实例重建。
- 热点数据采用逻辑过期:返回旧值,后台异步刷新。
- 加载失败短暂重试,不缓存失败结果。
- 监控未命中回源量,识别击穿征兆。
代码或图示
进程内:get_with single flight
跨实例:Redis 重建锁 / 单飞
热点:逻辑过期 + 异步刷新
常见误区
- 只做本地合并:多实例同时 miss 仍集体回源。
- 缓存错误值:后续请求被错误结果短路,无法恢复。
追问
- 逻辑过期在本地缓存怎么实现?答:值内嵌逻辑时间戳,读到过期值先返回旧值并触发后台刷新;库异步任务机制见 04.4.10.3。
- 重建锁 TTL 怎么定?答:覆盖回源耗时并留余量,持锁失败等待或返回旧值。
04.4.10.1-057 moka 与 dashmap 有什么本质差异,dashmap 适合做缓存吗?
一句话结论
dashmap 是并发分片哈希表,提供线程安全的 get/insert,但不内建淘汰、TTL 与加载合并;moka 是完整缓存方案,带淘汰策略、过期与 single flight。dashmap 适合固定并发映射,做缓存需自行补容量与过期管理。
概念解释
dashmap 通过分片减少锁竞争,定位是通用并发 map。作为缓存使用时:容量无上限、条目永不过期、冷数据不淘汰,需要业务自己实现 TTL 清理与淘汰。moka 在并发 map 之上封装缓存语义。选型:数据量小且固定映射用 dashmap;需要缓存治理(容量、过期、热点保护)用 moka。
原理流程
- 判断需求:纯并发键值映射还是缓存治理。
- 固定字典、配置映射:dashmap 直接可用。
- 需容量淘汰、过期、并发加载:选 moka。
- 若用 dashmap 做缓存,补 TTL 扫描、容量上限与清理任务。
- 封装统一缓存接口,实现可替换。
代码或图示
dashmap:并发哈希表,get/insert,无淘汰/TTL/加载合并
moka: 并发 map + 权重容量 + TTL/idle + TinyLFU + get_with
常见误区
- 把 dashmap 当缓存直接长期运行:条目累积导致内存增长。
- 在 dashmap 上反复遍历清理过期:与库并发模型冲突,效率低。
追问
- dashmap 锁竞争如何?答:分片锁降低单锁竞争;具体性能以基准测试为准。
- 两者能混用吗?答:可按场景分用,但同一对象缓存策略应统一,避免治理逻辑分裂。
04.4.10.1-058 dashmap 作为本地缓存有哪些局限,需要自己补哪些能力?
一句话结论
局限:无容量上限、无过期淘汰、无加载合并、无统计指标;用它做缓存需自实现 TTL 记录、后台清理、容量淘汰与命中统计,成本接近自建缓存。
概念解释
在 dashmap 上做缓存,业务要额外维护:每条目的写入/访问时间,定期扫描清理;超容量时淘汰策略;未命中并发去重;命中率与占用指标。通用 map 不提供这些钩子。如果这些能力都需要,直接用缓存库更稳妥;dashmap 更适合条目可控、生命周期由业务明确管理的映射。
原理流程
- 评估条目规模:是否可能无限增长。
- 补充元数据:时间戳、权重。
- 实现后台扫描清理过期条目。
- 实现容量淘汰(LIFO/LRU 简易版)。
- 增加命中/未命中指标与内存监控。
代码或图示
自建清单:过期时间记录 / 后台清理 / 容量淘汰 / single flight / 命中率指标
常见误区
- 只在插入时检查容量:访问后冷门条目不会被主动淘汰。
- 清理任务与 map 锁竞争未评估:扫描遍历影响读写性能。
追问
- 什么场景 dashmap 足够?答:进程内短生命周期映射、条目数量有上界、无需过期治理,如请求上下文索引。
- 自建淘汰要注意线程安全?答:dashmap 句柄可克隆并发访问;清理逻辑避免长持锁。
04.4.10.1-059 传统 lru 类 crate 与 moka 相比如何选择?
一句话结论
轻量 LRU 库实现简单、依赖少,适合条目少、无需 TTL 与并发加载的场景;moka 功能完整、并发友好,适合服务端热点缓存;选型按治理需求与并发模型决定。
概念解释
早期 Rust LRU 库多为单锁哈希链表,容量超限按 LRU 淘汰,API 简单。服务端高并发下单锁成为竞争点,且通常不内置 TTL 与异步加载。moka 面向并发服务场景,分片与策略更成熟。依赖敏感的小工具/嵌入式场景可用轻量 LRU;Web 服务本地缓存优先 moka 这类完整方案。
原理流程
- 列出缓存需求:并发度、过期、淘汰维度、加载合并。
- 需求简单:轻量 LRU 足够,编译体积小。
- 服务端并发与治理需求:选 moka。
- 压测对比命中率、延迟与锁竞争。
- 缓存接口抽象,保留替换余地。
代码或图示
轻量 LRU:容量淘汰、实现简单、并发支持有限
moka: 权重/TTL/idle、TinyLFU、并发加载、服务端导向
常见误区
- 为减少依赖在高并发服务用单锁 LRU:锁竞争拖慢吞吐。
- 不看当前版本维护状态:旧库可能停更,API 与安全性需核对。
追问
- 如何核对 crate 活跃度?答:查 docs.rs/crates.io 近期版本、issue 与下载量;不确定项标注待确认。
- 缓存抽象层设计要点?答:trait 暴露 get/put/invalidate,底层可换 LRU/dashmap/moka。
04.4.10.1-060 本地缓存的内存占用如何控制,进程内存边界怎么估算?
一句话结论
通过容量/权重上限、条目大小估算、过期清理与指标监控控制内存;估算要计入对象本身、哈希表开销与库元数据,预留进程其他内存预算。
概念解释
本地缓存直接吃进程内存,失控会触发 OOM 或被系统回收。控制手段:条目容量或权重上限;大对象不入本地缓存;TTL/idle 清理冷门;监控缓存条目数、权重与进程 RSS。估算单条成本:业务字段 + 字符串容量 + 库元数据,批量样本测量后乘条目数。
原理流程
- 测量典型条目在内存中的实际大小。
- 按并发与数据量估算最大条目数。
- 设置缓存容量/权重上限,留安全余量。
- 配置过期策略清理冷门条目。
- 监控 RSS、缓存条目数与淘汰事件,超限告警。
代码或图示
内存估算 = 单条大小 × 条目数 + 哈希表/元数据开销
上限设置 < 进程内存预算 × 安全系数
常见误区
- 只按条目数估算,忽略字符串与集合容量:实际内存远超预期。
- 本地缓存放大对象克隆:值被多次持有占用重复内存。
追问
- 大对象为什么不进本地缓存?答:单条占用大,少量条目即可吃满内存,且序列化/克隆成本高;大对象缓存放 Redis 或数据库侧。
- 内存指标在哪看?答:进程 RSS 与库自带统计(条目数、权重),接入可观测性章节的监控体系。
04.4.10.1-061 本地缓存与 Redis 如何组成多级缓存,请求链路怎么走?
一句话结论
多级缓存按「本地缓存 → Redis → 数据库」逐级回源;热点在本地命中省网络,Redis 承接跨实例共享数据,数据库为权威源;各级 TTL 与失效策略分层设计。
概念解释
一级本地缓存延迟最低但不共享,二级 Redis 跨实例一致,三级数据库兜底。请求先查本地,未命中查 Redis,再未命中查库并逐级回填。本地副本短期容忍旧值,Redis 作为共享副本。层级过多增加一致性复杂度,按数据热度选择是否启用本地层。
原理流程
- 请求先查本地缓存,命中返回。
- 本地未命中查 Redis,命中回填本地。
- Redis 未命中查数据库,回填 Redis 与本地。
- 写路径更新库,逐级失效缓存。
- 监控各级命中率定位瓶颈层级。
代码或图示
请求 → 本地缓存(moka) → Redis → 数据库
回填:DB → Redis → 本地
失效:写库 → 删 Redis → 广播失效本地
常见误区
- 每层都长 TTL:旧值叠加,不一致窗口拉长。
- 本地缓存未命中就直连库:跳过 Redis,共享副本失去意义。
追问
- 哪些数据适合放本地层?答:小体积、高频读、可容忍秒级旧值的热点;大对象与强一致数据留 Redis/库。
- 多级缓存命中率怎么看?答:分别统计本地命中、Redis 命中、回源率;本地命中率低说明本地层价值有限。
04.4.10.1-062 多级缓存如何保证一致性,失效广播怎么做?
一句话结论
写库后失效 Redis,再通过 Pub/Sub 或消息广播通知各实例剔除本地副本;本地层配合短 TTL 兜底,接受最终一致,广播丢失由 TTL 收敛。
概念解释
多实例本地副本无法逐一主动删除,依赖失效广播:变更事件发到频道,各实例订阅后清本地缓存键。广播本身不保证必达(Pub/Sub 离线丢失),所以本地 TTL 是兜底。事件携带键标识与版本,避免旧事件误删新值。订阅消费者要处理重复消息与消息顺序。
原理流程
- 写事务提交后删除 Redis 缓存键。
- 发布失效事件(键、类型、版本)到广播频道。
- 各实例订阅消息,按键清除本地条目。
- 本地 TTL 兜底:广播丢失后旧值有限期。
- 监听失败/积压进入监控告警。
代码或图示
写库 → 删 Redis → PUBLISH cache:invalidate {key, version}
各实例 SUBSCRIBE → 删本地 cache[key]
兜底:本地 TTL;版本号防旧事件误删
常见误区
- 广播不设版本:旧变更事件晚到,删掉新回填的本地值。
- 依赖广播强一致:Pub/Sub 离线消息丢失,必须 TTL 兜底。
追问
- 广播走什么通道?答:Redis Pub/Sub 轻量广播;要求可靠投递可用外部 MQ,可靠性权衡见 04.4.10.2。
- 本地缓存失效粒度?答:按对象键清除;列表/集合类缓存按前缀或标签批量失效。
04.4.10.1-063 本地缓存如何避免键污染与命名空间冲突?
一句话结论
本地键同样按「版本:业务:类型:标识」命名,不同业务域隔离前缀;避免全局混用同一 map,大对象与敏感数据不入本地缓存。
概念解释
本地缓存虽不跨实例共享,但同一进程内多业务共用一个缓存实例时,键冲突会互相覆盖。命名空间规则与 Redis 一致:版本前缀、业务前缀、对象类型。可按业务分多个缓存实例,容量与过期策略独立。键不含隐私明文,本地内存转储风险低于网络传输,但仍按规范处理。
原理流程
- 定义本地键命名规则与前缀段。
- 评估是否按业务拆分缓存实例。
- 写入前构造规范键,避免裸标识。
- 定期检查键分布,识别异常前缀。
- 清理任务按前缀批量失效。
代码或图示
v1:profile:1001
v1:dict:country
(本地实例内隔离,不与 Redis 键规则冲突但保持一致风格)
常见误区
- 本地缓存键用短名随机拼接:排查时无法定位业务归属。
- 多业务共享实例却不设前缀:测试数据覆盖生产缓存。
追问
- 本地缓存需要环境前缀吗?答:同一进程只跑一个环境时可简化;多环境混合部署必须加环境段。
- 键里能放查询参数组合吗?答:可编码排序后的参数作为键,注意组合数量膨胀。
04.4.10.1-064 本地缓存不做序列化有什么性能优势,代价是什么?
一句话结论
本地缓存直接持有 Rust 对象内存,跳过序列化/反序列化与网络拷贝,读取延迟最低;代价是对象驻留内存、跨语言/跨进程不可读,类型演进受进程内版本约束。
概念解释
Redis 值需要编码成字符串/二进制,读取再解码;本地缓存存的是对象(或克隆/引用),命中即取内存对象。优势:无编解码 CPU、无网络往返。代价:对象不能跨进程共享;进程重启数据丢失;结构体演进后旧内存对象需清理;值克隆会复制内存。本地缓存适合小对象与短生命周期副本。
原理流程
- 未命中时构造对象写入本地缓存。
- 命中直接返回对象(按库 API 共享/克隆语义)。
- 无序列化步骤,无格式版本转换。
- 进程重启后本地为空,重新回源预热。
- 结构体变更后旧条目按 TTL/版本前缀清理。
代码或图示
Redis:对象 → 序列化 → 网络 → 反序列化 → 对象
本地:对象直接驻留内存,命中零编解码
常见误区
- 本地缓存存大对象:内存占用与克隆成本高。
- 假设本地对象可被其他进程读取:本地副本不跨进程。
追问
- 本地返回对象是克隆还是引用?答:按缓存库 API 与键值类型决定;共享可变状态需内部可变性,通常克隆返回避免别名问题,具体以 moka 文档为准。
- 结构体改名后旧缓存怎么办?答:本地条目短期驻留,版本前缀/TTL 清理;进程重启自然清空。
04.4.10.1-065 进程重启或新实例上线后本地缓存冷启动怎么办?
一句话结论
冷启动靠预热加载热点数据,承接流量前达到命中率门槛;预热分批限速,失败条目懒加载,配合降级保护数据库。
概念解释
本地缓存在进程内存,重启即清空。新实例直接接流量会集中回源数据库。预热流程与 Redis 预热一致:热点清单分批加载进本地缓存。多实例各自预热(本地不共享)。预热期间或预热失败的请求走懒加载,限流兜底;健康检查通过后再全量切流。
原理流程
- 梳理热点对象清单与优先级。
- 实例启动后分批加载本地缓存,控制批次间隔。
- 检查本地命中率达标后再接全量流量。
- 未预热条目懒加载回源,有限流保护。
- 预热失败记录指标,告警人工介入。
代码或图示
实例启动 → 分批预热本地缓存 → 命中率达标 → 接流量
未命中 → 懒加载 + 限流;预热失败条目降级
常见误区
- 预热全量数据:数据库与进程内存同时被冲击。
- 不校验预热结果:带大量冷缓存上线,回源压力转嫁数据库。
追问
- 多实例预热重复吗?答:本地不共享,每个实例各自预热;Redis 预热一次即可被所有实例复用。
- 预热数据来源?答:热点统计、高频接口与配置字典;周期更新预热清单。
04.4.10.1-066 本地缓存如何防穿透,空值缓存与短 TTL 在进程内怎么落地?
一句话结论
本地层同样缓存空结果(空标记)短 TTL 防不存在数据反复回源;布隆过滤器可放本地或共享 Redis,空值条目与正常条目区分避免误判存在性。
概念解释
穿透在本地层表现为:不存在的键每次都 miss 并回源。落地方式:未命中数据库后,本地缓存空值标记,短 TTL 内直接短路。本地布隆过滤器按实例维护,重启重建;共享布隆放 Redis。空值缓存要与有效对象区分,避免把空标记当业务数据返回。
原理流程
- 本地未命中 → 查数据库。
- 数据库无记录:本地写入空值标记,短 TTL。
- 后续请求命中空标记,直接返回空,不回源。
- 数据新增后删除空标记,允许重新加载。
- 布隆过滤器作为前置不存在判断(可选)。
代码或图示
miss → DB 无 → 本地存 None/空标记(短 TTL) → 后续短路
新增数据 → 删空标记;布隆过滤器更新或重建
常见误区
- 空值缓存 TTL 过长:数据上线后长期被空标记挡住。
- 空标记与正常值同类型存储:返回时混淆,需显式区分。
追问
- 本地空值占用多大内存?答:空标记条目极小,可批量容纳;仍纳入容量统计。
- 布隆过滤器本地重建成本?答:集合大时重建有 CPU 成本,可定期后台重建并原子切换。
04.4.10.1-067 本地缓存压测应关注哪些指标?
一句话结论
核心指标:命中率/未命中率、平均加载耗时、条目数与权重(内存占用)、淘汰次数、single flight 等待情况;压测对比不同容量与 TTL 配置下的延迟与数据库回源量。
概念解释
缓存效果不能只看「有没有缓存」。命中率反映减负程度;加载耗时是未命中路径成本;内存占用决定容量上限;淘汰频繁说明容量不足;等待合并情况反映击穿防护。压测模拟真实访问分布(热点占比、条目规模),测 P50/P99 延迟与回源 QPS。
原理流程
- 构造贴近线上的访问分布与条目规模。
- 记录命中/未命中、加载耗时、条目与权重。
- 观测淘汰次数与等待队列。
- 调整容量、TTL 与加载策略。
- 对比配置下数据库回源量与接口延迟。
代码或图示
指标:hit ratio / miss rate / load latency(P99) / entries / weight / evictions / waiters
常见误区
- 只测平均延迟:未命中尖刺与 P99 被平均值掩盖。
- 压测数据均匀分布:真实热点集中,均匀分布高估缓存效果。
追问
- 命中率多少算健康?答:按业务定,热点缓存通常追求高命中;低命中先检查数据热度与 TTL 配置。
- 指标上报格式?答:接入 tracing/metrics 体系,按缓存实例与业务标签区分(见 04.4.12.1)。
04.4.10.1-068 Redis 服务端与客户端需要监控哪些指标?
一句话结论
监控命中率、内存占用与碎片、连接数、命令耗时/慢日志、Key 数量与剔除数;客户端侧监控连接池借用等待、命令错误分类与超时。
概念解释
服务端指标:键命中率、内存使用与 maxmemory 水位、碎片率、连接数、evicted_keys、慢查询日志、复制延迟。客户端指标:池大小/空闲/等待数、命令耗时分布、错误分类(连接/超时/参数)。指标结合才能判断是服务端瓶颈、客户端池耗尽还是慢命令。
原理流程
- 采集服务端 INFO 指标:内存、连接、键、淘汰、命中率。
- 采集慢日志定位重命令。
- 客户端上报池等待、命令耗时与错误类别。
- 配置水位告警:内存、连接、回源率下跌。
- 定期审查大 key 与热 key 排行。
代码或图示
服务端:hit rate / memory / fragments / clients / evicted / slowlog / replication lag
客户端:pool wait / command latency / error by kind / timeout count
常见误区
- 只监控连接存活:不看池等待与命令耗时,瓶颈发现滞后。
- 忽略淘汰数:持续淘汰说明容量不足,数据反复回源。
追问
- 命中率如何计算?答:
keyspace_hits / (hits + misses),按 INFO 统计;分业务键组更有意义。 - 慢日志阈值怎么设?答:按接口预算设置命令执行时长阈值,定期导出审查。
04.4.10.1-069 缓存方案如何做基准压测,压测场景设计有哪些要点?
一句话结论
基准压测要模拟真实访问分布(热点集中、条目规模、读写比例),分层测量本地/Redis/数据库耗时,对比容量、TTL、序列化格式与池配置,记录 P99 与回源量。
概念解释
缓存压测不能只跑单点 get 延迟。要点:数据规模贴近线上;访问分布含热点与长尾;混合读写;测量未命中重建路径;验证击穿、雪崩降级场景。工具可按 Rust 基准框架或压测客户端构造并发请求。压测结论要落到配置参数:池大小、容量、TTL、批大小。
原理流程
- 确定基线:条目量、访问分布、读写比、接口延迟预算。
- 准备测试数据与缓存预热。
- 并发加压,分层记录各级耗时与回源 QPS。
- 故障注入:Redis 不可用、键过期潮、大 key。
- 对比配置项,输出推荐参数与容量边界。
代码或图示
场景:热点读 / 批量回源 / 击穿并发 / 雪崩过期 / Redis 故障降级
度量:P50/P99 延迟、命中率、回源 QPS、池等待、内存占用
常见误区
- 均匀随机访问:测不出热点缓存价值。
- 只压成功路径:降级与故障恢复路径未验证。
追问
- 基准测试用什么工具?答:Rust 侧可用 criterion 做微基准,接口层用通用压测工具;具体工具链选择以项目现有体系为准。
- 压测环境要注意什么?答:隔离网络与实例,避免共享 Redis 干扰;数据量与生产同量级。
04.4.10.1-070 序列化格式或结构体演进后,缓存里的旧数据如何处理?
一句话结论
缓存键带格式/版本前缀,演进时旧版本键自然过期不参与解析;本地缓存重启清空或按版本清理,避免旧格式反序列化失败污染新逻辑。
概念解释
结构体字段增减、类型调整后,旧缓存值按新结构反序列化可能失败或字段错位。策略:键前缀含版本号(v1:/v2:),新逻辑只读写新版本键;旧键靠 TTL 自然淘汰。本地缓存重启即清空;Redis 旧键批量清理或等过期。序列化格式切换(JSON→二进制)同样用版本前缀隔离。
原理流程
- 结构变更时提升缓存键版本段。
- 新代码只读写新版本键。
- 旧版本键保留到 TTL 到期,不主动解析。
- 必要时按前缀扫描清理旧键(限速 SCAN)。
- 本地缓存随进程重启清空。
代码或图示
v1:item:1001 旧格式(TTL 淘汰)
v2:item:1001 新结构
反序列化失败不回填缓存,避免错误值驻留。
常见误区
- 结构体演进后复用旧键:旧值反序列化报错或静默错位。
- 缓存错误值:解析失败再次写入,错误被反复短路。
追问
- 旧键需要立即清理吗?答:非必须,TTL 兜底;占内存大时按前缀限速清理。
- 兼容期能同时读新旧格式吗?答:可在解析层尝试新旧两种格式,成功后回填新键;复杂度按兼容性收益评估。
04.4.10.1-071 缓存 Key 版本号前缀在多级缓存中如何使用?
一句话结论
版本前缀同时用于 Redis 与本地键,标识数据格式/结构版本;格式升级切新版本前缀,旧版本键隔离淘汰,两层缓存版本规则保持一致便于排查。
概念解释
版本前缀解决「代码已升级、缓存还是旧结构」的问题。多级缓存中本地与 Redis 键使用同一版本段,失效广播携带版本判断。升级时不需要清空全部缓存:新版本键逐步回填,旧版本自然过期。回滚代码时旧版本键仍在,降低回滚风险。
原理流程
- 键规则首段为版本号常量。
- DTO/格式变更时提升版本。
- 读写路径统一通过键构造函数生成键。
- 失效事件带版本,旧事件不删新键。
- 旧版本键 TTL 到期清理。
代码或图示
构造:format!("v{ver}:{domain}:{type}:{id}")
变更:v1 → v2;v1 键不被新代码读取
常见误区
- 版本前缀只加在 Redis,本地用裸标识:两层键规则不一致,失效广播难对齐。
- 版本号散落硬编码:升级时漏改某处导致读写分裂。
追问
- 版本号放键还是放值内?答:键前缀用于隔离旧格式不被解析;值内可存 schema 版本辅助兼容解析。
- 回滚后旧版本键还能用吗?答:保留旧版本键正是为回滚兜底;新版本键不影响旧代码。
04.4.10.1-072 本地缓存批量读取与缺失回源如何组织?
一句话结论
本地层批量取键集合,拆分命中与缺失;缺失键经 Redis/数据库批量回源,回填本地与 Redis;批量大小受控,失败部分不丢弃整体结果。
概念解释
列表场景批量取关联对象。本地批量查询返回键值映射,缺失键收集后走二级缓存与数据库批量查询(IN)。回填顺序:先 Redis 后本地。批量键数量分批,避免单批占用过大;部分回源失败的条目保留未命中,不缓存失败。
原理流程
- 收集本地待查键列表。
- 批量读取本地,拆分命中与缺失。
- 缺失键批量查 Redis,再拆分回源数据库。
- 批量查库后回填 Redis 与本地。
- 组装完整结果,记录未命中条目。
代码或图示
本地批量 get(keys) → 命中集合 / 缺失集合
缺失 → Redis mget → 仍缺失 → DB IN 查询 → 回填 Redis/本地
常见误区
- 缺失键逐个回源:批量场景退化为 N+1。
- 回填时整批阻塞:分批限速,失败部分单独记录。
追问
- 本地批量读取 API 有哪些?答:按 moka 版本提供批量 get 或逐条聚合;具体方法名以 docs.rs 为准。
- 批量回填顺序影响一致性吗?答:先填 Redis 再填本地,读路径一致;短暂窗口本地可能缺项,下次读从 Redis 补。
04.4.10.1-073 空对象与短路缓存如何设计,避免空值被反复回源?
一句话结论
查询无结果时缓存空值/空对象标记,短 TTL 短路后续请求;区分「空集合」与「未缓存」,数据生成后主动清除空标记。
概念解释
空结果(无记录、空列表)与正常结果同样会反复回源。空值缓存把未命中结果短期保存:本地存空标记,Redis 存空值或短 TTL 标记。注意空集合是业务合法结果,不能误当未缓存;新数据产生后要删空标记,否则新数据被空值挡住。
原理流程
- 数据源查询返回空。
- 写入空标记,TTL 短于正常缓存。
- 后续请求命中空标记直接返回空。
- 业务创建数据后删除对应空标记。
- 空标记条目纳入容量与监控统计。
代码或图示
DB 空 → 缓存 None/empty(短 TTL) → 后续短路
新增数据 → 删空标记 → 下次加载真实值
常见误区
- 空值 TTL 与正常值相同:新数据上线后长时间看不到。
- 不清除空标记:注册/创建类场景被空值短路。
追问
- 空集合要缓存吗?答:低频空结果可短缓存防穿透;高频变化列表不建议缓存空值。
- 空值如何序列化?答:Redis 存空标记字符串/空 JSON;本地用 Option 或空结构体区分。
04.4.10.1-074 热点数据异步刷新(逻辑过期)如何实现,与被动过期有何不同?
一句话结论
逻辑过期在值内记录过期时间,读到过期值先返回旧值,后台异步刷新缓存;请求不阻塞等待重建,区别于被动 miss 后同步回源。
概念解释
被动过期:键到期后下次请求 miss,同步查库回填,请求承担回源延迟。逻辑过期:缓存永不过期(或长 TTL),值内嵌逻辑时间;发现逻辑过期时返回旧值并触发后台任务刷新。适合可短暂旧值、不能接受重建延迟的热点。需要后台任务调度能力,刷新失败保留旧值待下次重试。
原理流程
- 缓存值写入逻辑过期时间戳。
- 请求读取判断是否逻辑过期。
- 未过期直接返回;已过期先返回旧值,提交异步刷新任务。
- 后台任务查库回填缓存,更新时间戳。
- 刷新失败不删旧值,下次请求再触发重试。
代码或图示
值结构:{ data, expire_at }
读:未过期 → 返回;过期 → 返回旧值 + 后台刷新
刷新:异步查库 → 回填;失败保留旧值
常见误区
- 异步刷新任务泄漏:任务随缓存生命周期管理,取消信号清晰。
- 逻辑过期值长期不刷新:后台任务失败无告警,需监控刷新成功率。
追问
- 后台任务用什么调度?答:Tokio 任务/定时调度组件,与 04.4.10.3 后台任务章节衔接。
- 逻辑过期适合强一致数据吗?答:不适合,旧值可能被展示;强敏感数据走主动失效或直查。
04.4.10.1-075 如何为每类数据设计缓存窗口(TTL、一致性容忍度)?
一句话结论
按数据变更频率与一致性要求分级定 TTL:强敏感短 TTL + 主动失效,展示类中等 TTL,字典配置长 TTL;每类数据明确容忍旧值窗口与失效方式。
概念解释
TTL 不是全局统一值。分级方法:先判断数据是否可缓存(敏感、大对象排除);再定一致性等级;最后选 TTL 与失效方式。变更频繁的数据长 TTL 会放大脏数据;冷门配置短 TTL 浪费回源。窗口设计要与业务方确认可接受的陈旧时长,并在文档中标注。
原理流程
- 列出缓存数据类别:身份权限、交易数据、详情、列表、字典配置。
- 标注一致性要求与变更频率。
- 选定 TTL 区间与失效方式(主动/广播/到期)。
- 强敏感数据评估是否不入缓存。
- 线上按投诉与对账数据回调窗口参数。
代码或图示
权限/金额:短 TTL + 主动失效,关键判定直查库
详情/列表:中等 TTL,旁路缓存
字典/配置:长 TTL,变更广播失效
常见误区
- 所有缓存同一 TTL:敏感数据旧值风险与冷门数据回源浪费并存。
- TTL 变更不评审:缩短影响命中率,拉长影响一致性。
追问
- 窗口怎么度量?答:从数据变更到缓存生效的延迟(主动失效时间 + TTL 兜底)。
- 多端看到不一致怎么办?答:按数据等级评估是否可接受;超窗口投诉排查失效广播与 TTL 配置。
04.4.10.1-076 库存扣减等超卖防护场景,Redis 原子操作如何配合数据库兜底?
一句话结论
Redis 用 Lua 或原子命令做预扣减拦截超卖,最终落库以数据库约束与事务为准;缓存层减负与前置拦截,不能替代数据库一致性保障。
概念解释
抢购场景高并发直接打数据库会超卖。常见链路:Redis 预扣库存(Lua 判断库存充足再扣减),成功后异步/同步落库;数据库唯一约束与余额校验兜底。Redis 数据可重建,库存权威源在数据库。预扣失败快速返回;落库失败需回补 Redis 库存。幂等键防重复下单。
原理流程
- 活动开始前库存同步到 Redis。
- 下单请求经 Lua 判断库存 > 0 再扣减,原子完成。
- 预扣成功后写订单与扣减数据库库存(事务)。
- 落库失败回补 Redis 库存;幂等键拦截重复请求。
- 对账任务核对 Redis 与数据库库存差异。
代码或图示
-- KEYS[1] 库存键;ARGV[1] 扣减数量
if tonumber(redis.call('get', KEYS[1])) >= tonumber(ARGV[1]) then
return redis.call('decrby', KEYS[1], ARGV[1])
else
return -1
end
常见误区
- 把 Redis 库存当最终账务:Redis 故障/重启后需重建,不能作为扣账权威。
- 落库失败不回补:Redis 库存永久少卖。
追问
- 热点商品单键压垮怎么办?答:库存分片(多键分段)或本地预检;分片扣减与回补逻辑复杂,需压测验证。
- 库存同步时机?答:活动前预热;期间以数据库对账为准修正 Redis 数值。
04.4.10.1-077 多实例部署下会话与缓存如何保持一致,本地副本与共享缓存如何分工?
一句话结论
跨实例共享的数据存 Redis,本地只放可容忍旧值的热点副本;会话等需要可撤销与一致判定的数据以 Redis 为准,本地不存权威会话状态。
概念解释
多实例各自本地缓存互不可见,更新一个实例的本地副本不会自动同步其他实例。分工:Redis 承载共享副本与会话权威记录;本地缓存加速只读热点。会话、权限、余额等判定数据不依赖本地副本。本地副本变更通过广播失效。实例扩缩容时本地缓存随新实例预热重建。
原理流程
- 明确数据是否跨实例共享:共享数据只入 Redis。
- 本地缓存仅存只读热点,短 TTL + 广播失效。
- 会话读写以 Redis 为准,本地不做权威副本。
- 变更事件广播到所有实例清除本地副本。
- 新实例按预热流程重建本地缓存。
代码或图示
权威/共享:Redis(会话、权限、库存、跨实例数据)
本地副本:只读热点详情、字典;失效靠广播 + TTL
常见误区
- 本地缓存存登录态:其他实例读不到,鉴权判定不一致。
- 多实例各自维护本地配置不广播:配置修改后各实例旧值长期并存。
追问
- 广播丢失怎么办?答:本地短 TTL 兜底;关键判定数据不走本地。
- 实例间需要直接通信吗?答:不直连,经 Redis Pub/Sub 或 MQ 中转事件。
04.4.10.1-078 运行期如何动态调整缓存 TTL 与容量,配置变更如何生效?
一句话结论
缓存参数从配置中心读取,构造缓存时应用;运行期调整容量/策略可重建缓存实例或通过配置接口更新,TTL 按条目写入时读取当前配置,避免硬编码常量。
概念解释
开发期定初始参数,线上按命中率与内存回调。实现上:缓存配置(容量、TTL、权重)集中在配置结构;缓存实例可按配置重建(新实例承接新写入,旧条目自然淘汰)。TTL 变更对已写入条目通常不追溯,新条目用新 TTL。动态调整要观察内存与命中率变化,防止激进调整引发回源尖刺。
原理流程
- 配置定义容量、TTL 区间、权重上限。
- 启动按配置构造缓存实例。
- 配置中心推送更新,评估后重建实例或更新读取项。
- 新写入条目使用新参数,旧条目按旧参数到期。
- 监控调整后的命中率与内存曲线。
代码或图示
配置:max_entries / ttl_secs / max_weight
变更 → 重建 Cache 实例(双实例过渡)或更新写入参数
旧条目:按原 TTL 淘汰
常见误区
- 参数散落硬编码:调优要改代码发版。
- 运行期直接改全局可变配置不加同步:并发读写数据竞争。
追问
- 重建缓存实例会不会击穿?答:新实例为空,需预热或允许懒加载;错峰重建,避免多实例同时清空。
- 配置变更需要审批吗?答:影响一致性与容量的参数变更走评审,记录变更原因与观察结果。
04.4.10.1-079 如何排查 Redis 连接泄漏与连接数持续增长?
一句话结论
连接泄漏表现为连接数只增不减、池等待超时;排查方向是连接借用后未归还、长任务持有连接、池配置过小导致反复新建,以及未关闭的订阅/管道句柄。
概念解释
正常连接池复用连接,空闲连接保持在池内。泄漏场景:借用连接后异常路径未归还;把连接存入全局结构长期持有;订阅连接与命令连接混用未释放;池大小配置不当使新建连接堆积。排查看客户端池指标(空闲/借用/新建)与服务端连接数趋势,对照代码连接生命周期。
原理流程
- 监控服务端连接数与客户端池空闲/借用计数。
- 检查连接获取与归还路径是否对称(含错误分支)。
- 排查全局缓存的连接句柄与未关闭订阅。
- 核对池大小、等待超时与连接生命周期配置。
- 修复后观察连接数回落与等待指标。
代码或图示
排查清单:
借用后错误分支是否归还
连接是否被长期持有
订阅/管道句柄是否释放
池 max_size 与回收配置
常见误区
- 连接数高就调大池:可能掩盖泄漏,连接堆积到服务端上限。
- 每次命令新建连接:无池化复用,连接数随请求增长。
追问
- 连接池句柄能克隆共享吗?答:池句柄可克隆分发,裸连接按池规则借用归还;具体共享语义以 redis-rs 与池库文档为准。
- 泄漏怎么复现?答:压测并发请求后观察空闲连接是否回收;异常路径单测覆盖归还逻辑。
04.4.10.1-080 在异步任务中使用缓存有哪些阻塞与运行时陷阱?
一句话结论
async 任务内必须用异步连接与异步命令,不能调同步阻塞 API;避免在缓存回调里做重计算或阻塞 IO,连接句柄按运行时要求跨任务传递。
概念解释
Web 服务运行在 Tokio 等异步运行时,同步阻塞调用会占住 worker 线程。缓存链路陷阱:误用同步连接方法;get_with 回调内做阻塞查询;批量命令未 await 导致任务泄漏;连接跨任务移动违反类型约束。异步缓存库(moka async 类型)与异步 Redis 客户端配套使用。
原理流程
- 确认运行时类型,引入对应 async feature。
- 所有 Redis 调用走异步连接与
await。 - 缓存加载回调内只编排异步取数,阻塞操作移到阻塞线程池。
- 连接/池句柄按
Clone或借用规则传入任务。 - 监控任务阻塞与超时,定位同步调用点。
代码或图示
// 正确:异步连接 + await
let v: Option<String> = conn.get("k").await?;
// 禁止:在 async 任务里调用同步阻塞连接方法
常见误区
- 回调里执行同步数据库查询:阻塞 worker,并发吞吐骤降。
- 忘记 await 命令:连接状态错乱,命令未真正发送。
追问
- 重计算放哪里?答:阻塞线程池(如
spawn_blocking),异步任务只编排;与 04.4.7.1 运行时章节衔接。 - 异步缓存与同步缓存怎么选?答:async 上下文用异步缓存类型;需要在非运行时环境使用才选同步类型。
04.4.10.1-081 Redis 键值的二进制安全与编码有什么注意点?
一句话结论
Redis 字符串是二进制安全的,可存任意字节;键名建议 UTF-8 可读,中文与特殊字符需统一编码规范,避免不可见字符导致排查困难。
概念解释
RESP 字符串长度前缀编码,内容不做解释,二进制安全。实践中键名用 ASCII 规范段;值可存 UTF-8 文本、序列化二进制。中文键名虽可行,但命令行调试、监控统计与跨工具兼容性差,推荐用内部 ID 作键,中文放值内。值编码格式在序列化层声明(JSON/二进制)。
原理流程
- 键名按 ASCII 规则分段,避免空格与特殊符号。
- 值按选定格式序列化,编码随版本前缀标注。
- 非 ASCII 内容放入值,不拼进键。
- 调试工具按二进制安全读取,避免乱码误判。
- 监控按键前缀统计时保证编码一致。
代码或图示
推荐:v1:item:1001 → 值: {"name":"中文"}
避免:键名直接含中文与空格;值编码格式不明
常见误区
- 键里拼接用户输入原文:特殊字符破坏命名规则,也注入不可见字符。
- 假设所有工具按 UTF-8 显示值:二进制格式需按编码解析。
追问
- 二进制值怎么查看?答:客户端按格式解码;监控展示避免打印敏感二进制内容。
- 编码不一致会导致什么?答:反序列化类型错误,缓存键带版本前缀隔离。
04.4.10.1-082 redis-rs 中 pipeline 与 transaction 的 API 形态如何落地?
一句话结论
pipeline 用 Pipeline 收集命令后一次查询;transaction 用事务辅助函数或 MULTI/EXEC 命令序列,两者返回批量回复,按命令顺序解析到目标类型。
概念解释
redis-rs 提供便捷命令方法与底层 cmd 拼装。Pipeline 链式追加命令,query_async 批量执行;事务辅助函数接收键集合与闭包,闭包内写命令,库包裹 MULTI/EXEC。批量回复是 Value 数组,需按序转换。API 细节(方法名、返回类型)以 docs.rs 当前版本为准。
原理流程
- 创建
Pipeline,追加 set/get 等命令。 - 调用批量查询方法发送整批,取回回复列表。
- 事务场景用辅助函数:声明关注键,闭包内读改写。
- 解析回复:按命令顺序类型转换。
- 错误按类别处理,区分网络与命令错误。
代码或图示
use redis::Pipeline;
let mut pipe = Pipeline::new();
pipe.set("a", "1").get("a");
let replies: Vec<redis::Value> = pipe.query_async(&mut conn).await?;
常见误区
- 批量回复不按顺序解析:命令与值错位。
- 事务闭包内做重 IO:事务持有连接期间拉长锁定窗口。
追问
- pipeline 能读取前序命令结果吗?答:不能同步读取,整批回复后统一解析;依赖前序结果需拆分批次。
- 事务闭包返回错误会怎样?答:中止事务,已入队命令不执行;具体语义以库文档为准。
04.4.10.1-083 为什么遍历键要用 SCAN 而不是 KEYS,分批扫描如何实现?
一句话结论
KEYS 阻塞遍历全量键,生产禁用;SCAN 系列游标分批迭代,每次返回少量键,配合 HSCAN/SSCAN 遍历集合元素,限速执行。
概念解释
Redis 单线程处理命令,KEYS * 遍历所有键期间其他命令排队。SCAN 用游标分批返回,单次成本可控,允许中途停止。遍历大 key 集合时同样用对应 HSCAN/SSCAN/ZSCAN。批量清理、预热对账等后台任务必须用 SCAN;游标返回 0 表示一轮结束。
原理流程
- 初始化游标为 0。
- 调用 SCAN 带 count 提示,返回新游标与本批键。
- 处理本批键(清理/统计/迁移)。
- 游标未到 0 继续下一批,批次间限速。
- 大集合用对应 HSCAN/SSCAN 遍历元素。
代码或图示
SCAN cursor COUNT 100
HSCAN hash cursor COUNT 50
SSCAN set cursor COUNT 50
常见误区
- 后台任务用 KEYS 全量扫:阻塞线上实例。
- SCAN count 设过大:失去分批意义,单次返回仍很重。
追问
- SCAN 保证遍历完整吗?答:遍历期间键增删可能重复或遗漏,适合统计/清理类非精确场景;精确集合用业务索引。
- 清理大批键怎么做?答:SCAN 收集后分批 UNLINK,限速避免阻塞。
04.4.10.1-084 缓存标签(tag)如何支持批量失效,与单键删除相比有什么取舍?
一句话结论
标签把多个缓存键关联到同一标签,变更时按标签批量失效;实现需额外维护标签到键的映射,代价是内存与写入开销,适合按类目/对象组批量更新的场景。
概念解释
单键失效粒度细,但一次业务变更影响多个缓存键时需要逐一删除。标签方案:维护「标签 → 键集合」与「键 → 标签」映射,变更时按标签找出键批量删除。映射本身存 Redis/本地,需处理集合膨胀与一致性。简单场景按前缀扫描删除即可,不必引入标签体系。
原理流程
- 写入缓存时登记标签映射。
- 业务变更确定失效标签。
- 按标签取键集合,批量删除缓存键与映射。
- 映射过期清理,避免无限增长。
- 标签失效失败进入补偿重试。
代码或图示
tag:order:1001 → {cache:order:1001, cache:order:items:1001}
变更订单 → 删标签下全部键 → 清理标签映射
常见误区
- 标签集合无限增长:需 TTL 与定期清理。
- 映射更新与缓存写入不同步:标签指向已失效或不存在的键。
追问
- 前缀扫描能替代标签吗?答:可按业务前缀 SCAN 删除,但遍历成本高;标签适合高频批量失效场景。
- 标签映射存本地还是 Redis?答:跨实例失效存 Redis;本地标签只服务本实例广播补偿。
04.4.10.1-085 在 Rust 本地实现 single flight 的基本思路是什么?
一句话结论
single flight 用「加载中状态表 + 通知机制」合并同键并发加载:第一个请求执行回调,后续同键等待同一结果;moka get_with 已内置,自建时需处理并发等待与失败传播。
概念解释
自建思路:维护键到加载状态的映射(持有 oneshot/通知句柄)。请求发现键加载中就订阅结果;无加载中记录则插入状态并执行回调,完成后写入结果、唤醒等待方。要处理:回调失败传播给等待方、状态清理、并发插入竞态。生产优先用缓存库内置能力,不自造复杂并发原语。
原理流程
- 检查键是否在加载中表。
- 在表中:等待通知句柄,取共享结果。
- 不在表中:插入加载状态,执行加载回调。
- 成功/失败后写入结果,唤醒所有等待方并清理状态。
- 竞态下用并发原语保证只有一个执行者。
代码或图示
key → Loading { waiter: Vec<oneshot::Sender<Result>> }
首个:执行回调 → 结果写入 → 通知 waiters
后续:注册 waiter → 等同一结果
常见误区
- 回调失败不通知等待方:等待任务永久挂起。
- 状态不清理:表内残留加载中条目,后续请求一直等待。
追问
- Rust 用什么原语?答:
tokio::sync的 oneshot/Mutex/Condvar 类组合;具体选型按运行时,与 04.4.2 并发章节衔接。 - 为什么优先用库内置?答:并发边界、取消与超时处理复杂,成熟库已覆盖边角情况。
04.4.10.1-086 moka 异步缓存的构建与回调有哪些约束,阻塞回调会带来什么问题?
一句话结论
异步缓存的加载回调应是异步非阻塞;构造缓存按异步 API 完成,回调内重计算或阻塞 IO 会卡住缓存内部调度,影响其他条目加载。
概念解释
moka 区分同步与异步缓存类型。异步场景下 get_with 回调返回异步结果,库在运行时内调度。约束:回调不能阻塞当前任务;外部取数走异步客户端;长任务拆到阻塞线程池。回调 panic 或长时间不返回会污染加载状态,需错误处理与超时控制。
原理流程
- 按运行时选择异步缓存类型构造实例。
- 未命中时回调执行异步取数。
- 阻塞性工作移到专用线程池,回调只 await 结果。
- 回调超时返回错误,不写入缓存。
- 监控加载耗时与失败率。
代码或图示
// 伪代码:异步 get_with 回调返回 Future
// cache.get_with_async(&key, async { repo.find(id).await }).await
常见误区
- 回调里同步查数据库:阻塞异步 worker。
- 回调无超时:下游慢响应拖挂同键等待方。
追问
- 同步缓存能在 async 任务里用吗?答:若其操作不阻塞短任务可用,但优先匹配异步类型;混用前核对文档约束。
- 缓存构造需要 await 吗?答:按类型而定,异步构造方法可能返回 Future;以 docs.rs/moka 当前版本为准。
04.4.10.1-087 缓存命中率偏低时按什么路径排查?
一句话结论
排查顺序:确认统计口径 → 区分本地/Redis/回源各层命中 → 检查 TTL 与失效策略 → 审查键设计与数据热度 → 评估缓存对象粒度与回填时机。
概念解释
低命中率可能是配置问题、数据本身冷门、键不一致或回填缺失。先分清哪一层 miss:本地低命中可能本地 TTL 过短或对象过大;Redis 低命中检查 TTL、淘汰与回填逻辑。再看访问分布:热点是否被缓存、未命中是否回源数据库。最后检查代码路径:是否所有读路径都走了缓存。
原理流程
- 核对命中率统计口径(键组、时间窗口)。
- 分层看本地/Redis/数据库回源率。
- 检查 TTL 是否过短、失效是否过于频繁。
- 审查键构造一致性:读路径键规则是否统一。
- 评估对象粒度与回填时机,必要时调整缓存策略。
代码或图示
口径 → 分层命中率 → TTL/失效 → 键一致性 → 数据热度 → 粒度/回填
常见误区
- 命中率低就加大容量:可能是回填逻辑未覆盖,容量无济于事。
- 用全库随机数据评估命中率:分布与线上不符。
追问
- 写后立即读 miss 正常吗?答:旁路模式写后删缓存,下次读回填,首读 miss 属预期;连续 miss 才异常。
- 哪些数据不该追求高命中?答:一次性访问、强一致易变数据,缓存价值低。
04.4.10.1-088 热 key 本地副本为什么要短有效期,过期与广播如何配合?
一句话结论
本地副本短 TTL 限制旧值窗口,变更时广播主动剔除;短 TTL 兜底广播丢失,广播保证及时失效,两者互补,避免本地副本长期陈旧。
概念解释
热 key 放本地是为省 Redis 访问,但本地副本更新滞后。有效期过长:变更后各实例旧值不一致;过短:本地层失去减负意义。配合方式:变更事件广播删本地,TTL 作为消息丢失兜底。热数据逻辑过期可异步刷新。副本失效粒度按对象键,列表类按标签/前缀。
原理流程
- 本地副本写入时设短 TTL。
- 数据变更发布广播事件,各实例删本地键。
- 广播未达时 TTL 到期自然清理。
- 热点条目可后台异步刷新保持新鲜。
- 监控本地命中率与旧值投诉。
代码或图示
本地副本:TTL 短 + 广播主动失效
广播丢失 → TTL 兜底;广播及时 → 缩短旧值窗口
常见误区
- 本地副本与 Redis 同 TTL:两层旧值叠加,一致性窗口过长。
- 只靠广播不设 TTL:消息丢失后本地旧值永久驻留。
追问
- 热 key 本地副本会不会放大内存?答:热点数量可控时占用有限;条目多需权重限制,见容量治理题。
- 广播事件顺序重要吗?答:变更先后顺序影响旧值覆盖,事件带版本号比对,旧事件不删新值。
04.4.10.1-089 大 key 删除为什么用 UNLINK,DEL 阻塞体现在哪?
一句话结论
DEL 同步释放大键内存,阻塞 Redis 单线程;UNLINK 把回收放到后台异步执行,命令立即返回,大键清理应优先 UNLINK。
概念解释
删除大集合时,释放内存涉及遍历与回收,耗时随元素数量增长。DEL 在命令执行内同步完成,期间其他命令排队。UNLINK 标记键并交给后台线程回收,主进程不阻塞。运维清理、迁移旧键都应评估用 UNLINK;小键 DEL 与 UNLINK 差异可忽略。
原理流程
- 识别待删大键(元素数/体积)。
- 大键使用
UNLINK异步回收。 - 后台线程完成内存释放。
- 监控回收期间内存与命令延迟。
- 小键直接 DEL 即可。
代码或图示
DEL big_set # 同步遍历回收,阻塞单线程
UNLINK big_set # 后台异步回收,命令立即返回
常见误区
- 批量脚本对所有键用 DEL:大键删除阻塞线上。
- 以为 UNLINK 不占内存:回收延迟期内存仍占用,观察后台释放进度。
追问
- UNLINK 后台回收受什么限制?答:服务端后台线程与内存策略;具体行为以 Redis 版本文档为准。
- 误删大键如何恢复?答:缓存可重建,数据库为准;不可丢数据不依赖 Redis 删除恢复。
04.4.10.1-090 集群下多键操作的 hash tag 如何规划命名?
一句话结论
需要同节点的相关键用统一 {tag} 包裹公共标识(如 order:{1001}:items),使槽位一致;无多键操作的键不必加 tag,避免热点集中同槽。
概念解释
hash tag 取 {} 内文本计算槽位。规划原则:属于同一聚合根、需要事务/Lua/多键命令的键共用 tag;独立单键操作不加 tag,分散槽位防热点。tag 内用稳定标识(主键),不含可变排序段。命名与键规则统一在构造函数中生成,避免手写不一致。
原理流程
- 梳理需要多键原子操作的键组。
- 组内键使用相同
{聚合根标识}tag。 - 独立键不加 tag,按键名自然分散。
- 键构造函数统一生成 tag 段。
- 上线前用槽位计算验证同组键落同槽。
代码或图示
order:{1001}:meta
order:{1001}:items # 同 tag → 同槽,可多键操作
user:2002 # 独立键,自然分片
常见误区
- 所有键加同一 tag:全部落单槽,集群失去分片意义。
- tag 内放可变字段:槽位随变更漂移,键组分裂。
追问
- 跨槽操作报错怎么排查?答:检查相关键 tag 是否一致;客户端重定向错误指向槽位问题。
- tag 影响键可读性吗?答:
{}是命名规范一部分,文档说明 tag 规则便于排查。
04.4.10.1-091 订阅/广播消息丢失有哪些补偿手段,失效事件如何保证最终收敛?
一句话结论
Pub/Sub 不持久化,丢失靠本地/Redis TTL 兜底;要求可靠投递时改用外部 MQ 消费确认,失效事件带版本与键,对账定期扫描修正陈旧副本。
概念解释
失效广播链路:写库 → 删 Redis → 发广播。Pub/Sub 离线订阅者收不到消息,本地副本可能残留旧值。补偿分层:本地短 TTL 兜底;Redis 键 TTL 兜底;定期对账扫描比对版本;关键数据可重试发布。可靠场景把失效事件投递到 MQ,消费者确认后删本地。
原理流程
- 失效事件携带键、类型、版本号。
- 订阅者收到后按版本比对再删本地。
- Pub/Sub 丢失由 TTL 自然收敛。
- 周期对账:比对缓存值与库数据版本,修正陈旧项。
- 高可靠链路用 MQ 持久化事件 + 消费确认。
代码或图示
补偿链:广播主动失效 → 本地 TTL → Redis TTL → 周期对账
事件字段:key / type / version / emitted_at
常见误区
- 假设广播必达:Pub/Sub 无持久化与确认。
- 旧事件后到误删新值:必须带版本号比对。
追问
- 对账扫描成本高怎么办?答:按变更频率抽样,关键对象优先;增量版本比对优于全量扫描。
- MQ 失效事件重复消费安全吗?答:删除操作幂等,重复消费无副作用;回填操作需版本保护。
04.4.10.1-092 多环境缓存如何隔离,键命名空间包含哪些隔离段?
一句话结论
不同环境(开发/测试/生产)与不同业务域通过键前缀隔离,避免共享实例串数据;环境段、业务段、类型段、标识段分层,配置中统一维护。
概念解释
Redis 实例常被多环境或多业务复用,无隔离会互相覆盖。键规则包含环境前缀(或使用独立实例/库号)、业务域、数据类型、主键。测试数据不能污染生产缓存。隔离段在键构造函数集中生成,禁止业务代码拼裸键。本地缓存同样按环境区分进程部署。
原理流程
- 配置定义环境标识与业务前缀。
- 键构造函数拼接环境/业务/类型/标识段。
- 共享实例分配独立逻辑库号或前缀段。
- 测试环境清理策略独立于生产。
- 监控按键前缀区分环境与业务指标。
代码或图示
env:domain:type:id
prod:order:item:1001
test:order:item:1001
常见误区
- 共用实例不带环境前缀:本地调试写入覆盖生产键。
- 环境标识硬编码在各处:部署到新环境漏改。
追问
- 环境隔离用前缀还是独立实例?答:生产优先独立实例;开发/测试可用前缀共享,按安全与成本权衡。
- 库号(DB index)能替代前缀吗?答:可作为隔离层,但多业务仍建议前缀;库号切换要在客户端配置明确。
04.4.10.1-093 缓存层如何写单元测试,如何 mock Redis 依赖?
一句话结论
缓存逻辑通过 trait 抽象,测试注入内存替身或 mock 客户端;断言命中回填、失效调用与空值短路,不依赖真实 Redis 实例跑单元测试。
概念解释
测试分层:仓储 trait 定义 get/put/invalidate;生产实现接 Redis,测试实现用 HashMap 替身。测试用例覆盖:未命中回填、命中返回、失效删除、空值缓存、并发加载合并。集成测试再用真实/容器化 Redis 验证命令与序列化。mock 按 trait 接口打桩,不模拟 redis-rs 内部类型。
原理流程
- 定义缓存 trait 与业务服务依赖。
- 测试构造内存替身实现。
- 用例编排:写入 → 读取 → 失效 → 断言状态。
- 验证回填与失效调用次数与键规则。
- 集成测试连接测试 Redis 覆盖命令兼容性。
代码或图示
trait CacheStore {
async fn get(&self, k: &str) -> Option<String>;
async fn put(&self, k: &str, v: &str, ttl: u64);
async fn del(&self, k: &str);
}
// 测试替身:HashMap 实现;断言 get/put/del 调用
常见误区
- 单元测试连真实 Redis:测试慢且受环境影响。
- mock 具体客户端类型:绑定实现细节,重构脆弱。
追问
- 序列化逻辑怎么测?答:单独测 DTO 与缓存值编解码往返,覆盖边界值与版本格式。
- 并发加载测试怎么做?答:并发触发同键加载,断言回调只执行一次、结果一致。
04.4.10.1-094 缓存读写失败时兜底策略如何设计,错误如何分层处理?
一句话结论
读失败降级直连库或返回旧值/默认值,写失败补偿重试;区分临时故障与配置错误,缓存故障不阻断核心业务,错误指标与日志独立记录。
概念解释
缓存是旁路优化,故障时业务应可降级。读路径:Redis 超时/错误 → 限流直连库或返回本地/旧值;写路径:删缓存失败入重试队列,不阻塞主写。错误分类:连接/超时可重试,参数/配置错误告警不重试。兜底返回要标注降级,避免客户端误把旧值当最新数据。
原理流程
- 读缓存捕获错误,按类别决定重试或降级。
- 降级路径限流保护数据库,返回旧值/默认值。
- 写缓存失败入补偿队列,有限次重试。
- 错误按类别上报指标,日志保留上下文。
- 故障恢复后观察命中率与回源回落。
代码或图示
读:cache error → 重试(有限) → 直连库(限流) / 旧值 / 默认
写:delete fail → 补偿队列 → 重试 / 告警
常见误区
- 缓存失败直接向上抛错:旁路缓存故障拖垮主业务。
- 降级返回空值不标注:前端展示错误空白。
追问
- 直连库限流阈值怎么定?答:按数据库可承受回源比例设置,核心接口优先放行。
- 补偿队列放哪?答:应用内重试或外部 MQ;失败上限后告警人工介入。
04.4.10.1-095 什么场景用分布式 Redis 缓存,什么场景用本地缓存,如何组合?
一句话结论
跨实例共享、可重建的大对象用 Redis;高频小体积只读热点用本地缓存;组合架构按数据热度分层,强一致与权威数据不放入本地层。
概念解释
选型维度:共享性(是否跨实例一致)、体积、访问频率、一致性要求、可重建性。Redis:跨实例副本、对象较大、需集中治理。本地:延迟敏感、热点小对象、容忍短暂旧值。组合:本地一级、Redis 二级、数据库三级。不适合缓存的数据(强敏感、一次性访问)直接查库。
原理流程
- 评估数据共享性:必须跨实例一致 → Redis。
- 评估体积与频率:小体积高频 → 可加本地层。
- 评估一致性:强敏感 → 直查库或短缓存。
- 设计分层链路与失效策略。
- 压测验证各层命中率与回源边界。
代码或图示
Redis:共享副本、大对象、集中 TTL/淘汰治理
本地: 小体积热点、最低延迟、短 TTL + 广播
排除: 强一致权威数据、一次性访问、超大对象
常见误区
- 所有数据都塞本地:内存失控且一致性差。
- 本地缓存承担共享一致性:多实例副本无法保证。
追问
- 两者容量如何分配?答:本地按进程内存预算小容量,Redis 按实例内存与条目规模规划。
- 新系统先建哪层?答:先 Redis 旁路缓存跑通共享副本,热点明确后再加本地层。
04.4.10.1-096 穿透、击穿、雪崩三个概念如何区分,防护手段各对应什么?
一句话结论
穿透查不存在的数据绕过缓存打库;击穿是单热点键过期并发回源;雪崩是大面积键同时失效或缓存整体故障;防护分别是空值/布隆、互斥重建/单飞、TTL 抖动/分批预热/限流降级。
概念解释
三者都表现为回源升高,成因不同。穿透:数据不存在,缓存永远 miss,靠布隆过滤器与空值缓存拦截。击穿:热点存在,过期瞬间并发重建,靠 single flight/互斥锁/逻辑过期。雪崩:批量同时到期或 Redis 故障,靠 TTL 抖动、分批预热、多级缓存与限流降级。混淆概念会导致防护手段错位。
原理流程
- 判断回源请求对应数据是否存在:存在→击穿/雪崩;不存在→穿透。
- 单热点并发→击穿;大面积失效/整体故障→雪崩。
- 按类型套用防护:布隆/空值;单飞/锁;抖动/预热/降级。
- 监控三类征兆:无效查询量、单键并发回源、大面积 miss。
- 复盘防护缺口并补策略。
代码或图示
穿透:查无此数据 → 布隆过滤器 + 空值缓存
击穿:热点过期并发 → single flight / 重建锁 / 逻辑过期
雪崩:批量失效/故障 → TTL 抖动 + 预热 + 多级缓存 + 限流降级
常见误区
- 用击穿手段防穿透:数据不存在,重建锁挡不住无效查询。
- 只防单键过期:忽略整体故障降级,雪崩时数据库被打垮。
追问
- 三者监控指标有何不同?答:穿透看无效查询占比;击穿看单键并发等待;雪崩看整体 miss 率与回源 QPS。
- 恶意穿透如何应对?答:布隆 + 空值短 TTL + 频率限制;可疑请求接入安全防护。
04.4.10.1-097 缓存键过期与内存治理复盘:常见失控模式有哪些?
一句话结论
失控模式包括:无 TTL 永久驻留、TTL 整齐形成过期潮、大 key 占内存、淘汰策略不当、标签映射膨胀;治理靠 TTL 分级、抖动、大 key 拆分、容量监控与定期扫描清理。
概念解释
内存治理是持续工作。复盘维度:条目是否都有 TTL;TTL 是否分组抖动;大 key 是否拆分;淘汰策略是否匹配数据可重建性;辅助映射(标签、索引)是否清理。线上内存上涨时按大 key、长尾条目、映射膨胀排查,结合 INFO 与 SCAN 抽样定位。
原理流程
- 检查所有写入路径是否设置 TTL。
- 审查 TTL 分布,识别整齐到期与超长 TTL。
- 抽样大 key 与大集合,评估拆分。
- 核对淘汰策略与数据可重建性。
- 定期扫描清理过期辅助映射,监控内存水位。
代码或图示
失控清单:无 TTL / TTL 同批 / 大 key / 误淘汰策略 / 映射膨胀
治理:分级 TTL + 抖动 + 拆分 + 容量上限 + 定期扫描
常见误区
- 只看总内存不看条目分布:大 key 与长尾条目被平均值掩盖。
- 辅助映射不设过期:标签/索引集合无限增长。
追问
- 内存碎片怎么判断?答:INFO 碎片率与内存分配比值;碎片过高结合淘汰与重启治理,具体以服务端文档为准。
- 长尾条目如何识别?答:SCAN 抽样 TTL 与体积,结合访问频率统计找冷门大键。
04.4.10.1-098 Rust 项目中缓存方案如何分层落地,代码结构怎么组织?
一句话结论
分层为:业务服务编排缓存读写 → 缓存 trait 抽象 → Redis/本地实现 → 序列化与键规则组件;配置、指标、降级策略集中在实现层,业务代码不接触具体客户端类型。
概念解释
工程结构对应职责:服务层决定何时回源与回填;缓存 trait 定义存取与失效;实现层封装连接池、序列化、TTL、错误分类;键构造与序列化格式独立成组件。测试用替身实现 trait。配置按环境注入,指标统一埋点。这样更换缓存实现或加本地层不影响业务逻辑。
原理流程
- 定义缓存 trait(get/put/invalidate/批量)。
- 实现 Redis 后端:池、命令、序列化、键规则。
- 实现本地后端:moka 实例、权重/TTL、广播订阅。
- 服务层编排 miss → 回源 → 回填。
- 配置与指标横切注入,测试替身覆盖。
代码或图示
service (编排) → Cache trait → Redis 实现 / 本地实现
components: key_builder / serializer / metrics / fallback
常见误区
- handler 直接持有 Redis 连接:规则与重试散落各处。
- 缓存实现与数据库仓储混在一层:一致性策略与回源职责不清。
追问
- 多级缓存在 trait 内还是服务层编排?答:常见做法是组合缓存实现内部委托本地→Redis,或服务层显式编排;两种都行,职责边界要一致。
- 新增加一层缓存改哪里?答:扩展 trait 组合实现,服务层编排不变。
04.4.10.1-099 复盘 Rust 接入 Redis 的常见踩坑清单有哪些?
一句话结论
高频踩坑:async 误用同步连接、未池化复用、键规则混乱、无 TTL、大 key 阻塞、事务当回滚、分布式锁误释放、序列化格式不隔离、错误不分类重试。
概念解释
按链路复盘:连接(同步/异步混用、池化缺失);命令(参数顺序、大返回、阻塞命令);数据(TTL、大 key、序列化版本);一致性(删缓存顺序、广播丢失);并发(锁释放、N+1);错误(无限重试、信息泄漏)。每条坑对应前述专题的防护做法,上线前按清单自查。
原理流程
- 连接层:核对运行时 feature、连接池配置与归还路径。
- 命令层:审查参数顺序、返回体积、阻塞命令。
- 数据层:TTL、键规则、版本前缀、大 key。
- 一致性:失效顺序、广播兜底、补偿重试。
- 错误层:分类重试、脱敏、指标告警。
代码或图示
踩坑清单:
同步连接进 async 任务 / 未池化
KEYS 全扫 / 大 DEL 阻塞
事务当回滚 / 锁误删
无 TTL / 序列化无版本
错误无限重试 / 泄漏内部细节
常见误区
- 同类坑在新代码重复出现:清单未进评审与 CI 检查项。
- 踩坑只记现象不补机制:下次换个场景再犯。
追问
- 清单如何落地到流程?答:接口评审对照清单,代码扫描检查裸命令与无 TTL 写入,压测覆盖故障场景。
- 哪些必须在原型验证?答:集群路由、订阅传输、池化行为等版本敏感点,以 docs.rs 当前版本为准并标注待确认。
04.4.10.1-100 把 Redis 与本地缓存串成完整工程方案,包含哪些设计门禁?
一句话结论
完整链路:数据分级选型 → 多级缓存链路 → 键/序列化/TTL 规范 → 击穿穿透雪崩防护 → 失效一致性与广播兜底 → 监控压测与降级;每项在设计评审与 CI 中可检查,不依赖口头约定。
概念解释
本章从 redis-rs 连接、池化、命令与数据结构,到锁、Stream、缓存模式、一致性,再到 moka 本地缓存与多级治理。工程闭环:先按数据等级决定是否缓存与放哪层;再定键规则、序列化版本与 TTL;防护三类缓存问题;写路径保证失效与补偿;监控命中率、内存、连接与慢命令;压测覆盖故障降级。Rust 侧业务服务保持缓存抽象,实现可替换。
原理流程
- 分级:强敏感直查,可重建热点进缓存。
- 选型:本地一级、Redis 二级、数据库三级。
- 规范:键命名空间、版本前缀、序列化格式、TTL 分级。
- 防护:空值/布隆、single flight、TTL 抖动、预热降级。
- 运维:一致性广播兜底、指标监控、压测复盘、故障预案。
代码或图示
分级选型 → 多级链路 → 规范(键/格式/TTL) → 防护(穿透/击穿/雪崩)
→ 失效一致性 → 监控压测 → 降级预案 → 复盘改进
常见误区
- 只接入缓存不做治理:命中率、内存与一致性问题滞后爆发。
- 业务代码绑定具体客户端类型:后续加本地层或换实现成本高。
追问
- 本章与后续章节如何衔接?答:消息队列可靠性与 Stream 替代方案见 04.4.10.2;后台异步刷新与定时任务见 04.4.10.3;指标上报见 04.4.12.1。
- 哪些行为需标注待确认?答:redis-rs/moka 当前版本 API、feature 清单与池化配置,以 docs.rs 核实后固化,不凭记忆写死版本行为。