罗罗编程学习记录
本页内容 展开查看

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 线程;连接句柄按需克隆或经连接池分发。

原理流程

  1. Cargo.toml 引入 redis,按运行时开启对应 feature。
  2. Client::open(url) 解析连接配置。
  3. 同步链路:get_connection() 拿到阻塞连接。
  4. 异步链路:get_async_connection().await 拿到异步连接,或包一层连接管理器。
  5. 命令通过连接上的方法或 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),每个任务借取独立连接。

原理流程

  1. 确认项目运行时:Tokio 任务开启 tokio-comp。
  2. 引入 connection-manager feature。
  3. 建立异步连接后构造 ConnectionManager。
  4. 句柄可克隆传入不同任务,断线由管理器后台重连。
  5. 连接数需求高时改用连接池,按借用隔离连接。

代码或图示

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 的不同类别。

原理流程

  1. 从配置读取主机、端口、密码、库号,组装 URL。
  2. Client::open 解析 URL 并校验格式。
  3. 建立连接,认证与选库在握手阶段完成。
  4. TLS 场景使用 rediss:// 或显式 TLS 配置。
  5. 连接错误按类别处理:网络、认证、协议错误分别告警。

代码或图示

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 客户端。借用时池内有空闲连接直接返回,无空闲则等待;等待超时返回错误。连接失效在借用或归还时回收,坏连接被剔除重建。

原理流程

  1. 构造 Manager(持有 Redis 客户端与配置)。
  2. 按 max_size 建立池,启动时可预热部分连接。
  3. 任务调用 pool.get().await 借用连接。
  4. 用完归还池内;连接报错则标记废弃并重建。
  5. 池满时新请求按等待超时排队,不无限扩张。

代码或图示

[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 成熟度与项目已有池化依赖。

原理流程

  1. 列出项目现有异步池化使用情况(是否已引入 deadpool/bb8)。
  2. 核对两个 Redis 适配包的当前版本与维护状态。
  3. 压测借用等待时间、连接复用率与坏连接回收表现。
  4. 选定后把池句柄注入应用状态。
  5. 仓储层只依赖借用接口,便于后续替换。

代码或图示

deadpool-redis:deadpool 框架,builder 配置 max_size/超时
bb8-redis:bb8 框架,ConnectionManager 适配按需创建与回收

常见误区

  • 同一项目混用两套连接池:连接数预算与监控口径混乱。
  • 凭旧资料断定某池「性能差」:版本迭代后表现需实测核对。

追问

  • 池层之上需要再做封装吗?答:建议仓储接口屏蔽池细节,业务代码只取连接执行命令。
  • 连接池指标暴露什么?答:池大小、空闲数、等待数、等待超时次数,接入可观测性。

04.4.10.1-006 连接池大小、等待超时与连接生命周期配置如何确定?

一句话结论

池大小由并发量、命令平均耗时与 Redis 服务端连接上限推算;等待超时防止无限排队;空闲回收与健康检查剔除失效连接,配置需压测校准而非固定值。

概念解释

池太小:请求排队等待,延迟上升;池太大:Redis 连接数被打满,服务端拒绝新连接。估算参考:连接数 ≈ 并发请求数 × 单请求占用连接时长占比,再结合服务端上限留余量。等待超时是兜底:池耗尽时快速失败而不是挂死。空闲连接定期检查,避免拿到半开连接。

原理流程

  1. 压测得出单命令平均耗时与峰值并发。
  2. 按 Little 定律估算所需连接数,留出冗余。
  3. 对照 Redis 服务端 maxclients 与多实例共享预算。
  4. 设置等待超时、空闲回收与健康检查参数。
  5. 线上观测等待队列与连接复用率,回调参数。

代码或图示

估算:所需连接 ≈ 峰值并发 × 平均命令耗时 / 单连接可服务时长
约束:总连接 < 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 或二进制格式。

原理流程

  1. 选择命令方法或 cmd 拼装。
  2. 追加键与参数,注意参数顺序与 Redis 文档一致。
  3. 执行并把回复反序列化为目标类型。
  4. 类型不匹配时返回 RedisError,按错误类别处理。
  5. 复杂对象在应用层先做序列化再写入。

代码或图示

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 按分数范围取排行。复杂关系不要硬塞进单一类型,必要时组合多键并注意一致性。

原理流程

  1. 梳理访问模式:读整体还是读字段、是否排序、是否去重。
  2. 整体读写选 String;字段局部读写选 Hash。
  3. 顺序队列选 List;成员存在性选 Set;排序范围选 ZSet。
  4. 评估内存与命令复杂度(如 ZSet 范围操作)。
  5. 组合类型时设计键命名空间与失效策略。

代码或图示

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)与批量写入都适合管道。

原理流程

  1. 创建 Pipeline,依次追加命令与参数。
  2. 命令写入客户端缓冲,不立即等待回复。
  3. 一次提交发送整批,服务端顺序执行。
  4. 批量取回回复,按命令顺序解析。
  5. 有依赖关系的命令不能随意批量,需等待前序结果。

代码或图示

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 提供事务辅助函数把键、预检查与命令打包。

原理流程

  1. WATCH 关注冲突键(可选,做乐观锁)。
  2. MULTI 开启事务,命令入队。
  3. 提交命令序列。
  4. EXEC 连续执行整批。
  5. 出错命令不回滚前序;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。

原理流程

  1. 无依赖批量命令:选 pipeline 省 RTT。
  2. 要求命令连续不穿插、无回滚需求:选 transaction。
  3. 需要条件判断、多键原子修改:选 Lua 脚本。
  4. 评估脚本复杂度与执行时长,避免长脚本阻塞 Redis。
  5. 按场景组合: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 的脚本。

原理流程

  1. 编写 Lua:读取键值、条件判断、写入结果,返回明确值。
  2. Script::new 构造脚本对象。
  3. 绑定键与参数,invoke_async 发送执行。
  4. 服务端原子执行脚本,回复结果。
  5. 业务按返回值判断成功/冲突,处理重试。

代码或图示

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 变化,客户端缓存需更新。

原理流程

  1. 首次:脚本正文发送到服务端,缓存并得到 SHA1。
  2. 后续调用:按 SHA1 引用脚本执行。
  3. 集群:路由到未缓存节点时补发脚本。
  4. 脚本内容变更:新版本新 SHA,旧缓存自然淘汰。
  5. 监控 NOSCRIPT 类错误并补传脚本。

代码或图示

SCRIPT LOAD "<脚本>" → 返回 sha1
EVALSHA sha1 numkeys key arg ...

常见误区

  • 集群下假设所有节点已缓存脚本:首次跨节点调用可能 NOSCRIPT。
  • 修改脚本内容却复用旧 SHA:执行旧逻辑,行为与预期不符。

追问

  • 脚本缓存会被淘汰吗?答:Redis 按内存策略与脚本缓存规则管理;NOSCRIPT 时重新加载即可。
  • 如何确认当前版本脚本调用方式?答:以 docs.rs/redis Script API 与 Redis 命令文档为准。

04.4.10.1-014 发布订阅(PUBLISH/SUBSCRIBE)在 Rust 侧如何使用,有哪些可靠性边界?

一句话结论

订阅端用 SUBSCRIBE 监听频道并循环接收消息,发布端 PUBLISH 投递;发布订阅是「 fire and forget 」,离线订阅者收不到历史消息,不保证持久化与消费确认。

概念解释

Pub/Sub 适合广播通知(缓存失效事件、配置刷新),不适合可靠任务队列。订阅连接进入消息循环,断开期间发布的消息直接丢失;没有消费确认、重试与积压保留。需要持久化消费、消费组与重试时用 Stream 或外部 MQ。Rust 异步订阅用专用订阅连接,循环处理消息直到断开。

原理流程

  1. 订阅端建立连接,SUBSCRIBE 到频道。
  2. 进入消息循环,逐条接收并处理事件。
  3. 发布端向频道 PUBLISH 消息。
  4. 在线订阅者收到,离线期间消息不保留。
  5. 处理失败不重投,业务自行决定补偿。

代码或图示

// 待确认: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 内置轻量消息队列方案。可靠性仍需结合业务:消费者处理后需确认,失败消息进入待处理列表追踪。

原理流程

  1. 生产者 XADD 追加条目,指定字段与值,得到消息 ID。
  2. 消费者 XREAD 按最后读取 ID 拉取新消息。
  3. 阻塞模式下等待新条目到达。
  4. 处理完成后在消费组模式下 XACK 确认。
  5. 未确认消息通过 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 转给其他消费者。这提供了最基础的消费可靠性:消息不丢、可追踪、可重投,但死信、重试退避等仍需业务实现。

原理流程

  1. 创建消费组,指定起始 ID。
  2. 消费者 XREADGROUP 按组拉取消息,记录消费者名。
  3. 业务处理成功后 XACK 确认。
  4. 失败消息保留在 pending,超时后被 Claim 重新分发。
  5. 监控 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)。

原理流程

  1. 评估消息量级、峰值吞吐与积压容忍度。
  2. 确认可靠性要求:持久化、确认、重试、死信、顺序。
  3. 轻量场景选 Stream,复用现有 Redis 基础设施。
  4. 复杂堆积与多语义场景引入外部 MQ。
  5. 消费者接口抽象,隔离底层队列实现便于替换。

代码或图示

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)让只有一个客户端抢到键。不加过期时间,持锁进程崩溃后锁永久残留。过期时间防死锁;唯一标识保证释放时只删自己的锁。锁粒度、超时时间与业务执行时长要匹配,过短被提前释放,过长故障恢复慢。

原理流程

  1. 生成请求唯一标识(UUID 或随机串)。
  2. SET lock:<资源> <唯一值> NX PX <毫秒> 尝试抢锁。
  3. 返回成功即持有锁,执行业务。
  4. 业务完成后用脚本比对标识再删除。
  5. 抢锁失败按策略重试或快速失败。

代码或图示

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 把比对与删除合并为一次原子操作,只在标识匹配时删除。释放失败(锁已不属于自己)不应再补救删除。

原理流程

  1. 业务完成,取出持有时生成的唯一标识。
  2. 执行 Lua:读取键值,等于标识则 DEL,否则返回未匹配。
  3. 脚本原子执行,比对与删除之间无穿插。
  4. 返回值判断是否成功释放。
  5. 不匹配说明锁已易主,记录告警不做二次删除。

代码或图示

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 周期任务配合取消信号。风险:续期任务泄漏、进程挂掉后续期停止但锁仍在、续期期间网络抖动导致刷新失败。

原理流程

  1. 抢锁成功后启动续期任务,周期小于 TTL。
  2. 每次续期先比对标识,匹配才延长过期。
  3. 业务完成发送取消信号,停止续期并释放锁。
  4. 续期失败(连接错误/标识不匹配)中止业务。
  5. 设置最大持锁时长兜底,防止无限续期。

代码或图示

抢锁(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 等协调服务,或接受方案局限并加业务兜底。

原理流程

  1. 核对场景:冲突后果是否严重,能否容忍偶发重复执行。
  2. 防误释放:唯一标识 + Lua 释放。
  3. 评估重入需求:需要时设计计数锁结构。
  4. 评估主从切换丢锁风险:关键链路加幂等与业务校验兜底。
  5. 强一致要求改用成熟协调组件,不自行堆砌 Redis 命令。

代码或图示

坑点清单:
  误释放:唯一值 + Lua 比对删除
  重入:需计数模型,普通 NX 锁不可重入
  主从切换:异步复制窗口内锁可能丢失
  时钟:TTL 基于节点时间,注意漂移

常见误区

  • 把 Redis 锁当强一致互斥:未评估主从复制与故障切换窗口。
  • 临界区操作不做幂等:锁失效后重复执行造成重复下单/扣减。

追问

  • Redlock 是否解决主从丢锁?答:多节点投票算法降低概率,但仍有时钟与网络争议;是否采用需结合一致性要求,方案细节以官方文档为准。
  • 业务兜底怎么做?答:关键操作加幂等键、数据库唯一约束、状态机校验,锁失效后重复请求被业务层拦截。

04.4.10.1-022 cache-aside(旁路缓存)模式的读写流程是什么,为什么是最常用模式?

一句话结论

读路径先查缓存,未命中查库并回填缓存;写路径先更新数据库再删除缓存;它把缓存作为旁路副本,业务数据以数据库为准,实现简单且与现有存储解耦。

概念解释

cache-aside 由应用层显式管理缓存:读时缓存miss 才回源,写时更新库后使缓存失效。对比「读写都走缓存层」的模式,旁路模式缓存故障时可降级直连数据库,数据权威源清晰。写后删缓存而不是更新缓存,避免并发写导致缓存值错乱;缓存短暂不一致窗口由 TTL 兜底。

原理流程

  1. 读:查缓存,命中返回;未命中查数据库。
  2. 回填缓存(设 TTL),返回数据。
  3. 写:先在数据库完成更新。
  4. 删除对应缓存键。
  5. 下次读触发回填;缓存故障时降级直连库。

代码或图示

读:cache → miss → DB → 回填 cache
写:DB 更新 → 删除 cache(不是更新 cache 值)

常见误区

  • 写后更新缓存而不是删除:并发覆盖下缓存值可能比数据库旧。
  • 缓存未命中时不设 TTL:脏数据永久驻留。

追问

  • 先删缓存还是先更新库?答:见本章一致性专题;常见顺序是先更新库再删缓存,配合延迟双删应对并发窗口。
  • 缓存击穿时如何避免大量请求同时回源?答:互斥重建或单飞加载,见击穿专题。

04.4.10.1-023 什么是缓存穿透,布隆过滤器与空值缓存分别怎么防护?

一句话结论

穿透指查询数据库不存在的数据,缓存也不命中,请求直达数据库;布隆过滤器在缓存前判断「一定不存在」,空值缓存把不存在结果短 TTL 记下,两者都挡住无效回源。

概念解释

穿透常见于恶意构造不存在的 ID 或拼写错误。布隆过滤器是概率结构:判断不存在则一定不存在,判断存在可能有误判;把已有 ID 集合放入过滤器,请求先过过滤器。空值缓存对查无结果的键缓存短生命周期空标记,避免反复查库。布隆适合大规模主键集合,空值缓存适合零星未命中结果,两者可叠加。

原理流程

  1. 启动/预热时把合法主键集合写入布隆过滤器。
  2. 请求先查过滤器:判定不存在直接返回空。
  3. 判定存在再查缓存;缓存未命中查库。
  4. 库中无记录则缓存空值(短 TTL)。
  5. 数据新增时同步更新过滤器或定期重建。

代码或图示

请求 → 布隆过滤器(不存在→直接空) → 缓存 → DB
DB 无记录 → 缓存空值(短 TTL) → 后续请求不再回源

常见误区

  • 布隆过滤器不随数据新增更新:新注册用户被误判不存在。
  • 空值缓存 TTL 过长:脏空结果长期占用缓存。

追问

  • 布隆过滤器误判会怎样?答:误判存在会放行到缓存/库,不影响正确性,只少挡一部分流量。
  • Rust 侧布隆过滤器用什么实现?答:可选本地布隆库或 Redis 模块;本地结构随多实例各自维护,具体 crate 与维护状态需核对 docs.rs。

04.4.10.1-024 什么是缓存击穿,互斥重建与单飞(single flight)如何防止并发回源?

一句话结论

击穿指热点键过期瞬间,大量并发请求同时未命中并回源压垮数据库;互斥锁只放一个请求重建缓存,其余等待或返回旧值,单飞合并并发加载请求。

概念解释

与穿透(数据不存在)不同,击穿针对存在的热点数据。键过期后高并发同时 miss,数据库被瞬时打满。防护:重建前抢锁,持锁者查库回填,其他等待结果;或用 single flight 组件把并发相同键的加载合并为一次。等待超时可返回旧值/降级数据,避免线程堆积。

原理流程

  1. 缓存未命中,尝试获取重建锁(短 TTL)。
  2. 持锁者查库、回填缓存后释放锁。
  3. 未持锁者短暂等待缓存回填,或先返回旧值/空值。
  4. 等待超时走降级,不无限阻塞。
  5. 热点数据可配合逻辑过期与异步刷新。

代码或图示

miss → 抢重建锁 → 持有者: DB → 回填 cache → 释放锁
       其余: 等待回填 / 返回旧值 / 降级

常见误区

  • 重建锁 TTL 过长:持锁者宕机后热点长时间不可重建。
  • 等待方无限循环重试:请求堆积,应用线程占满。

追问

  • 本地缓存场景怎么做 single flight?答:本地组件记录加载中状态,相同键的后续请求等待同一加载结果;与 moka get_with 能力衔接。
  • 逻辑过期是什么?答:缓存值内嵌过期时间,后台异步刷新,请求不等待重建;适合可容忍短暂旧值的热点。

04.4.10.1-025 什么是缓存雪崩,TTL 抖动与分批预热如何缓解大面积同时失效?

一句话结论

雪崩指大量缓存键在同一时刻失效或缓存整体故障,请求集中回源压垮数据库;TTL 加随机抖动避免同时过期,分批预热与多级缓存分散冲击,故障时降级限流兜底。

概念解释

雪崩成因:批量键 TTL 相同同时到期、Redis 整体故障、大面积脏数据被淘汰。防护分三层:写入 TTL 加随机偏移避免同期失效;启动分批预热热点数据;缓存故障时限流直连库并降级返回。监控缓存命中率与回源量,提前发现失效潮。

原理流程

  1. 写缓存时基础 TTL 加随机抖动(如 ±10%)。
  2. 批量数据分批加载,避免预热同时涌入。
  3. 热点数据本地缓存兜底 Redis 故障。
  4. 缓存异常时开启限流,控制回源数据库的请求比例。
  5. 观测命中率与数据库负载,恢复后逐步放开。

代码或图示

TTL = 基础秒数 + random(0, 抖动范围)
预热:分批加载,间隔与批量大小可控
降级:Redis 不可用 → 限流 + 旧值/空值 + 直连库兜底

常见误区

  • 所有缓存写同一固定 TTL:到期时刻整齐,形成失效峰。
  • 缓存故障时不做限流:数据库被全量流量打垮,故障扩大。

追问

  • 雪崩与击穿区别?答:击穿是单热点键过期并发回源;雪崩是大面积失效或整体故障。
  • 多级缓存如何缓解?答:本地缓存承接一部分读请求,Redis 故障时本地副本兜底;一致性与失效广播见后续专题。

04.4.10.1-026 写数据时先更新数据库还是先删缓存,两种顺序各有什么并发问题?

一句话结论

常见做法是「先更新数据库,再删除缓存」;先删缓存再更新库在并发读写下更容易产生旧值回填,两种顺序都存在短暂不一致窗口,需配合延迟双删或订阅 binlog 收敛。

概念解释

顺序一:先删缓存再更新库。并发读在库更新前 miss,把旧值回填缓存,脏数据驻留到 TTL。顺序二:先更新库再删缓存。并发读在删缓存前读到旧缓存,写入完成后缓存已删,下次读回填新值;风险是删缓存失败留下旧值。缓存本质是副本,无法与数据库强一致,工程目标是缩小窗口并兜底。

原理流程

  1. 先更新库:写事务提交成功。
  2. 删除对应缓存键;删除失败进入重试/补偿队列。
  3. 并发读在删除前可能持有旧缓存,删除后下次读回填新值。
  4. 关键业务加延迟双删或订阅数据库变更刷新缓存。
  5. TTL 作为最终兜底,保证脏数据有限期。

代码或图示

先更新库 → 删缓存(推荐)
风险:删缓存失败 → 旧值残留;补偿:重试删除/订阅变更
先删缓存 → 更新库(不推荐)
风险:并发读旧值回填 → 脏数据驻留至 TTL

常见误区

  • 认为删缓存失败可以忽略:旧值长期驻留,必须有补偿重试。
  • 追求缓存与库实时一致:旁路模式做不到强一致,按业务容忍度定窗口。

追问

  • 删除缓存失败怎么补偿?答:失败入重试队列,有限次重试后记录告警;或由 binlog 订阅异步刷新/删除。
  • 读多写少场景选哪种?答:先更新库再删缓存更稳;写并发高时评估延迟双删成本。

04.4.10.1-027 延迟双删用来解决什么问题,延迟时长如何确定?

一句话结论

延迟双删在更新库后先删一次缓存,延迟一个读并发窗口再删第二次,清理并发读回填的旧值;延迟时长按读请求耗时与事务窗口估算,不是固定魔法值。

概念解释

先更新库再删缓存后,仍可能有并发读在删除前拿到旧缓存;若缓存被旧值回填,第二次延迟删除清掉它。流程:更新库 → 删缓存 → 等待(覆盖一次读写往返时长)→ 再删缓存。延迟过短第二次删除赶不跑回填,过长旧值暴露窗口扩大。延迟任务由后台调度或消息延迟队列执行,不能阻塞主写路径。

原理流程

  1. 业务写事务提交。
  2. 第一次删除缓存键。
  3. 提交延迟任务(时长覆盖典型读链路耗时)。
  4. 延迟到点第二次删除同一键。
  5. 第二次删除失败仍走补偿队列;TTL 兜底残留旧值。

代码或图示

写库 → 删 cache → 延迟 N ms → 再删 cache
N 参考:数据库读耗时 + 缓存读写耗时 + 余量

常见误区

  • 在请求线程内 sleep 等待:阻塞业务响应,延迟必须异步执行。
  • 延迟时长拍脑袋固定:应结合 P99 读耗时压测调整。

追问

  • 延迟双删能替代 binlog 订阅吗?答:不能,双删只处理删除瞬间的并发回填;变更来源复杂时订阅数据库事件更可靠。
  • 第二次删除需要比对值吗?答:二次删除为失效意图,直接删键即可;若期间有新写入回填新值,需评估误删风险,必要时按版本号删除。

04.4.10.1-028 订阅数据库变更(binlog)刷新缓存如何工作,相比应用侧双删有什么优势?

一句话结论

通过监听数据库 binlog 变更事件,异步删除或刷新对应缓存,把缓存一致性从应用写路径解耦;优势是覆盖应用侧遗漏的删除路径,劣势是引入订阅组件与延迟,属于最终一致方案。

概念解释

应用内删缓存可能漏路径(后台批量更新、SQL 直改、多服务写同一表)。订阅 binlog 捕获所有行变更,按表与主键映射缓存键,异步失效缓存。链路:数据库 binlog → 订阅组件(如 Canal 类方案)→ 消息 → 缓存失效逻辑。延迟在秒级以内,缓存 TTL 兜底。Rust 服务消费变更消息执行删除,不直接耦合数据库内部工具链。

原理流程

  1. 部署 binlog 订阅组件,解析行变更事件。
  2. 事件按表映射到缓存键规则。
  3. 投递到消息通道,服务消费者删除/刷新缓存。
  4. 失败重试与死信告警。
  5. 缓存 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。

原理流程

  1. 监控命令与内存,定位大键类型与体积。
  2. 抽样 MEMORY USAGE key 确认大小。
  3. 设计拆分方案:字段分片、分段键、元素分批迁移。
  4. 迁移期间双写过渡,校验数据完整。
  5. 旧大键用 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 侧对可复制数据做多副本键分散;读流量走从节点。注意本地缓存一致性窗口与副本失效广播。

原理流程

  1. 统计各键访问频次,输出热 key 排行。
  2. 评估热键数据是否可容忍短暂旧值。
  3. 加本地缓存副本,缩短回源 Redis 路径。
  4. 可复制数据拆多副本键,请求按哈希分散。
  5. 读请求路由到从节点分担主节点压力。

代码或图示

识别:命令频次统计 / 代理热点监控
缓解:本地缓存 → 多副本键 → 读从节点
失效:更新后广播失效各副本与本地缓存

常见误区

  • 热 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 客户端维护槽位映射,槽位迁移时刷新路由。

原理流程

  1. 客户端计算键槽位,路由到对应节点。
  2. 多键操作前确认槽位一致。
  3. 相关键设计统一 hash tag,如 order:{1001}:items。
  4. 节点扩缩容时槽位迁移,客户端更新映射。
  5. 跨槽操作拆分到单键命令,避免集群报错。

代码或图示

键: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 演进要考虑旧缓存反序列化兼容。

原理流程

  1. 评估单值大小、访问频次与带宽预算。
  2. 跨语言/人工排查优先 JSON;内部高频大对象评估二进制格式。
  3. 封装序列化层,格式可替换。
  4. 缓存键带格式/版本前缀,格式切换时旧值可识别。
  5. 压测序列化耗时与体积,确认收益。

代码或图示

[dependencies]
serde_json = "*"
rmp-serde = "*"  # MessagePack 序列化,待确认 crate 维护状态

常见误区

  • 二进制格式不做版本标注:格式演进后旧缓存反序列化失败。
  • 为省体积选不可读格式,线上排障困难:权衡可观测性。

追问

  • bincode 适合跨语言缓存吗?答:不适合,格式与 Rust 类型耦合;跨语言选 MessagePack/JSON。
  • 序列化性能瓶颈在哪?答:大对象反序列化 CPU 成本;热点小对象格式差异影响有限。

04.4.10.1-033 序列化与反序列化在缓存链路中如何影响性能,怎么优化?

一句话结论

缓存命令本身快,瓶颈常在应用层序列化/反序列化;优化方向是减少大对象序列化、复用缓冲区、选择紧凑格式、避免缓存不必要字段,并在压测中确认耗时占比。

概念解释

每次回填与读取都要序列化对象。大对象(嵌套结构、长列表)序列化占用 CPU 与内存临时分配。优化:缓存粒度拆分,只缓存需要字段;复用 serde 缓冲区;紧凑格式降体积;避免高频缓存大列表。序列化错误与类型不匹配要进入错误监控,不能静默丢弃。

原理流程

  1. 压测定位耗时:命令网络 vs 序列化 vs 业务组装。
  2. 缩小缓存对象字段与体积。
  3. 序列化复用缓冲区,减少临时分配。
  4. 评估紧凑格式的体积/CPU 权衡。
  5. 监控序列化失败率与缓存值大小分布。

代码或图示

链路:业务对象 → 序列化 → 网络 → 反序列化 → 业务对象
优化:字段裁剪 / 缓冲区复用 / 格式选型 / 拆分大对象

常见误区

  • 缓存整张大对象:字段用不到也付出序列化成本。
  • 忽略反序列化临时内存:高并发下分配压力大。

追问

  • 零拷贝在 Redis 值上可行吗?答:网络传输与反序列化边界内有限;Rust 侧缓存字符串切片借用需结合连接生命周期评估。
  • 序列化失败如何兜底?答:记错误指标,降级直连库;不要把损坏缓存值反复回填。

04.4.10.1-034 Redis 的过期删除策略是什么,惰性删除与定期清理如何配合?

一句话结论

Redis 采用惰性删除(访问时检查过期)加定期抽样清理(后台周期扫描)结合;过期键不是到点立刻移除,而是在访问时或后台抽样时被清理。

概念解释

惰性删除:每次读/写键前检查 TTL,过期则删除并返回未命中。定期清理:后台周期抽样带 TTL 的键,清理已过期比例高的样本。两者配合避免单线程被过期清理占满,也避免过期键长期占内存。理解这一策略有助于解释「内存中仍能看到过期键」「统计数量偏大」等现象。

原理流程

  1. 键写入时设置 TTL 与过期时间戳。
  2. 访问该键时先检查是否过期,过期即删除。
  3. 后台任务周期抽样带 TTL 键,清理过期项。
  4. 过期比例高时增加本轮清理强度(受配置约束)。
  5. 内存达上限再触发淘汰策略。

代码或图示

惰性:请求 → 检查 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 系列让冷数据被淘汰;存会话/任务状态等不可丢数据时,要避免易淘汰策略并预留内存。

原理流程

  1. 明确键是否可重建:可重建缓存 vs 不可丢状态。
  2. 可重建缓存:选 allkeys-lru/lfu。
  3. 不可丢数据:预留内存或 noeviction,写入侧限流。
  4. 监控内存水位与淘汰次数。
  5. 调整 maxmemory 与键 TTL 控制占用。

代码或图示

noeviction:内存满拒绝写
volatile-lru/lfu:只淘汰带 TTL 键
allkeys-lru/lfu:淘汰任意冷键(纯缓存常用)

常见误区

  • 缓存与持久状态混在同一实例:淘汰策略误删不可丢数据。
  • 不设 maxmemory:内存无限增长直至系统级问题。

追问

  • LRU 与 LFU 怎么选?答:长热点、偶发扫描用 LFU 防冷数据污染;常见访问模式下 LRU 足够;具体样本策略以 Redis 版本实现为准。
  • 淘汰会通知应用吗?答:不会主动通知,应用通过缓存 miss 回源;本地缓存需自行处理淘汰。

04.4.10.1-036 Redis 高可用形态有哪些:主从复制、哨兵、集群分别解决什么?

一句话结论

主从复制提供读副本与数据备份,哨兵负责主节点故障自动切换,集群提供分片扩容与高可用;选型按数据量、读写压力与可用性要求分层组合。

概念解释

单节点有单点风险。主从:写主节点,异步复制到从节点,读可分流。哨兵:监控主从,故障时选举切换新主,客户端感知新主。集群:数据分片到多节点,每节点可配副本,横向扩容。异步复制窗口内主故障可能丢失最近写入;强一致需求需评估方案局限。

原理流程

  1. 数据量小、读多:主从 + 哨兵保障高可用。
  2. 数据量或写压力大:集群分片,副本在节点内高可用。
  3. 客户端配置拓扑连接,故障切换后刷新路由。
  4. 监控复制延迟、节点状态与切换事件。
  5. 备份与持久化策略按数据重要性配置。

代码或图示

主从:主写从读,异步复制
哨兵:监控 + 自动故障转移
集群:槽位分片 + 副本 + 横向扩容

常见误区

  • 把主从复制当强一致备份:异步复制有延迟窗口。
  • 哨兵与集群混用概念:哨兵管单主组转移,集群管分片。

追问

  • 故障切换期间写入会怎样?答:切换窗口内连接可能报错,客户端需重连重试;未复制到从的写入可能丢失。
  • 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 异步删大键。慢日志统计执行时长,接口层限制单次返回条数。

原理流程

  1. 审查命令模式,识别全量遍历与大集合读取。
  2. 遍历改 SCAN/HSCAN 分批。
  3. 集合读取分页,限制单批条数。
  4. 大键删除用 UNLINK。
  5. 接入慢日志与命令耗时监控,定位阻塞点。

代码或图示

避免:KEYS * / 大 HGETALL / 大 SMEMBERS / 全量 LRANGE
替代:SCAN 分批 / 分页读取 / UNLINK

常见误区

  • 后台清理任务用 KEYS 全量扫:阻塞线上实例。
  • 一次返回大列表再在应用层裁剪:传输与序列化双重浪费。

追问

  • 慢命令日志在哪看?答:Redis 服务端 slowlog;客户端记录命令耗时与返回体积。
  • 阻塞命令影响面多大?答:单实例上所有命令排队,从节点复制也受影响;集群下按节点隔离。

04.4.10.1-038 用 INCR 配合 EXPIRE 做计数器与限流,原子性如何保证?

一句话结论

INCR 原子自增计数;首键写入时设置过期时间实现窗口计数,限流判定读计数是否超阈值;计数与过期分开两步时注意并发下的 TTL 设置竞争。

概念解释

计数器场景:接口访问次数、每日签到、限额。INCR 单命令原子。TTL 问题:首次自增后 EXPIRE,并发下多请求同时判断键不存在,重复设过期;可用 Lua 把「自增 + 首次设 TTL」合并原子执行。限流按窗口(固定窗口/滑动窗口)结合阈值判断,超限拒绝。

原理流程

  1. 键按业务 + 窗口标识构造。
  2. INCR 自增,返回当前值。
  3. 首次(值为 1)设置过期时间;并发场景用 Lua 保证只设一次。
  4. 判定当前值是否超阈值。
  5. 窗口过期自动清理计数。

代码或图示

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;启动预热覆盖已知热点,定时/主动刷新应对数据更新与周期性热点,预热要分批限速避免冲击数据库。

概念解释

新实例上线或缓存清空后,直接承接流量会回源数据库。预热流程:梳理热点键清单(高频接口、配置、排行),分批从库加载回填缓存。启动预热在部署后、切流前完成;定时预热刷新周期数据;变更事件主动失效而非全量预热。预热脚本限速执行,避免一次性压垮数据库。

原理流程

  1. 梳理热点数据清单与访问优先级。
  2. 启动阶段分批加载,控制批次大小与间隔。
  3. 验证热点键命中率达标后切流。
  4. 定时任务刷新周期型热点。
  5. 数据变更走事件失效,不依赖全量重预热。

代码或图示

热点清单 → 分批 DB 查询 → 回填 cache(限速)→ 命中率达标 → 切流
周期数据:定时刷新;变更数据:事件失效 + 懒回填

常见误区

  • 启动时全量加载所有数据:数据库与缓存同时被冲击。
  • 预热后不校验命中率:切流仍有大量 miss。

追问

  • 预热失败怎么处理?答:记录未预热键,流量到来时懒加载;降级保护数据库限流。
  • 多实例预热重复吗?答:共享 Redis 只需预热一次;本地缓存各实例分别预热。

04.4.10.1-040 缓存故障时的降级策略有哪些,如何避免数据库被连带打垮?

一句话结论

降级手段包括:限流控制回源比例、返回旧值/空值/默认值、本地缓存兜底、只读降级;核心是缓存故障时不让全量请求直达数据库,按业务优先级分层放行。

概念解释

Redis 不可用或大面积 miss 时,数据库承接全部读流量,容易被打垮。降级链路:探测缓存健康度 → 触发限流 → 非核心接口返回默认/旧值,核心接口有限回源 → 本地缓存副本承接 → 缓存恢复后逐步放开。降级策略要预先演练,错误与超时进入监控,避免故障期间静默失败。

原理流程

  1. 监控缓存连接错误、超时与命中率下跌。
  2. 触发降级开关,按接口优先级限流回源。
  3. 非核心读返回旧值/空值/静态默认。
  4. 本地缓存与预留副本兜底热点。
  5. 缓存恢复后观察数据库负载,逐步解除限流。

代码或图示

缓存故障 → 限流回源 → 本地缓存/旧值/默认值 → 核心接口有限放行 → 恢复后逐步放开

常见误区

  • 故障时所有请求直连库:数据库成为第二个单点。
  • 降级返回空值不标注:客户端把空值当真实数据展示。

追问

  • 降级数据如何标识?答:响应带降级标记或头部,前端展示兜底提示;监控区分正常 miss 与降级返回。
  • 缓存连接超时设多久?答:按接口预算设置短超时,快速失败走降级,不等待长连接挂起。

04.4.10.1-041 缓存一致性按业务如何分级,哪些场景必须强一致,哪些接受最终一致?

一句话结论

一致性要求按业务分级:金额、库存、权限等强敏感数据优先查库或短缓存;展示类、统计类数据接受最终一致;分级决定 TTL、失效策略与是否走缓存。

概念解释

缓存引入副本必然有一致性窗口。强一致场景(扣款、权限判定、库存)不宜依赖缓存旧值,可加短 TTL + 主动失效 + 关键路径直查。最终一致场景(详情页、推荐列表、展示计数)容忍秒级旧值。设计时明确每类数据的容忍窗口,而不是所有数据同一套缓存策略。

原理流程

  1. 按业务划分一致性等级:强敏感 / 可短暂旧值 / 可延迟。
  2. 强敏感:短 TTL、变更主动失效、关键判定直查库。
  3. 可容忍:常规旁路缓存 + TTL 兜底。
  4. 低敏感:长 TTL,定时刷新。
  5. 监控不一致投诉与对账数据。

代码或图示

强一致:库存/金额/权限 → 直查或短 TTL + 主动失效
最终一致:详情/列表/展示计数 → 旁路缓存 + TTL

常见误区

  • 权限标识也长缓存:旧权限导致越权访问窗口。
  • 为所有数据追求强一致:缓存失去减负意义。

追问

  • 强一致数据能不能用缓存加速读?答:可缓存只读副本做展示,判定逻辑以库为准;缓存结果标注用途。
  • 一致性窗口怎么度量?答:从变更提交到缓存失效/回填的时间差,结合订阅延迟与 TTL 评估。

04.4.10.1-042 缓存 Key 设计有哪些规范,命名空间、版本与 TTL 如何规划?

一句话结论

键名按「业务域:类型:标识」分层命名,带版本前缀便于格式切换,避免空格与特殊字符;TTL 按数据等级分组规划,键设计要支持批量失效与排查。

概念解释

键是缓存接口的一部分,命名混乱导致无法批量管理与排查。规范:小写冒号分段,业务前缀隔离多实例共享;版本前缀(v1:)应对序列化格式演进;对象键含主键;集合键标注分片/分页。避免过短无意义键,避免把敏感信息编码进键。TTL 分组:临时数据短,配置类长,不可重建数据另设策略。

原理流程

  1. 定义键规则:版本:业务:类型:标识。
  2. 同一对象的相关键用统一标识(可配合 hash tag)。
  3. 格式/结构升级时新版本前缀隔离旧缓存。
  4. 按数据等级规划 TTL 区间。
  5. 清理脚本按前缀扫描(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 只做前置拦截。幂等记录保存请求结果,重复请求直接返回首次结果。

原理流程

  1. 生成幂等键(业务类型 + 业务唯一标识)。
  2. SET NX PX 占位,成功才执行业务。
  3. 业务结果写入幂等记录,重复请求返回结果。
  4. TTL 到期清理;唯一约束数据库索引兜底。
  5. 占位失败按「重复请求」处理,不重复执行写操作。

代码或图示

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;名次按分数位置。并列分数时成员顺序不保证业务可读,可把「分数 + 时间戳/序号」编码为复合分数,或查询时处理并列。榜单周期重置用新键或清理成员。

原理流程

  1. 成员写入/更新分数:ZADD / ZINCRBY。
  2. 倒序取 Top N:ZREVRANGE start stop WITHSCORES。
  3. 查成员名次:ZRANK/ZREVRANK。
  4. 并列场景设计复合分数或并列规则。
  5. 周期榜单换新键,旧键到期清理。

代码或图示

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 与内存,集群下跨槽集合运算受限;成员编码与过期策略按业务设计。

原理流程

  1. 成员加入:SADD,重复成员自动忽略。
  2. 存在判断:SISMEMBER。
  3. 集合关系:SINTER/SUNION/SDIFF。
  4. 大集合分页或限量取成员。
  5. 集合过期随 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 与令牌有效期对齐;刷新时轮换标识,登出删除键。会话数据变更(角色调整)需同步失效旧会话。

原理流程

  1. 登录成功生成会话标识,写入 Redis 含身份与元数据。
  2. 请求校验取会话,检查存在与未过期。
  3. 临近过期按策略刷新,轮换会话标识。
  4. 登出/强制下线删除会话键。
  5. 权限变更后失效相关会话。

代码或图示

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,跨节点接受最终一致并做对账。索引键设计要支持按维度清理。

原理流程

  1. 主对象存 Hash:HSET user:1001 name age。
  2. 查询维度建索引:状态 Set、时间 ZSet。
  3. 写入/更新时先改主对象,再维护索引。
  4. 多键一致性用事务/Lua(同槽)或异步补偿。
  5. 定期对账主数据与索引,修复漂移。

代码或图示

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 携带错误类别与消息:网络/连接类可重连重试,命令参数/语法类不可重试,服务端业务错误按语义处理;应用层区分可重试与致命错误并记录指标。

概念解释

错误来源:连接断开、超时、认证失败、命令语法错误、服务端运行错误、类型不匹配。可重试:临时网络抖动、连接重置(配合退避)。不可重试:参数错误、键类型不符、认证失败。重试要有上限与退避,避免故障风暴。错误包装进领域错误,日志保留原始类别。

原理流程

  1. 捕获 RedisError,读取错误类别/详情。
  2. 网络/超时类:有限次退避重试。
  3. 参数/类型类:不重试,记录缺陷并返回业务错误。
  4. 认证/配置类:告警并停止重试。
  5. 错误指标按类别上报监控。

代码或图示

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。

原理流程

  1. 收集待缓存键列表。
  2. MGET 批量取回,按顺序解析。
  3. 拆分命中值与缺失键。
  4. 缺失键批量查数据源,回填缓存。
  5. 组装完整结果返回。

代码或图示

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 读写、序列化、键构造与错误处理。测试时用内存替身实现接口。缓存与数据库访问分层:缓存未命中由仓储层触发回源还是由服务层编排,需统一约定。

原理流程

  1. 定义业务缓存 trait:按对象与操作划分方法。
  2. Redis 实现负责键规则、序列化、TTL、错误分类。
  3. 服务层调用缓存接口,不接触 redis-rs 类型。
  4. 注入实现(生产 Redis / 测试内存替身)。
  5. 指标与降级在封装层统一埋点。

代码或图示

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 上下文选择对应缓存类型。

原理流程

  1. Cargo.toml 引入 moka,按运行时需要 feature。
  2. 构造缓存实例,配置容量/权重与过期策略。
  3. 业务读路径先查本地缓存,命中直接返回。
  4. 未命中经加载回调取数并写入缓存。
  5. 淘汰与过期由库后台维护。

代码或图示

[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 方法以当前版本文档为准。

原理流程

  1. 评估条目大小是否均一:均一用条目容量,差异大用权重。
  2. 构造缓存设置 max_capacity 或 max_weight。
  3. 写入条目时提供权重值(按估算字节/字段数)。
  4. 总权重超限时按淘汰策略移除条目。
  5. 监控缓存占用与淘汰次数回调。

代码或图示

// 伪代码:权重模式
// 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(空闲时间)清理冷门条目,频繁访问的热点不被过早淘汰。可单独使用,也可组合:两条时间都设置时先到期者生效。本地缓存过期由库后台扫描与访问时检查共同完成。

原理流程

  1. 写入条目记录写入时间与最后访问时间。
  2. TTL 模式:当前时间超写入时间 + TTL 即失效。
  3. Idle 模式:当前时间超最后访问时间 + idle 即失效。
  4. 组合配置下任一条件满足即淘汰。
  5. 访问命中时刷新最后访问时间(仅 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 采用该类近似策略。工程上不必手写频率统计,理解其对突发扫描的免疫力即可;命中率差异需压测验证。

原理流程

  1. 条目访问时更新频率估计计数。
  2. 新进入条目先在 admit/窗口阶段观察。
  3. 超容量时按频率与新近度淘汰低价值条目。
  4. 冷数据(低频率)优先被移除。
  5. 热点在频繁访问下保留在缓存中。

代码或图示

LRU:按最后访问时间排序,冷扫描冲掉热点
TinyLFU:频率估计 + 新近度窗口,抗一次性冷数据冲击

常见误区

  • 以为淘汰策略决定绝对最优命中率:工作负载不同,LRU/LFU 表现需按实际访问模式压测。
  • 自行实现频率计数替代库:引入复杂度与一致性风险。

追问

  • 频率统计有误差吗?答:素描结构是近似估计,存在小概率误判;目的是小内存换大体量热度估计。
  • 本地缓存淘汰与 Redis 淘汰策略要一致吗?答:不必一致,两层数据特性不同;各自按工作负载配置。

04.4.10.1-055 moka 的 get_with 如何实现并发加载,single flight 解决什么问题?

一句话结论

get_with 在缓存未命中时执行加载回调并写入;相同键的并发请求共享同一次加载结果(single flight),避免缓存击穿时多个任务同时回源。

概念解释

本地缓存击穿场景:热点键过期瞬间,多个并发任务同时未命中。若各自执行回调查库,形成本地击穿。get_with 把加载中状态按键记录,后续同键请求等待同一结果。回调只执行一次,结果回填后并发方都拿到。这与 Redis 层互斥重建思路一致,但发生在进程内。

原理流程

  1. 读缓存:命中直接返回。
  2. 未命中且无加载中记录:执行 get_with 回调取数。
  3. 同键后续请求发现加载中,等待共享结果。
  4. 回调成功写入缓存,通知等待方。
  5. 回调失败按策略返回错误,不写入缓存。

代码或图示

// 伪代码: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 层防多实例同时打库 → 逻辑过期后台刷新。回调要轻量、可重试;失败不缓存错误值。热点永不过期场景用后台异步刷新保证新鲜度。

原理流程

  1. 本地未命中:get_with 合并进程内并发加载。
  2. 需要回源数据库时,经 Redis 层互斥或 single flight 限制单实例重建。
  3. 热点数据采用逻辑过期:返回旧值,后台异步刷新。
  4. 加载失败短暂重试,不缓存失败结果。
  5. 监控未命中回源量,识别击穿征兆。

代码或图示

进程内: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。

原理流程

  1. 判断需求:纯并发键值映射还是缓存治理。
  2. 固定字典、配置映射:dashmap 直接可用。
  3. 需容量淘汰、过期、并发加载:选 moka。
  4. 若用 dashmap 做缓存,补 TTL 扫描、容量上限与清理任务。
  5. 封装统一缓存接口,实现可替换。

代码或图示

dashmap:并发哈希表,get/insert,无淘汰/TTL/加载合并
moka:  并发 map + 权重容量 + TTL/idle + TinyLFU + get_with

常见误区

  • 把 dashmap 当缓存直接长期运行:条目累积导致内存增长。
  • 在 dashmap 上反复遍历清理过期:与库并发模型冲突,效率低。

追问

  • dashmap 锁竞争如何?答:分片锁降低单锁竞争;具体性能以基准测试为准。
  • 两者能混用吗?答:可按场景分用,但同一对象缓存策略应统一,避免治理逻辑分裂。

04.4.10.1-058 dashmap 作为本地缓存有哪些局限,需要自己补哪些能力?

一句话结论

局限:无容量上限、无过期淘汰、无加载合并、无统计指标;用它做缓存需自实现 TTL 记录、后台清理、容量淘汰与命中统计,成本接近自建缓存。

概念解释

在 dashmap 上做缓存,业务要额外维护:每条目的写入/访问时间,定期扫描清理;超容量时淘汰策略;未命中并发去重;命中率与占用指标。通用 map 不提供这些钩子。如果这些能力都需要,直接用缓存库更稳妥;dashmap 更适合条目可控、生命周期由业务明确管理的映射。

原理流程

  1. 评估条目规模:是否可能无限增长。
  2. 补充元数据:时间戳、权重。
  3. 实现后台扫描清理过期条目。
  4. 实现容量淘汰(LIFO/LRU 简易版)。
  5. 增加命中/未命中指标与内存监控。

代码或图示

自建清单:过期时间记录 / 后台清理 / 容量淘汰 / 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 这类完整方案。

原理流程

  1. 列出缓存需求:并发度、过期、淘汰维度、加载合并。
  2. 需求简单:轻量 LRU 足够,编译体积小。
  3. 服务端并发与治理需求:选 moka。
  4. 压测对比命中率、延迟与锁竞争。
  5. 缓存接口抽象,保留替换余地。

代码或图示

轻量 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。估算单条成本:业务字段 + 字符串容量 + 库元数据,批量样本测量后乘条目数。

原理流程

  1. 测量典型条目在内存中的实际大小。
  2. 按并发与数据量估算最大条目数。
  3. 设置缓存容量/权重上限,留安全余量。
  4. 配置过期策略清理冷门条目。
  5. 监控 RSS、缓存条目数与淘汰事件,超限告警。

代码或图示

内存估算 = 单条大小 × 条目数 + 哈希表/元数据开销
上限设置 < 进程内存预算 × 安全系数

常见误区

  • 只按条目数估算,忽略字符串与集合容量:实际内存远超预期。
  • 本地缓存放大对象克隆:值被多次持有占用重复内存。

追问

  • 大对象为什么不进本地缓存?答:单条占用大,少量条目即可吃满内存,且序列化/克隆成本高;大对象缓存放 Redis 或数据库侧。
  • 内存指标在哪看?答:进程 RSS 与库自带统计(条目数、权重),接入可观测性章节的监控体系。

04.4.10.1-061 本地缓存与 Redis 如何组成多级缓存,请求链路怎么走?

一句话结论

多级缓存按「本地缓存 → Redis → 数据库」逐级回源;热点在本地命中省网络,Redis 承接跨实例共享数据,数据库为权威源;各级 TTL 与失效策略分层设计。

概念解释

一级本地缓存延迟最低但不共享,二级 Redis 跨实例一致,三级数据库兜底。请求先查本地,未命中查 Redis,再未命中查库并逐级回填。本地副本短期容忍旧值,Redis 作为共享副本。层级过多增加一致性复杂度,按数据热度选择是否启用本地层。

原理流程

  1. 请求先查本地缓存,命中返回。
  2. 本地未命中查 Redis,命中回填本地。
  3. Redis 未命中查数据库,回填 Redis 与本地。
  4. 写路径更新库,逐级失效缓存。
  5. 监控各级命中率定位瓶颈层级。

代码或图示

请求 → 本地缓存(moka) → Redis → 数据库
回填:DB → Redis → 本地
失效:写库 → 删 Redis → 广播失效本地

常见误区

  • 每层都长 TTL:旧值叠加,不一致窗口拉长。
  • 本地缓存未命中就直连库:跳过 Redis,共享副本失去意义。

追问

  • 哪些数据适合放本地层?答:小体积、高频读、可容忍秒级旧值的热点;大对象与强一致数据留 Redis/库。
  • 多级缓存命中率怎么看?答:分别统计本地命中、Redis 命中、回源率;本地命中率低说明本地层价值有限。

04.4.10.1-062 多级缓存如何保证一致性,失效广播怎么做?

一句话结论

写库后失效 Redis,再通过 Pub/Sub 或消息广播通知各实例剔除本地副本;本地层配合短 TTL 兜底,接受最终一致,广播丢失由 TTL 收敛。

概念解释

多实例本地副本无法逐一主动删除,依赖失效广播:变更事件发到频道,各实例订阅后清本地缓存键。广播本身不保证必达(Pub/Sub 离线丢失),所以本地 TTL 是兜底。事件携带键标识与版本,避免旧事件误删新值。订阅消费者要处理重复消息与消息顺序。

原理流程

  1. 写事务提交后删除 Redis 缓存键。
  2. 发布失效事件(键、类型、版本)到广播频道。
  3. 各实例订阅消息,按键清除本地条目。
  4. 本地 TTL 兜底:广播丢失后旧值有限期。
  5. 监听失败/积压进入监控告警。

代码或图示

写库 → 删 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 一致:版本前缀、业务前缀、对象类型。可按业务分多个缓存实例,容量与过期策略独立。键不含隐私明文,本地内存转储风险低于网络传输,但仍按规范处理。

原理流程

  1. 定义本地键命名规则与前缀段。
  2. 评估是否按业务拆分缓存实例。
  3. 写入前构造规范键,避免裸标识。
  4. 定期检查键分布,识别异常前缀。
  5. 清理任务按前缀批量失效。

代码或图示

v1:profile:1001
v1:dict:country
(本地实例内隔离,不与 Redis 键规则冲突但保持一致风格)

常见误区

  • 本地缓存键用短名随机拼接:排查时无法定位业务归属。
  • 多业务共享实例却不设前缀:测试数据覆盖生产缓存。

追问

  • 本地缓存需要环境前缀吗?答:同一进程只跑一个环境时可简化;多环境混合部署必须加环境段。
  • 键里能放查询参数组合吗?答:可编码排序后的参数作为键,注意组合数量膨胀。

04.4.10.1-064 本地缓存不做序列化有什么性能优势,代价是什么?

一句话结论

本地缓存直接持有 Rust 对象内存,跳过序列化/反序列化与网络拷贝,读取延迟最低;代价是对象驻留内存、跨语言/跨进程不可读,类型演进受进程内版本约束。

概念解释

Redis 值需要编码成字符串/二进制,读取再解码;本地缓存存的是对象(或克隆/引用),命中即取内存对象。优势:无编解码 CPU、无网络往返。代价:对象不能跨进程共享;进程重启数据丢失;结构体演进后旧内存对象需清理;值克隆会复制内存。本地缓存适合小对象与短生命周期副本。

原理流程

  1. 未命中时构造对象写入本地缓存。
  2. 命中直接返回对象(按库 API 共享/克隆语义)。
  3. 无序列化步骤,无格式版本转换。
  4. 进程重启后本地为空,重新回源预热。
  5. 结构体变更后旧条目按 TTL/版本前缀清理。

代码或图示

Redis:对象 → 序列化 → 网络 → 反序列化 → 对象
本地:对象直接驻留内存,命中零编解码

常见误区

  • 本地缓存存大对象:内存占用与克隆成本高。
  • 假设本地对象可被其他进程读取:本地副本不跨进程。

追问

  • 本地返回对象是克隆还是引用?答:按缓存库 API 与键值类型决定;共享可变状态需内部可变性,通常克隆返回避免别名问题,具体以 moka 文档为准。
  • 结构体改名后旧缓存怎么办?答:本地条目短期驻留,版本前缀/TTL 清理;进程重启自然清空。

04.4.10.1-065 进程重启或新实例上线后本地缓存冷启动怎么办?

一句话结论

冷启动靠预热加载热点数据,承接流量前达到命中率门槛;预热分批限速,失败条目懒加载,配合降级保护数据库。

概念解释

本地缓存在进程内存,重启即清空。新实例直接接流量会集中回源数据库。预热流程与 Redis 预热一致:热点清单分批加载进本地缓存。多实例各自预热(本地不共享)。预热期间或预热失败的请求走懒加载,限流兜底;健康检查通过后再全量切流。

原理流程

  1. 梳理热点对象清单与优先级。
  2. 实例启动后分批加载本地缓存,控制批次间隔。
  3. 检查本地命中率达标后再接全量流量。
  4. 未预热条目懒加载回源,有限流保护。
  5. 预热失败记录指标,告警人工介入。

代码或图示

实例启动 → 分批预热本地缓存 → 命中率达标 → 接流量
未命中 → 懒加载 + 限流;预热失败条目降级

常见误区

  • 预热全量数据:数据库与进程内存同时被冲击。
  • 不校验预热结果:带大量冷缓存上线,回源压力转嫁数据库。

追问

  • 多实例预热重复吗?答:本地不共享,每个实例各自预热;Redis 预热一次即可被所有实例复用。
  • 预热数据来源?答:热点统计、高频接口与配置字典;周期更新预热清单。

04.4.10.1-066 本地缓存如何防穿透,空值缓存与短 TTL 在进程内怎么落地?

一句话结论

本地层同样缓存空结果(空标记)短 TTL 防不存在数据反复回源;布隆过滤器可放本地或共享 Redis,空值条目与正常条目区分避免误判存在性。

概念解释

穿透在本地层表现为:不存在的键每次都 miss 并回源。落地方式:未命中数据库后,本地缓存空值标记,短 TTL 内直接短路。本地布隆过滤器按实例维护,重启重建;共享布隆放 Redis。空值缓存要与有效对象区分,避免把空标记当业务数据返回。

原理流程

  1. 本地未命中 → 查数据库。
  2. 数据库无记录:本地写入空值标记,短 TTL。
  3. 后续请求命中空标记,直接返回空,不回源。
  4. 数据新增后删除空标记,允许重新加载。
  5. 布隆过滤器作为前置不存在判断(可选)。

代码或图示

miss → DB 无 → 本地存 None/空标记(短 TTL) → 后续短路
新增数据 → 删空标记;布隆过滤器更新或重建

常见误区

  • 空值缓存 TTL 过长:数据上线后长期被空标记挡住。
  • 空标记与正常值同类型存储:返回时混淆,需显式区分。

追问

  • 本地空值占用多大内存?答:空标记条目极小,可批量容纳;仍纳入容量统计。
  • 布隆过滤器本地重建成本?答:集合大时重建有 CPU 成本,可定期后台重建并原子切换。

04.4.10.1-067 本地缓存压测应关注哪些指标?

一句话结论

核心指标:命中率/未命中率、平均加载耗时、条目数与权重(内存占用)、淘汰次数、single flight 等待情况;压测对比不同容量与 TTL 配置下的延迟与数据库回源量。

概念解释

缓存效果不能只看「有没有缓存」。命中率反映减负程度;加载耗时是未命中路径成本;内存占用决定容量上限;淘汰频繁说明容量不足;等待合并情况反映击穿防护。压测模拟真实访问分布(热点占比、条目规模),测 P50/P99 延迟与回源 QPS。

原理流程

  1. 构造贴近线上的访问分布与条目规模。
  2. 记录命中/未命中、加载耗时、条目与权重。
  3. 观测淘汰次数与等待队列。
  4. 调整容量、TTL 与加载策略。
  5. 对比配置下数据库回源量与接口延迟。

代码或图示

指标: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、慢查询日志、复制延迟。客户端指标:池大小/空闲/等待数、命令耗时分布、错误分类(连接/超时/参数)。指标结合才能判断是服务端瓶颈、客户端池耗尽还是慢命令。

原理流程

  1. 采集服务端 INFO 指标:内存、连接、键、淘汰、命中率。
  2. 采集慢日志定位重命令。
  3. 客户端上报池等待、命令耗时与错误类别。
  4. 配置水位告警:内存、连接、回源率下跌。
  5. 定期审查大 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、批大小。

原理流程

  1. 确定基线:条目量、访问分布、读写比、接口延迟预算。
  2. 准备测试数据与缓存预热。
  3. 并发加压,分层记录各级耗时与回源 QPS。
  4. 故障注入:Redis 不可用、键过期潮、大 key。
  5. 对比配置项,输出推荐参数与容量边界。

代码或图示

场景:热点读 / 批量回源 / 击穿并发 / 雪崩过期 / Redis 故障降级
度量:P50/P99 延迟、命中率、回源 QPS、池等待、内存占用

常见误区

  • 均匀随机访问:测不出热点缓存价值。
  • 只压成功路径:降级与故障恢复路径未验证。

追问

  • 基准测试用什么工具?答:Rust 侧可用 criterion 做微基准,接口层用通用压测工具;具体工具链选择以项目现有体系为准。
  • 压测环境要注意什么?答:隔离网络与实例,避免共享 Redis 干扰;数据量与生产同量级。

04.4.10.1-070 序列化格式或结构体演进后,缓存里的旧数据如何处理?

一句话结论

缓存键带格式/版本前缀,演进时旧版本键自然过期不参与解析;本地缓存重启清空或按版本清理,避免旧格式反序列化失败污染新逻辑。

概念解释

结构体字段增减、类型调整后,旧缓存值按新结构反序列化可能失败或字段错位。策略:键前缀含版本号(v1:/v2:),新逻辑只读写新版本键;旧键靠 TTL 自然淘汰。本地缓存重启即清空;Redis 旧键批量清理或等过期。序列化格式切换(JSON→二进制)同样用版本前缀隔离。

原理流程

  1. 结构变更时提升缓存键版本段。
  2. 新代码只读写新版本键。
  3. 旧版本键保留到 TTL 到期,不主动解析。
  4. 必要时按前缀扫描清理旧键(限速 SCAN)。
  5. 本地缓存随进程重启清空。

代码或图示

v1:item:1001 旧格式(TTL 淘汰)
v2:item:1001 新结构
反序列化失败不回填缓存,避免错误值驻留。

常见误区

  • 结构体演进后复用旧键:旧值反序列化报错或静默错位。
  • 缓存错误值:解析失败再次写入,错误被反复短路。

追问

  • 旧键需要立即清理吗?答:非必须,TTL 兜底;占内存大时按前缀限速清理。
  • 兼容期能同时读新旧格式吗?答:可在解析层尝试新旧两种格式,成功后回填新键;复杂度按兼容性收益评估。

04.4.10.1-071 缓存 Key 版本号前缀在多级缓存中如何使用?

一句话结论

版本前缀同时用于 Redis 与本地键,标识数据格式/结构版本;格式升级切新版本前缀,旧版本键隔离淘汰,两层缓存版本规则保持一致便于排查。

概念解释

版本前缀解决「代码已升级、缓存还是旧结构」的问题。多级缓存中本地与 Redis 键使用同一版本段,失效广播携带版本判断。升级时不需要清空全部缓存:新版本键逐步回填,旧版本自然过期。回滚代码时旧版本键仍在,降低回滚风险。

原理流程

  1. 键规则首段为版本号常量。
  2. DTO/格式变更时提升版本。
  3. 读写路径统一通过键构造函数生成键。
  4. 失效事件带版本,旧事件不删新键。
  5. 旧版本键 TTL 到期清理。

代码或图示

构造:format!("v{ver}:{domain}:{type}:{id}")
变更:v1 → v2;v1 键不被新代码读取

常见误区

  • 版本前缀只加在 Redis,本地用裸标识:两层键规则不一致,失效广播难对齐。
  • 版本号散落硬编码:升级时漏改某处导致读写分裂。

追问

  • 版本号放键还是放值内?答:键前缀用于隔离旧格式不被解析;值内可存 schema 版本辅助兼容解析。
  • 回滚后旧版本键还能用吗?答:保留旧版本键正是为回滚兜底;新版本键不影响旧代码。

04.4.10.1-072 本地缓存批量读取与缺失回源如何组织?

一句话结论

本地层批量取键集合,拆分命中与缺失;缺失键经 Redis/数据库批量回源,回填本地与 Redis;批量大小受控,失败部分不丢弃整体结果。

概念解释

列表场景批量取关联对象。本地批量查询返回键值映射,缺失键收集后走二级缓存与数据库批量查询(IN)。回填顺序:先 Redis 后本地。批量键数量分批,避免单批占用过大;部分回源失败的条目保留未命中,不缓存失败。

原理流程

  1. 收集本地待查键列表。
  2. 批量读取本地,拆分命中与缺失。
  3. 缺失键批量查 Redis,再拆分回源数据库。
  4. 批量查库后回填 Redis 与本地。
  5. 组装完整结果,记录未命中条目。

代码或图示

本地批量 get(keys) → 命中集合 / 缺失集合
缺失 → Redis mget → 仍缺失 → DB IN 查询 → 回填 Redis/本地

常见误区

  • 缺失键逐个回源:批量场景退化为 N+1。
  • 回填时整批阻塞:分批限速,失败部分单独记录。

追问

  • 本地批量读取 API 有哪些?答:按 moka 版本提供批量 get 或逐条聚合;具体方法名以 docs.rs 为准。
  • 批量回填顺序影响一致性吗?答:先填 Redis 再填本地,读路径一致;短暂窗口本地可能缺项,下次读从 Redis 补。

04.4.10.1-073 空对象与短路缓存如何设计,避免空值被反复回源?

一句话结论

查询无结果时缓存空值/空对象标记,短 TTL 短路后续请求;区分「空集合」与「未缓存」,数据生成后主动清除空标记。

概念解释

空结果(无记录、空列表)与正常结果同样会反复回源。空值缓存把未命中结果短期保存:本地存空标记,Redis 存空值或短 TTL 标记。注意空集合是业务合法结果,不能误当未缓存;新数据产生后要删空标记,否则新数据被空值挡住。

原理流程

  1. 数据源查询返回空。
  2. 写入空标记,TTL 短于正常缓存。
  3. 后续请求命中空标记直接返回空。
  4. 业务创建数据后删除对应空标记。
  5. 空标记条目纳入容量与监控统计。

代码或图示

DB 空 → 缓存 None/empty(短 TTL) → 后续短路
新增数据 → 删空标记 → 下次加载真实值

常见误区

  • 空值 TTL 与正常值相同:新数据上线后长时间看不到。
  • 不清除空标记:注册/创建类场景被空值短路。

追问

  • 空集合要缓存吗?答:低频空结果可短缓存防穿透;高频变化列表不建议缓存空值。
  • 空值如何序列化?答:Redis 存空标记字符串/空 JSON;本地用 Option 或空结构体区分。

04.4.10.1-074 热点数据异步刷新(逻辑过期)如何实现,与被动过期有何不同?

一句话结论

逻辑过期在值内记录过期时间,读到过期值先返回旧值,后台异步刷新缓存;请求不阻塞等待重建,区别于被动 miss 后同步回源。

概念解释

被动过期:键到期后下次请求 miss,同步查库回填,请求承担回源延迟。逻辑过期:缓存永不过期(或长 TTL),值内嵌逻辑时间;发现逻辑过期时返回旧值并触发后台任务刷新。适合可短暂旧值、不能接受重建延迟的热点。需要后台任务调度能力,刷新失败保留旧值待下次重试。

原理流程

  1. 缓存值写入逻辑过期时间戳。
  2. 请求读取判断是否逻辑过期。
  3. 未过期直接返回;已过期先返回旧值,提交异步刷新任务。
  4. 后台任务查库回填缓存,更新时间戳。
  5. 刷新失败不删旧值,下次请求再触发重试。

代码或图示

值结构:{ data, expire_at }
读:未过期 → 返回;过期 → 返回旧值 + 后台刷新
刷新:异步查库 → 回填;失败保留旧值

常见误区

  • 异步刷新任务泄漏:任务随缓存生命周期管理,取消信号清晰。
  • 逻辑过期值长期不刷新:后台任务失败无告警,需监控刷新成功率。

追问

  • 后台任务用什么调度?答:Tokio 任务/定时调度组件,与 04.4.10.3 后台任务章节衔接。
  • 逻辑过期适合强一致数据吗?答:不适合,旧值可能被展示;强敏感数据走主动失效或直查。

04.4.10.1-075 如何为每类数据设计缓存窗口(TTL、一致性容忍度)?

一句话结论

按数据变更频率与一致性要求分级定 TTL:强敏感短 TTL + 主动失效,展示类中等 TTL,字典配置长 TTL;每类数据明确容忍旧值窗口与失效方式。

概念解释

TTL 不是全局统一值。分级方法:先判断数据是否可缓存(敏感、大对象排除);再定一致性等级;最后选 TTL 与失效方式。变更频繁的数据长 TTL 会放大脏数据;冷门配置短 TTL 浪费回源。窗口设计要与业务方确认可接受的陈旧时长,并在文档中标注。

原理流程

  1. 列出缓存数据类别:身份权限、交易数据、详情、列表、字典配置。
  2. 标注一致性要求与变更频率。
  3. 选定 TTL 区间与失效方式(主动/广播/到期)。
  4. 强敏感数据评估是否不入缓存。
  5. 线上按投诉与对账数据回调窗口参数。

代码或图示

权限/金额:短 TTL + 主动失效,关键判定直查库
详情/列表:中等 TTL,旁路缓存
字典/配置:长 TTL,变更广播失效

常见误区

  • 所有缓存同一 TTL:敏感数据旧值风险与冷门数据回源浪费并存。
  • TTL 变更不评审:缩短影响命中率,拉长影响一致性。

追问

  • 窗口怎么度量?答:从数据变更到缓存生效的延迟(主动失效时间 + TTL 兜底)。
  • 多端看到不一致怎么办?答:按数据等级评估是否可接受;超窗口投诉排查失效广播与 TTL 配置。

04.4.10.1-076 库存扣减等超卖防护场景,Redis 原子操作如何配合数据库兜底?

一句话结论

Redis 用 Lua 或原子命令做预扣减拦截超卖,最终落库以数据库约束与事务为准;缓存层减负与前置拦截,不能替代数据库一致性保障。

概念解释

抢购场景高并发直接打数据库会超卖。常见链路:Redis 预扣库存(Lua 判断库存充足再扣减),成功后异步/同步落库;数据库唯一约束与余额校验兜底。Redis 数据可重建,库存权威源在数据库。预扣失败快速返回;落库失败需回补 Redis 库存。幂等键防重复下单。

原理流程

  1. 活动开始前库存同步到 Redis。
  2. 下单请求经 Lua 判断库存 > 0 再扣减,原子完成。
  3. 预扣成功后写订单与扣减数据库库存(事务)。
  4. 落库失败回补 Redis 库存;幂等键拦截重复请求。
  5. 对账任务核对 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 承载共享副本与会话权威记录;本地缓存加速只读热点。会话、权限、余额等判定数据不依赖本地副本。本地副本变更通过广播失效。实例扩缩容时本地缓存随新实例预热重建。

原理流程

  1. 明确数据是否跨实例共享:共享数据只入 Redis。
  2. 本地缓存仅存只读热点,短 TTL + 广播失效。
  3. 会话读写以 Redis 为准,本地不做权威副本。
  4. 变更事件广播到所有实例清除本地副本。
  5. 新实例按预热流程重建本地缓存。

代码或图示

权威/共享:Redis(会话、权限、库存、跨实例数据)
本地副本:只读热点详情、字典;失效靠广播 + TTL

常见误区

  • 本地缓存存登录态:其他实例读不到,鉴权判定不一致。
  • 多实例各自维护本地配置不广播:配置修改后各实例旧值长期并存。

追问

  • 广播丢失怎么办?答:本地短 TTL 兜底;关键判定数据不走本地。
  • 实例间需要直接通信吗?答:不直连,经 Redis Pub/Sub 或 MQ 中转事件。

04.4.10.1-078 运行期如何动态调整缓存 TTL 与容量,配置变更如何生效?

一句话结论

缓存参数从配置中心读取,构造缓存时应用;运行期调整容量/策略可重建缓存实例或通过配置接口更新,TTL 按条目写入时读取当前配置,避免硬编码常量。

概念解释

开发期定初始参数,线上按命中率与内存回调。实现上:缓存配置(容量、TTL、权重)集中在配置结构;缓存实例可按配置重建(新实例承接新写入,旧条目自然淘汰)。TTL 变更对已写入条目通常不追溯,新条目用新 TTL。动态调整要观察内存与命中率变化,防止激进调整引发回源尖刺。

原理流程

  1. 配置定义容量、TTL 区间、权重上限。
  2. 启动按配置构造缓存实例。
  3. 配置中心推送更新,评估后重建实例或更新读取项。
  4. 新写入条目使用新参数,旧条目按旧参数到期。
  5. 监控调整后的命中率与内存曲线。

代码或图示

配置:max_entries / ttl_secs / max_weight
变更 → 重建 Cache 实例(双实例过渡)或更新写入参数
旧条目:按原 TTL 淘汰

常见误区

  • 参数散落硬编码:调优要改代码发版。
  • 运行期直接改全局可变配置不加同步:并发读写数据竞争。

追问

  • 重建缓存实例会不会击穿?答:新实例为空,需预热或允许懒加载;错峰重建,避免多实例同时清空。
  • 配置变更需要审批吗?答:影响一致性与容量的参数变更走评审,记录变更原因与观察结果。

04.4.10.1-079 如何排查 Redis 连接泄漏与连接数持续增长?

一句话结论

连接泄漏表现为连接数只增不减、池等待超时;排查方向是连接借用后未归还、长任务持有连接、池配置过小导致反复新建,以及未关闭的订阅/管道句柄。

概念解释

正常连接池复用连接,空闲连接保持在池内。泄漏场景:借用连接后异常路径未归还;把连接存入全局结构长期持有;订阅连接与命令连接混用未释放;池大小配置不当使新建连接堆积。排查看客户端池指标(空闲/借用/新建)与服务端连接数趋势,对照代码连接生命周期。

原理流程

  1. 监控服务端连接数与客户端池空闲/借用计数。
  2. 检查连接获取与归还路径是否对称(含错误分支)。
  3. 排查全局缓存的连接句柄与未关闭订阅。
  4. 核对池大小、等待超时与连接生命周期配置。
  5. 修复后观察连接数回落与等待指标。

代码或图示

排查清单:
  借用后错误分支是否归还
  连接是否被长期持有
  订阅/管道句柄是否释放
  池 max_size 与回收配置

常见误区

  • 连接数高就调大池:可能掩盖泄漏,连接堆积到服务端上限。
  • 每次命令新建连接:无池化复用,连接数随请求增长。

追问

  • 连接池句柄能克隆共享吗?答:池句柄可克隆分发,裸连接按池规则借用归还;具体共享语义以 redis-rs 与池库文档为准。
  • 泄漏怎么复现?答:压测并发请求后观察空闲连接是否回收;异常路径单测覆盖归还逻辑。

04.4.10.1-080 在异步任务中使用缓存有哪些阻塞与运行时陷阱?

一句话结论

async 任务内必须用异步连接与异步命令,不能调同步阻塞 API;避免在缓存回调里做重计算或阻塞 IO,连接句柄按运行时要求跨任务传递。

概念解释

Web 服务运行在 Tokio 等异步运行时,同步阻塞调用会占住 worker 线程。缓存链路陷阱:误用同步连接方法;get_with 回调内做阻塞查询;批量命令未 await 导致任务泄漏;连接跨任务移动违反类型约束。异步缓存库(moka async 类型)与异步 Redis 客户端配套使用。

原理流程

  1. 确认运行时类型,引入对应 async feature。
  2. 所有 Redis 调用走异步连接与 await。
  3. 缓存加载回调内只编排异步取数,阻塞操作移到阻塞线程池。
  4. 连接/池句柄按 Clone 或借用规则传入任务。
  5. 监控任务阻塞与超时,定位同步调用点。

代码或图示

// 正确:异步连接 + 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/二进制)。

原理流程

  1. 键名按 ASCII 规则分段,避免空格与特殊符号。
  2. 值按选定格式序列化,编码随版本前缀标注。
  3. 非 ASCII 内容放入值,不拼进键。
  4. 调试工具按二进制安全读取,避免乱码误判。
  5. 监控按键前缀统计时保证编码一致。

代码或图示

推荐: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 当前版本为准。

原理流程

  1. 创建 Pipeline,追加 set/get 等命令。
  2. 调用批量查询方法发送整批,取回回复列表。
  3. 事务场景用辅助函数:声明关注键,闭包内读改写。
  4. 解析回复:按命令顺序类型转换。
  5. 错误按类别处理,区分网络与命令错误。

代码或图示

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 表示一轮结束。

原理流程

  1. 初始化游标为 0。
  2. 调用 SCAN 带 count 提示,返回新游标与本批键。
  3. 处理本批键(清理/统计/迁移)。
  4. 游标未到 0 继续下一批,批次间限速。
  5. 大集合用对应 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/本地,需处理集合膨胀与一致性。简单场景按前缀扫描删除即可,不必引入标签体系。

原理流程

  1. 写入缓存时登记标签映射。
  2. 业务变更确定失效标签。
  3. 按标签取键集合,批量删除缓存键与映射。
  4. 映射过期清理,避免无限增长。
  5. 标签失效失败进入补偿重试。

代码或图示

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/通知句柄)。请求发现键加载中就订阅结果;无加载中记录则插入状态并执行回调,完成后写入结果、唤醒等待方。要处理:回调失败传播给等待方、状态清理、并发插入竞态。生产优先用缓存库内置能力,不自造复杂并发原语。

原理流程

  1. 检查键是否在加载中表。
  2. 在表中:等待通知句柄,取共享结果。
  3. 不在表中:插入加载状态,执行加载回调。
  4. 成功/失败后写入结果,唤醒所有等待方并清理状态。
  5. 竞态下用并发原语保证只有一个执行者。

代码或图示

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 或长时间不返回会污染加载状态,需错误处理与超时控制。

原理流程

  1. 按运行时选择异步缓存类型构造实例。
  2. 未命中时回调执行异步取数。
  3. 阻塞性工作移到专用线程池,回调只 await 结果。
  4. 回调超时返回错误,不写入缓存。
  5. 监控加载耗时与失败率。

代码或图示

// 伪代码:异步 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、淘汰与回填逻辑。再看访问分布:热点是否被缓存、未命中是否回源数据库。最后检查代码路径:是否所有读路径都走了缓存。

原理流程

  1. 核对命中率统计口径(键组、时间窗口)。
  2. 分层看本地/Redis/数据库回源率。
  3. 检查 TTL 是否过短、失效是否过于频繁。
  4. 审查键构造一致性:读路径键规则是否统一。
  5. 评估对象粒度与回填时机,必要时调整缓存策略。

代码或图示

口径 → 分层命中率 → TTL/失效 → 键一致性 → 数据热度 → 粒度/回填

常见误区

  • 命中率低就加大容量:可能是回填逻辑未覆盖,容量无济于事。
  • 用全库随机数据评估命中率:分布与线上不符。

追问

  • 写后立即读 miss 正常吗?答:旁路模式写后删缓存,下次读回填,首读 miss 属预期;连续 miss 才异常。
  • 哪些数据不该追求高命中?答:一次性访问、强一致易变数据,缓存价值低。

04.4.10.1-088 热 key 本地副本为什么要短有效期,过期与广播如何配合?

一句话结论

本地副本短 TTL 限制旧值窗口,变更时广播主动剔除;短 TTL 兜底广播丢失,广播保证及时失效,两者互补,避免本地副本长期陈旧。

概念解释

热 key 放本地是为省 Redis 访问,但本地副本更新滞后。有效期过长:变更后各实例旧值不一致;过短:本地层失去减负意义。配合方式:变更事件广播删本地,TTL 作为消息丢失兜底。热数据逻辑过期可异步刷新。副本失效粒度按对象键,列表类按标签/前缀。

原理流程

  1. 本地副本写入时设短 TTL。
  2. 数据变更发布广播事件,各实例删本地键。
  3. 广播未达时 TTL 到期自然清理。
  4. 热点条目可后台异步刷新保持新鲜。
  5. 监控本地命中率与旧值投诉。

代码或图示

本地副本:TTL 短 + 广播主动失效
广播丢失 → TTL 兜底;广播及时 → 缩短旧值窗口

常见误区

  • 本地副本与 Redis 同 TTL:两层旧值叠加,一致性窗口过长。
  • 只靠广播不设 TTL:消息丢失后本地旧值永久驻留。

追问

  • 热 key 本地副本会不会放大内存?答:热点数量可控时占用有限;条目多需权重限制,见容量治理题。
  • 广播事件顺序重要吗?答:变更先后顺序影响旧值覆盖,事件带版本号比对,旧事件不删新值。

04.4.10.1-089 大 key 删除为什么用 UNLINK,DEL 阻塞体现在哪?

一句话结论

DEL 同步释放大键内存,阻塞 Redis 单线程;UNLINK 把回收放到后台异步执行,命令立即返回,大键清理应优先 UNLINK。

概念解释

删除大集合时,释放内存涉及遍历与回收,耗时随元素数量增长。DEL 在命令执行内同步完成,期间其他命令排队。UNLINK 标记键并交给后台线程回收,主进程不阻塞。运维清理、迁移旧键都应评估用 UNLINK;小键 DEL 与 UNLINK 差异可忽略。

原理流程

  1. 识别待删大键(元素数/体积)。
  2. 大键使用 UNLINK 异步回收。
  3. 后台线程完成内存释放。
  4. 监控回收期间内存与命令延迟。
  5. 小键直接 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 内用稳定标识(主键),不含可变排序段。命名与键规则统一在构造函数中生成,避免手写不一致。

原理流程

  1. 梳理需要多键原子操作的键组。
  2. 组内键使用相同 {聚合根标识} tag。
  3. 独立键不加 tag,按键名自然分散。
  4. 键构造函数统一生成 tag 段。
  5. 上线前用槽位计算验证同组键落同槽。

代码或图示

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,消费者确认后删本地。

原理流程

  1. 失效事件携带键、类型、版本号。
  2. 订阅者收到后按版本比对再删本地。
  3. Pub/Sub 丢失由 TTL 自然收敛。
  4. 周期对账:比对缓存值与库数据版本,修正陈旧项。
  5. 高可靠链路用 MQ 持久化事件 + 消费确认。

代码或图示

补偿链:广播主动失效 → 本地 TTL → Redis TTL → 周期对账
事件字段:key / type / version / emitted_at

常见误区

  • 假设广播必达:Pub/Sub 无持久化与确认。
  • 旧事件后到误删新值:必须带版本号比对。

追问

  • 对账扫描成本高怎么办?答:按变更频率抽样,关键对象优先;增量版本比对优于全量扫描。
  • MQ 失效事件重复消费安全吗?答:删除操作幂等,重复消费无副作用;回填操作需版本保护。

04.4.10.1-092 多环境缓存如何隔离,键命名空间包含哪些隔离段?

一句话结论

不同环境(开发/测试/生产)与不同业务域通过键前缀隔离,避免共享实例串数据;环境段、业务段、类型段、标识段分层,配置中统一维护。

概念解释

Redis 实例常被多环境或多业务复用,无隔离会互相覆盖。键规则包含环境前缀(或使用独立实例/库号)、业务域、数据类型、主键。测试数据不能污染生产缓存。隔离段在键构造函数集中生成,禁止业务代码拼裸键。本地缓存同样按环境区分进程部署。

原理流程

  1. 配置定义环境标识与业务前缀。
  2. 键构造函数拼接环境/业务/类型/标识段。
  3. 共享实例分配独立逻辑库号或前缀段。
  4. 测试环境清理策略独立于生产。
  5. 监控按键前缀区分环境与业务指标。

代码或图示

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 内部类型。

原理流程

  1. 定义缓存 trait 与业务服务依赖。
  2. 测试构造内存替身实现。
  3. 用例编排:写入 → 读取 → 失效 → 断言状态。
  4. 验证回填与失效调用次数与键规则。
  5. 集成测试连接测试 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 超时/错误 → 限流直连库或返回本地/旧值;写路径:删缓存失败入重试队列,不阻塞主写。错误分类:连接/超时可重试,参数/配置错误告警不重试。兜底返回要标注降级,避免客户端误把旧值当最新数据。

原理流程

  1. 读缓存捕获错误,按类别决定重试或降级。
  2. 降级路径限流保护数据库,返回旧值/默认值。
  3. 写缓存失败入补偿队列,有限次重试。
  4. 错误按类别上报指标,日志保留上下文。
  5. 故障恢复后观察命中率与回源回落。

代码或图示

读:cache error → 重试(有限) → 直连库(限流) / 旧值 / 默认
写:delete fail → 补偿队列 → 重试 / 告警

常见误区

  • 缓存失败直接向上抛错:旁路缓存故障拖垮主业务。
  • 降级返回空值不标注:前端展示错误空白。

追问

  • 直连库限流阈值怎么定?答:按数据库可承受回源比例设置,核心接口优先放行。
  • 补偿队列放哪?答:应用内重试或外部 MQ;失败上限后告警人工介入。

04.4.10.1-095 什么场景用分布式 Redis 缓存,什么场景用本地缓存,如何组合?

一句话结论

跨实例共享、可重建的大对象用 Redis;高频小体积只读热点用本地缓存;组合架构按数据热度分层,强一致与权威数据不放入本地层。

概念解释

选型维度:共享性(是否跨实例一致)、体积、访问频率、一致性要求、可重建性。Redis:跨实例副本、对象较大、需集中治理。本地:延迟敏感、热点小对象、容忍短暂旧值。组合:本地一级、Redis 二级、数据库三级。不适合缓存的数据(强敏感、一次性访问)直接查库。

原理流程

  1. 评估数据共享性:必须跨实例一致 → Redis。
  2. 评估体积与频率:小体积高频 → 可加本地层。
  3. 评估一致性:强敏感 → 直查库或短缓存。
  4. 设计分层链路与失效策略。
  5. 压测验证各层命中率与回源边界。

代码或图示

Redis:共享副本、大对象、集中 TTL/淘汰治理
本地:  小体积热点、最低延迟、短 TTL + 广播
排除:  强一致权威数据、一次性访问、超大对象

常见误区

  • 所有数据都塞本地:内存失控且一致性差。
  • 本地缓存承担共享一致性:多实例副本无法保证。

追问

  • 两者容量如何分配?答:本地按进程内存预算小容量,Redis 按实例内存与条目规模规划。
  • 新系统先建哪层?答:先 Redis 旁路缓存跑通共享副本,热点明确后再加本地层。

04.4.10.1-096 穿透、击穿、雪崩三个概念如何区分,防护手段各对应什么?

一句话结论

穿透查不存在的数据绕过缓存打库;击穿是单热点键过期并发回源;雪崩是大面积键同时失效或缓存整体故障;防护分别是空值/布隆、互斥重建/单飞、TTL 抖动/分批预热/限流降级。

概念解释

三者都表现为回源升高,成因不同。穿透:数据不存在,缓存永远 miss,靠布隆过滤器与空值缓存拦截。击穿:热点存在,过期瞬间并发重建,靠 single flight/互斥锁/逻辑过期。雪崩:批量同时到期或 Redis 故障,靠 TTL 抖动、分批预热、多级缓存与限流降级。混淆概念会导致防护手段错位。

原理流程

  1. 判断回源请求对应数据是否存在:存在→击穿/雪崩;不存在→穿透。
  2. 单热点并发→击穿;大面积失效/整体故障→雪崩。
  3. 按类型套用防护:布隆/空值;单飞/锁;抖动/预热/降级。
  4. 监控三类征兆:无效查询量、单键并发回源、大面积 miss。
  5. 复盘防护缺口并补策略。

代码或图示

穿透:查无此数据 → 布隆过滤器 + 空值缓存
击穿:热点过期并发 → single flight / 重建锁 / 逻辑过期
雪崩:批量失效/故障 → TTL 抖动 + 预热 + 多级缓存 + 限流降级

常见误区

  • 用击穿手段防穿透:数据不存在,重建锁挡不住无效查询。
  • 只防单键过期:忽略整体故障降级,雪崩时数据库被打垮。

追问

  • 三者监控指标有何不同?答:穿透看无效查询占比;击穿看单键并发等待;雪崩看整体 miss 率与回源 QPS。
  • 恶意穿透如何应对?答:布隆 + 空值短 TTL + 频率限制;可疑请求接入安全防护。

04.4.10.1-097 缓存键过期与内存治理复盘:常见失控模式有哪些?

一句话结论

失控模式包括:无 TTL 永久驻留、TTL 整齐形成过期潮、大 key 占内存、淘汰策略不当、标签映射膨胀;治理靠 TTL 分级、抖动、大 key 拆分、容量监控与定期扫描清理。

概念解释

内存治理是持续工作。复盘维度:条目是否都有 TTL;TTL 是否分组抖动;大 key 是否拆分;淘汰策略是否匹配数据可重建性;辅助映射(标签、索引)是否清理。线上内存上涨时按大 key、长尾条目、映射膨胀排查,结合 INFO 与 SCAN 抽样定位。

原理流程

  1. 检查所有写入路径是否设置 TTL。
  2. 审查 TTL 分布,识别整齐到期与超长 TTL。
  3. 抽样大 key 与大集合,评估拆分。
  4. 核对淘汰策略与数据可重建性。
  5. 定期扫描清理过期辅助映射,监控内存水位。

代码或图示

失控清单:无 TTL / TTL 同批 / 大 key / 误淘汰策略 / 映射膨胀
治理:分级 TTL + 抖动 + 拆分 + 容量上限 + 定期扫描

常见误区

  • 只看总内存不看条目分布:大 key 与长尾条目被平均值掩盖。
  • 辅助映射不设过期:标签/索引集合无限增长。

追问

  • 内存碎片怎么判断?答:INFO 碎片率与内存分配比值;碎片过高结合淘汰与重启治理,具体以服务端文档为准。
  • 长尾条目如何识别?答:SCAN 抽样 TTL 与体积,结合访问频率统计找冷门大键。

04.4.10.1-098 Rust 项目中缓存方案如何分层落地,代码结构怎么组织?

一句话结论

分层为:业务服务编排缓存读写 → 缓存 trait 抽象 → Redis/本地实现 → 序列化与键规则组件;配置、指标、降级策略集中在实现层,业务代码不接触具体客户端类型。

概念解释

工程结构对应职责:服务层决定何时回源与回填;缓存 trait 定义存取与失效;实现层封装连接池、序列化、TTL、错误分类;键构造与序列化格式独立成组件。测试用替身实现 trait。配置按环境注入,指标统一埋点。这样更换缓存实现或加本地层不影响业务逻辑。

原理流程

  1. 定义缓存 trait(get/put/invalidate/批量)。
  2. 实现 Redis 后端:池、命令、序列化、键规则。
  3. 实现本地后端:moka 实例、权重/TTL、广播订阅。
  4. 服务层编排 miss → 回源 → 回填。
  5. 配置与指标横切注入,测试替身覆盖。

代码或图示

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);错误(无限重试、信息泄漏)。每条坑对应前述专题的防护做法,上线前按清单自查。

原理流程

  1. 连接层:核对运行时 feature、连接池配置与归还路径。
  2. 命令层:审查参数顺序、返回体积、阻塞命令。
  3. 数据层:TTL、键规则、版本前缀、大 key。
  4. 一致性:失效顺序、广播兜底、补偿重试。
  5. 错误层:分类重试、脱敏、指标告警。

代码或图示

踩坑清单:
  同步连接进 async 任务 / 未池化
  KEYS 全扫 / 大 DEL 阻塞
  事务当回滚 / 锁误删
  无 TTL / 序列化无版本
  错误无限重试 / 泄漏内部细节

常见误区

  • 同类坑在新代码重复出现:清单未进评审与 CI 检查项。
  • 踩坑只记现象不补机制:下次换个场景再犯。

追问

  • 清单如何落地到流程?答:接口评审对照清单,代码扫描检查裸命令与无 TTL 写入,压测覆盖故障场景。
  • 哪些必须在原型验证?答:集群路由、订阅传输、池化行为等版本敏感点,以 docs.rs 当前版本为准并标注待确认。

04.4.10.1-100 把 Redis 与本地缓存串成完整工程方案,包含哪些设计门禁?

一句话结论

完整链路:数据分级选型 → 多级缓存链路 → 键/序列化/TTL 规范 → 击穿穿透雪崩防护 → 失效一致性与广播兜底 → 监控压测与降级;每项在设计评审与 CI 中可检查,不依赖口头约定。

概念解释

本章从 redis-rs 连接、池化、命令与数据结构,到锁、Stream、缓存模式、一致性,再到 moka 本地缓存与多级治理。工程闭环:先按数据等级决定是否缓存与放哪层;再定键规则、序列化版本与 TTL;防护三类缓存问题;写路径保证失效与补偿;监控命中率、内存、连接与慢命令;压测覆盖故障降级。Rust 侧业务服务保持缓存抽象,实现可替换。

原理流程

  1. 分级:强敏感直查,可重建热点进缓存。
  2. 选型:本地一级、Redis 二级、数据库三级。
  3. 规范:键命名空间、版本前缀、序列化格式、TTL 分级。
  4. 防护:空值/布隆、single flight、TTL 抖动、预热降级。
  5. 运维:一致性广播兜底、指标监控、压测复盘、故障预案。

代码或图示

分级选型 → 多级链路 → 规范(键/格式/TTL) → 防护(穿透/击穿/雪崩)
  → 失效一致性 → 监控压测 → 降级预案 → 复盘改进

常见误区

  • 只接入缓存不做治理:命中率、内存与一致性问题滞后爆发。
  • 业务代码绑定具体客户端类型:后续加本地层或换实现成本高。

追问

  • 本章与后续章节如何衔接?答:消息队列可靠性与 Stream 替代方案见 04.4.10.2;后台异步刷新与定时任务见 04.4.10.3;指标上报见 04.4.12.1。
  • 哪些行为需标注待确认?答:redis-rs/moka 当前版本 API、feature 清单与池化配置,以 docs.rs 核实后固化,不凭记忆写死版本行为。