04.7.21.2 Redis 缓存与 Celery 任务队列
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.21 Python 后端常见搭配技术
覆盖范围
- redis-py 连接池、
decode_responses、超时与健康检查参数 - pipeline、MULTI/EXEC 事务、Lua 脚本原子性
- cache-aside / write-through / write-behind 缓存模式、key 设计与 TTL
- 缓存击穿、穿透、雪崩与布隆过滤器、缓存一致性
- 分布式锁:
SET NX PX、解锁脚本、续期、Redlock 争议 - Celery 架构:broker、worker、beat、backend;路由、优先级、幂等、去重
- 重试与退避、
acks_late、prefetch_multiplier、可见性超时、任务超时 - chain/group/chord、worker 并发模型、
max_tasks_per_child、beat 与时区 - 框架集成与
on_commit投递、flower 监控、积压排查与容量规划
04.7.21.2-001 redis-py 的连接池是怎么工作的?
一句话结论
redis-py 内部用 ConnectionPool 复用 TCP 连接:客户端从池里取连接执行命令,用完归还;默认按惰性方式创建连接,池大小可通过 max_connections 限制。多线程共享同一个池即可,不必每次新建 Redis 客户端;连接耗尽时按配置等待或抛连接异常。
概念解释
Redis客户端持有一个连接池,命令通过池借连接发出。- 连接复用减少 TCP 握手与认证开销;池参数需与 Redis 实例
maxclients协调。 - 生产一般在应用启动时创建客户端单例,请求层复用。
原理流程
- 创建
Redis(host=..., port=..., db=..., decode_responses=True),内部建池。 - 执行命令时从池取空闲连接,无空闲且未超上限则新建。
- 命令执行完连接归还池,供下次复用。
- 连接断开/超时由健康检查与重连机制处理。
代码或图示
import redis
pool = redis.ConnectionPool(
host="redis", port=6379, db=0,
decode_responses=True, max_connections=50,
)
client = redis.Redis(connection_pool=pool)
client.set("greeting", "hello")
常见误区
- 每个请求新建
Redis(...):连接无法复用,短时间打满 Redis 连接。 - 池大小设得比 Redis
maxclients还大:多实例叠加后被服务端拒绝连接。 - 把 redis 连接对象存进请求 Session 长期持有:应通过客户端单例取池连接。
追问
- 连接池满了会怎样?答:等待空闲连接,超时或按池配置抛
ConnectionError/连接超时异常。 - redis-py 版本基线?答:redis-py 5.x,API 与 4.x 基本兼容(待确认:5.x 弃用方法清单)。
- 哨兵/集群模式用什么客户端?答:
Sentinel连接池或RedisCluster,连接管理由对应类封装。
04.7.21.2-002 decode_responses 解决什么编码问题?
一句话结论
decode_responses=True 让 redis-py 返回 str 而非 bytes;默认 False 时所有值都是 bytes,直接与字符串比较/拼接会出错。写入与读取要保持同一编码配置,避免 bytes 与 str 混用导致类型错误或缓存键不一致。
概念解释
- Redis 存储的是字节串,客户端负责解码;默认按字节返回。
- 中文/UTF-8 内容需确认编码一致,解码失败会抛
UnicodeDecodeError。 - 混用
bytes键与str键可能在 Redis 中形成两个不同键。
原理流程
- 写入:Python 字符串按 UTF-8 编码为字节存入。
- 读取:
decode_responses=False返回原始bytes;True解码为str。 - 代码统一按一种类型取值,序列化/反序列化在应用层处理。
- 复杂结构(JSON、列表、哈希)在应用层
json.dumps/loads。
代码或图示
r = redis.Redis(host="redis", decode_responses=True)
r.set("user:1", '{"name": "ann"}')
raw = r.get("user:1") # str
data = json.loads(raw)
常见误区
- 一半代码按
str取值、一半按bytes比较:类型不一致,缓存命中判断失效。 - 存 JSON 还依赖客户端自动转对象:redis-py 不做 JSON 序列化,需手动 dumps。
- 解码假设所有值都是文本:二进制(图片、序列化字节)应保持
bytes处理。
追问
bytes类型怎么判等?答:b"hello" == "hello"为 False,必须统一解码或统一字节。- 哈希/列表返回值类型一致吗?答:受同一
decode_responses配置控制,容器内元素同步解码。 - 编码怎么指定?答:redis-py 默认 UTF-8,特殊编码需写入前自行编码(待确认:客户端编码参数名)。
04.7.21.2-003 连接超时与健康检查参数怎么配?
一句话结论
常用参数:socket_connect_timeout(建立 TCP 连接超时)、socket_timeout(命令读取超时)、health_check_interval(空闲连接周期性 ping)、retry_on_timeout(读/写超时是否重试)。生产应显式设置连接与命令超时,避免应用无限等待 Redis;慢命令要先在服务端定位。
概念解释
socket_timeout覆盖单条命令的等待,批量操作/大值读取要按业务调整。health_check_interval对空闲连接定期探活,类似数据库池的 pre-ping。- 重试只应对瞬时超时,业务写操作要考虑幂等。
原理流程
- 建立连接按
socket_connect_timeout控制握手。 - 命令发出后按
socket_timeout等待响应。 - 空闲连接超过间隔触发 health check,失效连接重建。
- 超时异常按业务分类:网络抖动重试,慢命令转排查。
代码或图示
r = redis.Redis(
host="redis",
socket_connect_timeout=2,
socket_timeout=2,
health_check_interval=30,
retry_on_timeout=True,
)
常见误区
- 不设超时:Redis 卡住时应用线程/协程无限阻塞,级联拖垮服务。
socket_timeout设过大:大 key 读取慢时掩盖问题,接口雪崩。- 盲目重试写命令:非幂等写入重复执行,需结合去重键。
追问
- health check 什么时候触发?答:连接被取出使用前,按间隔判断是否需要 ping,不是后台线程定时扫。
- 命令超时和连接超时能混为一谈吗?答:不能,前者是已建连接上的读写等待,后者是握手阶段。
- 慢命令怎么查?答:
SLOWLOG GET、LATENCY监控,定位大 key 与复杂命令。
04.7.21.2-004 pipeline 批量提交为什么快?它是事务吗?
一句话结论
pipeline 把多条命令打包,一次网络往返发送、批量接收结果,减少 RTT;默认 pipeline 不是事务,命令之间不保证原子执行,中途某条失败不回滚前面命令。需要原子性时用 MULTI/EXEC 包裹或 Lua 脚本。
概念解释
- 性能收益来自减少网络往返,而非服务端加锁。
- pipeline 内命令按顺序发送,结果按顺序取回。
- 与事务的区别:无回滚语义、无隔离保证、单条失败不影响已执行命令。
原理流程
- 进入 pipeline,命令先在客户端缓冲。
execute()时批量发送到 Redis。- 服务端逐条执行(非事务模式下),结果排队返回。
- 客户端按顺序取回结果列表。
代码或图示
pipe = r.pipeline()
pipe.set("k1", "v1")
pipe.incr("counter")
pipe.hset("h", mapping={"a": "1"})
results = pipe.execute() # 一次往返,返回三条命令结果
常见误区
- 以为 pipeline 批量执行就是事务:多命令之间仍可能被其他客户端插入。
- pipeline 内读取依赖前一条写入:非事务隔离下读到的是当前服务端状态,顺序执行保证但无锁隔离。
- 把超大批命令塞一个 pipeline:单次请求体过大、阻塞 Redis,应分批。
追问
- pipeline 怎么取结果?答:
execute()返回与命令顺序对应的结果列表;也可用execute(raise_on_error=False)收集错误。 - 事务型 pipeline 怎么开?答:
r.pipeline(transaction=True)内部用 MULTI/EXEC。 - 批量写哈希/列表适合 pipeline 吗?答:适合,多条 hset/lpush 合并往返;大 key 场景仍要控制体量。
04.7.21.2-005 MULTI/EXEC 事务与 pipeline 有什么区别?
一句话结论
MULTI/EXEC 把命令排队到事务队列,EXEC 时顺序原子执行,期间其他客户端命令不会插入;pipeline 只是网络批量发送。Redis 事务不支持回滚(入队/执行错误处理有限),也没有隔离级别的多版本并发控制;复杂原子逻辑优先用 Lua 脚本。
概念解释
- MULTI 之后命令进入队列,EXEC 触发一次性执行;DISCARD 放弃队列。
- 事务内命令出错(语法/类型)不回滚已成功命令(待确认:Redis 版本对事务错误的处理细节)。
- WATCH 提供乐观锁:监视键被改动则事务中止。
原理流程
MULTI开启事务状态,命令入队不立即执行。- 可选
WATCH key做乐观锁保护。 EXEC顺序执行队列命令,返回结果列表。- 任一命令在执行期失败,已执行命令不回滚。
代码或图示
pipe = r.pipeline(transaction=True)
pipe.watch("balance")
pipe.multi()
pipe.decrby("balance", 10)
pipe.incrby("frozen", 10)
pipe.execute()
常见误区
- 期待 Redis 事务像关系库一样回滚:Redis 不做失败回滚,错误需业务自行补偿。
- 用事务替代 Lua:多步条件判断、读写联动逻辑用脚本表达更可靠。
- WATCH 粒度太大:监视范围越广,冲突中止概率越高。
追问
- WATCH 解决什么问题?答:乐观检测关键键在事务期间是否被修改,被改则 EXEC 中止,避免覆盖并发更新。
- Redis 事务能保证隔离性吗?答:EXEC 期间命令连续执行,其他客户端不会插入,但不提供 RC/RR 式快照隔离。
- 事务内可以读键做判断吗?答:命令入队时不执行,读结果拿不到;条件判断应在脚本或事务外完成。
04.7.21.2-006 Lua 脚本为什么是原子执行的?
一句话结论
Lua 脚本在 Redis 单线程中整体执行,执行期间不会插入其他客户端命令,因此脚本内的多步读写天然原子;比 MULTI/EXEC 更适合带条件判断的复合操作。用 EVAL 直接传脚本,EVALSHA 传脚本哈希减少传输;脚本要短小,避免阻塞主线程。
概念解释
- Redis 事件循环单线程执行 Lua,脚本期间其他命令排队。
- 脚本原子性建立在「单线程不被抢占」上,不是加分布式锁。
- 长脚本/大循环会阻塞所有请求,需控制复杂度。
原理流程
EVAL提交脚本与键、参数;服务端编译并执行。- 执行期间独占事件循环,命令依次完成读写。
- 返回脚本结果;
EVALSHA命中缓存则不传源码。 - 脚本可通过
KEYS/ARGV接收参数,避免拼接注入。
代码或图示
# 余额充足才扣款,返回 1/0
script = """
if tonumber(redis.call('get', KEYS[1])) >= tonumber(ARGV[1]) then
redis.call('decrby', KEYS[1], ARGV[1])
return 1
end
return 0
"""
r.eval(script, 1, "balance", 10)
常见误区
- 脚本内大循环/遍历大 key:阻塞 Redis,拖垮所有客户端。
- 用字符串拼接参数进脚本:注入风险,参数走
ARGV。 - 把复杂业务全塞进 Lua:可维护性差,调试困难,逻辑尽量留在应用层。
追问
- EVALSHA 未命中怎么办?答:返回 NOSCRIPT 错误,客户端回退 EVAL 重新提交。
- Lua 脚本有超时限制吗?答:Redis 对脚本执行有配置层面的超时/阻塞保护,超长脚本会被中断(待确认:具体配置项与版本行为)。
- 脚本能调用随机命令吗?答:部分随机命令(如
SRANDMEMBER)结果不确定,复制模式下需注意(待确认:Redis 复制对非确定性命令的约束)。
04.7.21.2-007 cache-aside 模式的读写流程是什么?
一句话结论
cache-aside(旁路缓存):读时先查缓存,未命中查库并回填缓存;写时先更新数据库,再删除缓存(不是更新缓存)。它是 Web 最常用模式,缓存与库由应用代码显式维护,一致性靠删除策略与过期时间兜底。
概念解释
- 读路径:缓存 → 库 → 回填。
- 写路径:更新库 → 删缓存;下次读再从库重建。
- 删缓存而非更新缓存:避免并发写造成缓存旧值覆盖,且减少写时计算。
原理流程
- 读请求查 Redis,命中直接返回。
- 未命中查数据库,结果写入缓存并设 TTL。
- 写请求先提交数据库事务。
- 事务提交后删除对应缓存键;失败留待 TTL 过期或补偿任务修复。
代码或图示
def get_user(uid):
data = r.get(f"user:{uid}")
if data:
return json.loads(data)
user = db.query(User).get(uid)
r.setex(f"user:{uid}", 300, json.dumps(user.to_dict()))
return user
def update_user(uid, payload):
db.update(User, uid, payload)
r.delete(f"user:{uid}")
常见误区
- 写时更新缓存而非删除:并发顺序下容易留下旧值。
- 缓存未命中回填时不设 TTL:脏数据永久驻留。
- 删缓存在事务提交前执行:事务回滚后缓存已删/被其他请求回填旧值。
追问
- 为什么写后删而不是写后更新?答:并发写顺序不确定,更新缓存可能用旧值覆盖新值;删除让下次读重建。
- 缓存击穿在哪个环节?答:热点 key 过期瞬间,大量请求未命中查库。
- 读未命中回填失败怎么办?答:可缓存短 TTL 空值防穿透,或放行并记录告警。
04.7.21.2-008 write-through 与 write-behind 有什么区别?
一句话结论
write-through:写请求先写缓存层,由缓存层同步写库,写路径等待库完成才返回;一致性强但写延迟高。write-behind(write-back):先写缓存并标记异步落库,返回快,但宕机可能丢未刷盘数据,需要可靠队列与补偿。Web 业务多数用 cache-aside,这两种较少直接使用。
概念解释
- write-through 由缓存组件承担写库职责,应用不直接写库。
- write-behind 把落库延迟到后台,吞吐高,风险是缓存故障丢数据。
- 两者都要求缓存层有持久化/代理能力,纯应用层 Redis 不易实现严格语义。
原理流程
- write-through:应用写缓存 → 缓存同步写库 → 库确认 → 返回。
- write-behind:应用写缓存 → 标记脏 → 后台批量刷库 → 定时/容量触发。
- 后台落库失败需重试与告警;缓存重启要能恢复脏数据日志。
- 按一致性要求选择模式,不能为性能牺牲资金类数据安全。
代码或图示
write-through: app -> cache -> db(同步等待)
write-behind: app -> cache(标记脏)-> async writer -> db
常见误区
- 把 cache-aside 误称 write-through:cache-aside 写库由应用直接完成,缓存只是旁路。
- write-behind 无持久化兜底:Redis 宕机,未落库数据丢失。
- 资金/订单数据选 write-behind:一致性与丢数风险不可接受。
追问
- write-behind 怎么防丢?答:脏写记录到持久化队列/AOF,后台重试落库并对账。
- 什么场景适合 write-through?答:读多写少、要求缓存与库强一致、可接受写延迟的场景。
- 应用层能自己实现 write-behind 吗?答:可用本地队列+后台线程,但需处理崩溃恢复,复杂度接近独立存储层。
04.7.21.2-009 Redis key 怎么设计与命名?
一句话结论
key 用「业务:实体:标识」分层命名,单词小写、冒号分隔、不含空格与特殊字符;统一前缀便于按业务扫描与批量管理;值结构与过期时间成体系规划。避免超长 key、无业务前缀的裸键、把大对象序列化塞进单键。
概念解释
- 常见层级:
业务:类型:id,如order:detail:1001、cache:user:profile:88。 - 命名空间隔离环境/业务:多租户或多系统共用实例时前缀区分。
- TTL 按数据新鲜度分类,缓存键必须有过期时间。
原理流程
- 按业务域定义 key 规范与前缀。
- 标识用稳定主键,避免可变字段(如昵称)做键。
- 值选择合适结构:对象 JSON、计数 string、关联列表 list、标签集合 set、映射 hash。
- 配合
SCAN按前缀排查,禁止线上KEYS *。
代码或图示
user:profile:1001 # 用户资料
order:detail:20261119001 # 订单详情
lock:deduct:3001 # 分布式锁
seq:order:daily # 计数器
常见误区
- 用
KEYS扫描大库:阻塞主线程,线上必须用SCAN。 - key 里拼可变业务字段:改名/迁移时键无法对齐。
- 一个 key 存超大对象:大 key 拆分到 hash/list 并控制单元素体量。
追问
- 多环境怎么隔离 key?答:key 前缀区分 dev/staging/prod,或直接用不同 db/实例。
- 哈希结构和 JSON 对象怎么选?答:频繁按字段读写用 hash;整体读写、需序列化到前端用 JSON。
- 过期时间统一设还是分类设?答:按数据类型分类,热点/强新鲜度数据短 TTL,弱一致数据可长 TTL。
04.7.21.2-010 Redis 过期删除策略是怎样的?
一句话结论
Redis 采用「惰性删除 + 定期删除」组合:访问键时检查是否过期并删除(惰性);后台周期性抽样检查并清理过期键(定期)。过期键不会立刻从内存消失,未被访问时靠定期任务回收;内存紧张时再配合淘汰策略驱逐。
概念解释
- 惰性删除:读/写命中时判断 TTL,过期则删除并返回空。
- 定期删除:周期性抽样带 TTL 的键,清理过期项,控制循环时长。
- 淘汰策略(maxmemory-policy)在内存达上限时生效,与过期删除是两层机制。
原理流程
- 写入键时记录过期时间。
- 每次访问先检查 TTL,过期即删除。
- 后台定期任务抽样扫描过期键并清理。
- 内存不足时按淘汰策略驱逐非过期键。
代码或图示
访问触发:惰性删除
后台任务:定期抽样删除
内存上限:淘汰策略驱逐
常见误区
- 设了 TTL 就以为内存立刻释放:未访问的过期键仍占内存,靠定期任务回收。
- 大量过期 key 集中到期:定期删除压力与缓存雪崩叠加。
- 把过期删除和淘汰策略混为一谈:前者针对已过期键,后者在内存满时选择驱逐对象。
追问
- 怎么查看 key 剩余 TTL?答:
TTL key,返回剩余秒数;-1 无过期,-2 不存在。 - 过期键占内存高怎么处理?答:错峰设置 TTL、增加定期清理效率、检查是否有 key 漏设过期。
- Redis 持久化会保存过期键吗?答:RDB/AOF 加载时会过滤已过期键(待确认:各持久化模式过期键处理细节)。
04.7.21.2-011 缓存击穿怎么产生?怎么兜底?
一句话结论
击穿:某个热点 key 过期瞬间,大量并发请求同时未命中,全部压到数据库。兜底手段:热点 key 互斥重建(拿锁后由单线程查库回填,其他等待/返回旧值)、热点 key 不设物理过期(后台异步刷新)、提前预热与永不过期逻辑。
概念解释
- 击穿针对「单个热点 key」,与雪崩(大面积过期)、穿透(查不存在)区分。
- 互斥重建:第一个请求拿锁查库回填,后续请求短暂等待或读旧缓存。
- 逻辑过期:缓存存逻辑过期时间,后台线程刷新,请求不阻塞。
原理流程
- 热点 key TTL 到期。
- 并发请求同时查缓存未命中。
- 方案一:请求竞争重建锁,持锁者查库回填,其余等待后读缓存。
- 方案二:数据带逻辑过期标记,发现过期即触发异步刷新,先返回旧值。
代码或图示
def get_hot(key, rebuild):
val = r.get(key)
if val is None:
# 互斥重建:抢到锁才查库
if r.set(f"lock:{key}", "1", nx=True, px=3000):
val = rebuild()
r.setex(key, TTL, json.dumps(val))
else:
time.sleep(0.02)
val = r.get(key)
return val
常见误区
- 只加 TTL 不加重建保护:热点过期即数据库被打穿。
- 锁不设过期:持锁进程崩溃,锁永久占用。
- 等待自旋过久:下游线程堆积,应设等待上限与降级返回。
追问
- 击穿和雪崩区别?答:击穿是单热点 key 过期;雪崩是大量 key 同时过期或缓存节点故障。
- 热点数据刷新怎么做不阻塞?答:逻辑过期 + 异步线程刷新,读请求先返回旧值。
- 互斥锁用什么实现?答:
SET NX PX,解锁走 Lua 校验 owner。
04.7.21.2-012 缓存穿透怎么产生?怎么防?
一句话结论
穿透:查询数据库和缓存都不存在的数据(如非法 id、恶意请求),请求每次绕过缓存直击数据库。兜底:缓存空值(短 TTL)、布隆过滤器前置拦截、接口层参数校验与限流。穿透的对象是「不存在的数据」,与击穿的「存在但过期」不同。
概念解释
- 空值缓存:未命中库也写入空标记,短 TTL,防止反复查库。
- 布隆过滤器:在缓存前判断数据是否可能存在,不存在直接拒绝。
- 参数校验:非法格式、越界 id 在入口拦截。
原理流程
- 请求查缓存,未命中。
- 查数据库,记录不存在。
- 写入空值缓存(如
""/null,TTL 较短)。 - 后续相同请求命中空值,不再查库;布隆过滤器则在更前置位置拦截。
代码或图示
def get_user(uid):
if not valid_id(uid):
return None
raw = r.get(f"user:{uid}")
if raw is not None:
return None if raw == "" else json.loads(raw)
user = db.query(User).get(uid)
if user is None:
r.setex(f"user:{uid}", 60, "") # 空值短 TTL
else:
r.setex(f"user:{uid}", 300, json.dumps(user.to_dict()))
return user
常见误区
- 空值缓存 TTL 过长:错误数据长期占位,真实数据入库后读到空值。
- 布隆过滤器全量重建无预案:扩容/重启后穿透期数据库承压。
- 只靠缓存防穿透:恶意参数在入口不校验,过滤器与空值都被绕过。
追问
- 布隆过滤器误判是什么?答:判定存在可能误报(需再查库),判定不存在一定不存在。
- 空值缓存占空间吗?答:单条很小,但恶意枚举会产生大量空键,需配合限流与格式校验。
- 穿透攻击怎么限流?答:按 uid/IP 维度限频,异常流量接入 WAF 或降级拦截。
04.7.21.2-013 缓存雪崩怎么产生?怎么兜底?
一句话结论
雪崩:大量 key 同一时刻过期,或缓存节点整体故障,请求集中压向数据库。兜底:TTL 加随机抖动避免同时过期、缓存集群高可用(哨兵/集群/多副本)、数据库限流与降级兜底、热点数据预热与多级缓存。
概念解释
- 过期雪崩:TTL 批量相同,集中到期。
- 故障雪崩:Redis 节点宕机/网络分区,缓存整体不可用。
- 兜底链路:限流保护数据库、降级返回默认值、异步重建缓存。
原理流程
- 错峰 TTL:基础 TTL 上加随机秒数,打散过期时间。
- 缓存层高可用:主从+哨兵或集群,避免单点。
- 缓存不可用时,数据库入口限流,超阈值走降级响应。
- 服务恢复后按预热流程逐步回填缓存。
代码或图示
import random
def set_cache(key, value, base_ttl=300):
ttl = base_ttl + random.randint(0, 120)
r.setex(key, ttl, value)
常见误区
- 所有缓存用同一 TTL:高峰集中过期,数据库瞬时被打满。
- 缓存单点部署:节点故障即雪崩,无高可用兜底。
- 故障时不限流:数据库被并发请求压垮,缓存恢复后业务仍不可用。
追问
- 雪崩和击穿怎么区分?答:雪崩是大范围/整体失效,击穿是单个热点过期。
- 多级缓存是什么?答:本地缓存(进程内)+ Redis,本地挡一部分重复读,Redis 故障时降级。
- 缓存预热怎么做?答:上线/重启后主动加载热点数据,避免冷启动全部回源。
04.7.21.2-014 布隆过滤器原理与误判率怎么理解?
一句话结论
布隆过滤器用多位数组 + 多个哈希函数标记元素:加入时把对应位置 1;查询时所有位为 1 才「可能存在」,任一为 0 则「一定不存在」。特点是存在误报(可能存在但实际没有),不存在漏报(判定不存在就一定没有);误判率随位数与哈希数调整。
概念解释
- 空间效率高,适合海量数据的前置存在性判断。
- 不支持删除元素(普通布隆过滤器);计数布隆过滤器支持删除(待确认:实现库与限制)。
- 数据集合要可枚举/可预热,动态新增需持续加入过滤器。
原理流程
- 初始化位数组,选定 k 个哈希函数。
- 元素加入:k 个哈希位置置 1。
- 查询:k 位全 1 → 可能存在(回源查库确认);有 0 → 拒绝。
- 误报率随填充率上升,需预留空间或定期重建。
代码或图示
# 伪代码示意;生产可用已实现的布隆过滤器库
# bf.add(uid);bf.exists(uid)
常见误区
- 以为布隆过滤器能返回数据:它只回答「可能存在/一定不存在」,不存值。
- 过滤器不随业务数据更新:新入库数据被误判不存在,形成新的穿透。
- 误报当成精确判断:命中后仍要查缓存/库确认。
追问
- 怎么降低误判率?答:增大位数组、调整哈希函数数量,控制元素填充率。
- 布隆过滤器能删除吗?答:标准实现不能;需要删除用计数布隆过滤器或定期重建。
- Redis 有原生布隆过滤器吗?答:Redis Stack/Module 提供布隆过滤器类型,普通开源版需应用层实现(待确认:当前模块可用性)。
04.7.21.2-015 缓存与数据库一致性怎么保证?延迟双删是什么?
一句话结论
cache-aside 下推荐「先更新数据库,再删除缓存」;并发读写的小概率窗口用延迟双删兜底:更新库后删一次缓存,延迟一小段时间再删一次,覆盖读旧库回填旧缓存的并发窗口。最终一致靠 TTL 兜底;强一致要求高的场景需读写加锁或接受读旧值。
概念解释
- 并发窗口:线程 A 读旧库回填缓存,线程 B 更新库并删缓存,A 的旧值可能晚一步写回。
- 延迟双删:第二次删除在读完回填之后执行,清掉旧值。
- 删除失败可靠消息队列/重试任务补偿,不能静默丢弃。
原理流程
- 写事务更新数据库并提交。
- 第一次删除缓存键。
- 延迟数百毫秒到秒级(覆盖读库时长)后第二次删除。
- 仍不一致的数据由 TTL 过期自然修复。
代码或图示
def update(uid, payload):
db.update(User, uid, payload)
r.delete(f"user:{uid}")
# 延迟双删:异步任务或消息触发
schedule(lambda: r.delete(f"user:{uid}"), delay=0.5)
常见误区
- 先删缓存再更新库:删缓存后、库提交前的读请求回填旧值。
- 延迟双删不设兜底:第二次删除失败,旧值残留到 TTL 到期。
- 要求缓存与库实时强一致:旁路缓存做不到,需事务/锁或专用一致性方案。
追问
- 删除缓存失败怎么补偿?答:记录失败键,重试队列/定时任务扫描重删,监控删除失败率。
- 读写并发还有哪些方案?答:延迟双删、订阅 binlog 异步删缓存、读写短锁;按业务一致性等级选择。
- 什么数据不适合缓存?答:强实时、频繁变更、一致性要求极高的资金/库存扣减路径。
04.7.21.2-016 Redis 内存淘汰策略有哪些?怎么选?
一句话结论
maxmemory-policy 决定内存达上限时的驱逐行为:noeviction(不淘汰,写报错)、allkeys-lru(所有键按 LRU 淘汰)、allkeys-lfu、volatile-lru(仅设过期键)、volatile-lfu、volatile-random、allkeys-random、volatile-ttl(优先淘汰短 TTL)。纯缓存场景常用 allkeys-lru/allkeys-lfu;存持久化/任务状态的键用 noeviction 避免误删。
概念解释
- LRU 淘汰最近最少使用;LFU 按访问频率;Redis 实现为近似 LRU/LFU。
volatile-*只在设置了 TTL 的键中淘汰,未设过期的键受保护。- 淘汰与过期删除是两层:前者内存满触发,后者键到期触发。
原理流程
- 设置
maxmemory上限与淘汰策略。 - 写入导致内存接近上限,按策略选择候选键驱逐。
- 缓存型实例优先淘汰冷数据;状态型实例禁止淘汰。
- 监控内存使用率与驱逐次数,容量不足时扩容而非依赖淘汰。
代码或图示
allkeys-lru # 纯缓存:全库按 LRU
volatile-lru # 混有持久键:只淘汰带 TTL 的缓存键
noeviction # 不淘汰,内存满则拒绝写入
常见误区
- 把任务结果/分布式锁存进
allkeys-lru实例:冷下来被驱逐,锁失效、任务状态丢失。 - 只设
maxmemory不配策略:默认行为随版本,需显式确认(待确认:各 Redis 版本默认策略)。 - 依赖淘汰保护数据:淘汰不可控,持久状态必须落数据库。
追问
- LFU 适合什么数据?答:热点明显、访问频率差异大的缓存,按频率淘汰比按时间更合理。
- 淘汰键会通知客户端吗?答:默认不通知,业务不能假设被删事件;需要监听用 keyspace 通知(待确认:可靠性边界)。
- 内存碎片影响上限吗?答:碎片使实际占用高于数据量,需关注
mem_fragmentation_ratio。
04.7.21.2-017 分布式锁怎么用 SET NX PX 实现?解锁为什么要 Lua?
一句话结论
加锁用 SET key value NX PX 毫秒:NX 保证只有键不存在时写入,PX 设置自动过期防死锁;value 存唯一 owner 标识(UUID)。解锁必须用 Lua 脚本:先比对 owner,匹配才删除,避免误删他人持有的锁。比对与删除在脚本内原子完成。
概念解释
NX:键已存在则设置失败,保证互斥。PX:过期时间兜底,持锁进程崩溃也能自动释放。- owner 标识:防止业务执行超时后锁被自动释放,另一个进程拿到锁,原进程回来误删新锁。
原理流程
- 生成唯一 token 作为 value。
SET lock:<biz> <token> NX PX 30000,成功即持锁。- 业务执行;超时未完成需续期(看门狗)。
- 解锁 Lua:
if get == token then del,原子校验+删除。
代码或图示
LOCK = f"lock:{biz}"
token = str(uuid.uuid4())
ok = r.set(LOCK, token, nx=True, px=30000)
unlock_script = """
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
end
return 0
"""
r.eval(unlock_script, 1, LOCK, token)
常见误区
- 解锁直接
DEL key:锁已过期被他人持有,删的是新锁。 - 加锁不设过期:进程崩溃/网络异常导致死锁,业务永久阻塞。
- value 用固定值:无法区分 owner,误删不可避免。
追问
- 锁过期但业务没跑完怎么办?答:看门狗后台续期,或缩小临界区;续期机制见下一题。
NX和XX区别?答:NX键不存在才写;XX键存在才写,加锁用 NX。- 加锁失败怎么处理?答:短暂退避重试,超过次数放弃并告警;不要无限自旋。
04.7.21.2-018 锁过期但业务未完成怎么续期?
一句话结论
临界区执行时间可能超过锁 TTL 时,需要看门狗(watchdog)机制:持锁期间后台线程按间隔检查业务是否完成,未完成则在 owner 校验下延长过期时间;业务结束停止续期。续期同样要校验 owner,且续期线程崩溃要有兜底(锁最终过期释放)。
概念解释
- 典型实现参考 Redisson 看门狗:默认锁 TTL 30 秒,每 10 秒续期到 30 秒(参数为库默认值,待确认:Redisson 当前默认值)。
- 纯 redis-py 需自行实现后台续期协程/线程。
- 续期不是无限延长:进程异常退出后续期停止,锁最终过期。
原理流程
- 加锁时设定基础 TTL。
- 启动续期任务:间隔小于 TTL 的三分之一。
- 每次续期校验 owner 后
PEXPIRE延长。 - 业务完成/异常退出,停止续期并解锁;进程崩溃则靠 TTL 释放。
代码或图示
# 伪代码:后台续期线程
def renew(lock_key, token, ttl=30000, interval=10000):
while not done.is_set():
time.sleep(interval / 1000)
if r.eval(check_script, 1, lock_key, token):
r.pexpire(lock_key, ttl)
常见误区
- 续期不校验 owner:锁已易主还延长他人锁。
- 续期间隔大于 TTL:中途锁过期,互斥失效。
- 把长临界区依赖续期兜底:应先拆分业务、缩短事务,续期只是补救。
追问
- 看门狗在任务进程里跑,进程挂了怎么办?答:续期停止,锁按 TTL 自动释放,不会永久死锁。
- 续期失败要不要告警?答:要,续期失败可能意味着锁已丢失,临界区存在并发风险。
- 分布式锁适合长事务吗?答:不适合,长临界区锁竞争与续期复杂度高,优先业务拆分。
04.7.21.2-019 Redlock 算法是什么?有哪些争议?
一句话结论
Redlock 是 Antirez 提出的多节点分布式锁算法:向 N 个独立 Redis 节点依次加锁,多数(N/2+1)成功且总耗时小于锁 TTL 才算持锁成功。争议集中在时钟漂移、进程暂停(GC/调度)导致锁过期后仍被使用、以及多数派假设在故障场景下的安全性;工程上对正确性要求极高的场景需谨慎评估。
概念解释
- 单节点锁存在主从切换丢锁窗口;Redlock 用多节点多数派降低单点风险。
- 批评观点:分布式锁安全性依赖 fencing token(递增序号)配合资源侧拒绝旧锁,Redlock 本身不解决资源侧并发。
- 争议来自 Martin Kleppmann 与 Antirez 的公开讨论,结论是锁只能降低并发概率,不能替代资源层防护。
原理流程
- 客户端记录开始时间,依次向 N 个节点
SET NX PX。 - 统计成功节点数,达到多数派且耗时未超 TTL 视为持锁。
- 业务执行;释放时向所有节点发解锁脚本。
- 时钟跳变、进程长时间暂停可能让锁过期而客户端仍在操作。
代码或图示
5 节点:成功 ≥3 个,且总耗时 < TTL → 持锁
释放:向 5 个节点分别执行 owner 校验删除
常见误区
- 以为 Redlock 提供强互斥:进程暂停/时钟问题下仍可能双持锁。
- 不引入 fencing token:资源侧无法拒绝过期锁的写入。
- 为了 Redlock 部署多套 Redis:成本与运维复杂度上升,多数业务单节点+TTL+owner 已够用。
追问
- 什么是 fencing token?答:每次持锁生成递增序号,资源存储校验序号,旧序号写入被拒绝,从资源层防并发覆盖。
- 单节点主从切换会丢锁吗?答:会,锁在主节点未落从库时主从切换,新主无锁记录。
- 工程上怎么选?答:低风险业务用单节点 Redis 锁;高风险用数据库乐观锁/条件更新 + fencing,Redlock 按团队评估。
04.7.21.2-020 Redis 分布式锁和数据库悲观锁怎么选?
一句话结论
Redis 锁性能高、适合短时互斥与限流排队,但不提供强持久保证;数据库悲观锁(SELECT ... FOR UPDATE)依托事务行锁,一致性强但吞吐低、持有时间受限。资金扣减、库存一致性优先数据库条件更新/乐观锁;短时任务排队、防重复提交用 Redis 锁。
概念解释
- Redis 锁:内存操作,快;风险是过期、主从切换、进程暂停导致双持。
- DB 悲观锁:锁随事务释放,有死锁检测与回滚;并发高时锁等待堆积。
- 很多「锁」场景本质可用条件更新
WHERE status='pending'替代显式锁。
原理流程
- 判断业务一致性等级:强一致优先数据库。
- 短时互斥、防重、限流:Redis 锁。
- 关键写路径:数据库唯一约束/条件更新兜底,Redis 锁只做前置排队。
- 两层结合:Redis 挡并发洪峰,数据库约束保证最终正确性。
代码或图示
-- 条件更新替代显式锁
UPDATE stock SET count = count - 1
WHERE sku = ? AND count > 0;
-- 影响行数 0 即扣减失败
常见误区
- 关键一致性只靠 Redis 锁:锁失效时直接产生超卖/重复扣款。
- 长临界区用 DB 悲观锁:锁等待拉长,吞吐骤降。
- 把缓存锁当分布式事务:锁互斥不等于多步操作原子提交。
追问
- 防重复提交用什么?答:Redis 锁/唯一请求键 + 数据库唯一索引双重兜底。
- 乐观锁和悲观锁怎么选?答:冲突少用乐观锁版本列;冲突激烈、临界区短用悲观锁。
- 锁超时时间设多少?答:按业务 P99 执行时间估,留余量;宁可重试不要过长持锁。
04.7.21.2-021 broker/worker/beat/backend 各是什么职责?
一句话结论
broker 是消息中间件,接收并路由任务消息;worker 是执行任务的进程池,从 broker 拉取并运行;beat 是定时调度器,按计划把周期任务投递到 broker;backend(result backend)存储任务执行结果与状态,供查询。四者解耦:生产者只投递,消费者异步执行。
概念解释
- 生产者:应用代码调用
task.delay()/apply_async(),消息进 broker。 - worker:并发执行任务,可按队列分组扩容。
- beat:单实例运行定时调度,多实例需防重复触发。
- backend:可选,存返回值/异常/状态;不需要结果可关闭以减负。
原理流程
- beat 到点或生产者调用任务,消息投递 broker。
- worker 监听对应队列,拉取任务执行。
- 执行结果写入 backend(配置了才写)。
- 生产者/监控系统从 backend 或 flower 查询状态。
代码或图示
app -> broker(RabbitMQ/Redis) <- worker 执行
beat -> broker
worker -> backend(结果存储)
常见误区
- 把 backend 当 broker:结果存储不承担任务投递,职责不同。
- beat 多实例同时跑:定时任务被重复投递,需选主或单点部署。
- 不需要结果还开 backend:浪费存储,任务结果应配置过期清理。
追问
- Celery 版本基线?答:Celery 5.x,命令行与配置延续 4.x 迁移后的约定。
- worker 宕机任务会丢吗?答:取决于确认模式与 broker 持久化,
acks_late下任务会重新投递。 - 一个任务能跨多个 worker 协作吗?答:单任务由一个 worker 进程执行;协作靠 chain/group 组合多个任务。
04.7.21.2-022 broker 选 RabbitMQ 还是 Redis?
一句话结论
RabbitMQ 功能完整:路由 exchange、ack、死信、重试队列、持久化成熟,适合任务可靠性要求高、路由复杂的场景;Redis 作 broker 部署简单、与缓存栈复用,但消息能力较薄(无 exchange 路由、可见性/重试机制受限),适合轻量异步任务。结果 backend 用 Redis 很常见。
概念解释
- RabbitMQ:AMQP 协议,队列/交换器/死信队列,消息确认精细。
- Redis broker:用 list/stream 存消息,依赖 key 过期与 ack 机制,复杂重试需自己实现。
- 选型看:可靠性要求、路由复杂度、运维栈、消息积压容忍度。
原理流程
- 评估任务量级、可靠性、重试/死信需求。
- 高可靠/复杂路由 → RabbitMQ;简单异步/已有 Redis 栈 → Redis。
- broker 持久化与确认模式按可靠性配置。
- 迁移时消息格式与队列定义先在预发验证。
代码或图示
app.conf.broker_url = "amqp://user:***@rabbit:5672//"
# 或
app.conf.broker_url = "redis://redis:6379/1"
app.conf.result_backend = "redis://redis:6379/2"
常见误区
- 用 Redis broker 期待 RabbitMQ 级死信路由:能力缺失,异常任务处理要自行补偿。
- broker 与 backend 混用一个 Redis db:任务消息和结果互相干扰,建议分 db/实例。
- 小任务集群上 RabbitMQ 不做镜像/仲裁队列:单点故障丢消息。
追问
- Redis Stream 能替代 RabbitMQ 吗?答:可做轻量消息队列,消费组/ack 能力有限,复杂路由与死信仍不如 RabbitMQ。
- broker 消息积压怎么处理?答:扩容 worker、拆分队列、限流生产者; broker 侧监控队列深度。
- 任务消息需要持久化吗?答:可靠性要求高的场景开启消息持久化与手动 ack。
04.7.21.2-023 任务路由和队列怎么配置?
一句话结论
通过 task_routes 把任务按名称/规则分配到不同队列,worker 用 -Q 指定消费队列。大任务、慢任务、高优任务分队列隔离,避免互相阻塞;队列名在配置中声明,路由规则可按任务名前缀或正则匹配。
概念解释
- 默认队列:
celery,未路由的任务进默认队列。 - 路由键:AMQP 下对应 routing key;Redis broker 直接按队列名投递。
- 队列隔离:IO 密集、CPU 密集、定时任务各用独立队列与 worker 池。
原理流程
- 定义队列与路由规则:任务名 → 队列名。
apply_async(queue=...)可单次覆盖路由。- worker 启动
-Q queue_a,queue_b消费指定队列。 - 监控各队列深度,按队列扩容对应 worker。
代码或图示
app.conf.task_routes = {
"tasks.notify_*": {"queue": "notify"},
"tasks.export_*": {"queue": "export"},
}
# worker: celery -A app worker -Q export -c 4
常见误区
- 所有任务挤默认队列:慢任务堵住快任务,整体响应变差。
- 路由规则与 worker 监听队列不一致:任务投递后无人消费,形成积压。
- 队列只增不治理:长期空队列与僵尸任务名应清理。
追问
- 任务能指定交换机/routing key 吗?答:RabbitMQ broker 下可配置 exchange 与 routing key,Redis broker 不支持复杂交换。
- 队列优先级怎么实现?答:RabbitMQ 用优先级队列;Celery 层面可分高/低队列分别消费。
- 一个 worker 能消费多个队列吗?答:能,
-Q逗号分隔;注意各队列任务量与 worker 并发匹配。
04.7.21.2-024 队列优先级怎么安排?
一句话结论
工程上常用多队列映射优先级:高优任务进 high 队列,独立 worker 池优先消费;普通任务进默认队列;低优后台任务进 low 队列,worker 空闲时才拉取。底层 RabbitMQ 支持消息优先级队列,Redis broker 不具备原生优先级,靠队列分组与消费速度实现。
概念解释
- 优先级隔离:高优队列 worker 不被低优任务占用。
- 低优队列可限制并发,避免抢占资源。
- 优先级规则要结合 SLA:用户交互类 > 通知类 > 报表导出类。
原理流程
- 按业务 SLA 划分高/中/低队列。
- 高优队列分配独立 worker 与充足并发。
- 低优队列worker 数少或限速,高峰时段可暂停消费。
- 监控各队列等待时长,动态调整 worker 分配。
代码或图示
celery -A app worker -Q high -c 8
celery -A app worker -Q default -c 4
celery -A app worker -Q low -c 2
常见误区
- 把所有任务标成高优:优先级失去意义,资源竞争依旧。
- 低优任务无限制消费:导出/报表任务高峰抢占在线任务资源。
- 期望单队列内严格优先级:需 broker 原生优先级支持,否则只能分队列。
追问
- RabbitMQ 优先级队列有代价吗?答:优先级排序占用服务端内存与 CPU,队列过长时排序开销上升。
- 低优任务被饿死怎么办?答:监控低优队列等待时间,空闲期补充 worker 或定期放行。
- 任务紧急程度运行时可变吗?答:可在投递时按参数选队列;执行中不跨队列迁移。
04.7.21.2-025 任务幂等怎么设计?去重键怎么选?
一句话结论
幂等任务:重复执行多次结果与一次相同。设计上用业务唯一标识(订单号、操作流水号)作为去重键,执行前查去重表/缓存:已处理直接返回;处理中加锁防并发重复;结果落库后记录状态。broker 重投、人工重跑、超时重试都不应产生重复副作用。
概念解释
- 去重键:稳定业务 ID,不含时间戳/随机数。
- 状态机:待处理 → 处理中 → 成功/失败,重复投递按状态分流。
- 副作用操作(发通知、扣款、写外部系统)必须可识别重复。
原理流程
- 任务入队前/执行首步生成或接收业务唯一键。
- 查去重记录:成功则直接返回;处理中则等待或退出。
- 执行业务,成功后写入去重记录与结果。
- 重试/重跑命中已有记录,跳过副作用。
代码或图示
@app.task(bind=True)
def send_notice(order_id):
if DedupRecord.exists(order_id, "notice"):
return "duplicate"
mark_processing(order_id)
# 外部副作用
notify(order_id)
mark_done(order_id)
常见误区
- 去重键用任务 ID:broker 重投生成新消息 ID,挡不住重复。
- 只在缓存去重:缓存过期/丢失后重复执行,关键路径要落库去重表。
- 幂等只防重试,不防并发重复:同一键两个 worker 同时进入需处理中状态/锁。
追问
- 去重记录保留多久?答:按业务回溯周期设置,过期清理;资金类长期保留。
- 任务部分成功怎么算幂等?答:步骤级幂等 + 状态记录,失败从断点续跑,不从头重复副作用。
- 外部接口本身不幂等怎么办?答:本地生成请求单号传外部做幂等,或对账补偿。
04.7.21.2-026 Celery 重试怎么配?退避策略怎么写?
一句话结论
任务内 self.retry(exc=..., countdown=...) 主动重试;类装饰器 autoretry_for=(Exception,) 自动捕获并重试;max_retries 限制次数,backoff=True 开启指数退避,retry_backoff_max 限制上限。重试要区分可重试错误(瞬时故障)与不可重试错误(参数/校验失败)。
概念解释
countdown:下次执行延迟秒数;指数退避按 2^n 增长。autoretry_for:匹配异常类型自动重试,避免每个任务手写 try/except。- 重试任务重新进 broker 队列,不等于在原进程内循环。
原理流程
- 任务执行抛可重试异常。
- 达到重试条件:记录重试次数,按退避时间重新入队。
- 次数未超:worker 稍后再次拉取执行。
- 超过
max_retries:异常抛到 backend,进入失败处理/告警。
代码或图示
@app.task(
bind=True,
autoretry_for=(ConnectionError, TimeoutError),
retry_backoff=True,
retry_backoff_max=300,
max_retries=5,
)
def notify(self, order_id):
try:
call_external(order_id)
except ExternalFatal:
raise # 不重试
常见误区
- 所有异常都重试:业务校验失败也反复执行,浪费资源并放大错误。
- 退避无上限:故障期间重试间隔无限增长,恢复后任务长期排队。
- 重试不打指标:重试次数/失败率不可见,无法判断下游健康。
追问
retry_kwargs能覆盖什么?答:重试时的 countdown、headers、eta 等参数。- 重试任务还走原队列吗?答:默认同队列;可在
retry/apply_async指定路由。 - 怎么区分可重试异常?答:自定义异常基类,瞬时故障继承可重试基类, fatal 异常独立类型。
04.7.21.2-027 什么是重试风暴?怎么设置重试预算?
一句话结论
重试风暴是下游故障时,上游任务层层重试放大流量,导致 broker 积压、下游更难恢复。重试预算:限制单位时间重试占比、设置总重试次数与退避上限、熔断后停止重试;监控重试消息比例,超阈值触发降级,而不是无限重跑。
概念解释
- 放大链条:任务失败 → 重试 → 重试再失败 → 二次重试,消息量指数增长。
- 预算思路:重试消息不得超过新消息一定比例,超出后直接失败入死信/人工处理。
- 退避抖动避免大量任务同时醒来再冲击下游。
原理流程
- 故障发生,首批任务失败。
- 按策略重试,退避间隔加随机抖动。
- 统计重试消息占比与队列深度,超预算阈值熔断。
- 熔断期间新失败任务直接标记失败/转补偿,不再重试。
代码或图示
# 退避加抖动
retry_backoff=True,
retry_backoff_max=300,
max_retries=4,
# 监控:retry_count / task_count 超阈值告警并降级
常见误区
- 固定短间隔重试:任务同时醒来,集中冲击恢复中的下游。
- 多层服务各自重试:叠加后重试倍数相乘,放大更严重。
- 重试无死信出口:失败任务反复复活,积压无法清理。
追问
- 熔断在哪一层做?答:调用外部依赖的客户端层 + 任务投递层,结合下游健康状态。
- 重试任务失败记录在哪?答:backend 与日志;超过次数转死信队列/补偿表。
- 恢复后积压怎么消化?答:限流逐步消费,避免一次性打垮下游;低优任务延后处理。
04.7.21.2-028 acks_late 语义是什么?有什么副作用?
一句话结论
acks_late=False(默认):任务取出即确认,worker 执行崩溃任务丢失;acks_late=True:任务执行完成后才 ack,worker 崩溃/被杀时 broker 重新投递,可能重复执行。副作用是重复消费,任务必须幂等;长时间运行的任务在 acks_late 下崩溃恢复后重跑。
概念解释
- ack:向 broker 确认消息已处理,确认后 broker 不再保留。
- 早 ack:防重复投递,但丢任务;晚 ack:防丢任务,但可能重复。
- 可靠性与幂等必须配套:晚 ack 场景下重复执行是常态而非异常。
原理流程
- worker 拉取任务。
acks_late=False:立即 ack,执行失败/崩溃不重投。acks_late=True:执行成功后 ack;进程崩溃,消息未 ack,broker 重新入队投给其他 worker。- 重复执行由幂等逻辑拦截副作用。
代码或图示
app.conf.task_acks_late = True
# 或任务级
@app.task(acks_late=True)
def process(...): ...
常见误区
- 开
acks_late但任务不幂等:崩溃重跑导致重复扣款/重复通知。 - 以为晚 ack 就不会丢消息:broker 持久化、节点故障仍可能丢,需综合配置。
- 长任务晚 ack 被多次重投:处理中状态超时后重复进入,需去重保护。
追问
acks_on_failure_or_timeout是什么?答:任务失败/超时是否确认消息;晚 ack 体系下控制失败任务是否重投(待确认:当前版本默认值与行为)。- worker 被杀(SIGKILL)能恢复任务吗?答:晚 ack 下 broker 重投;早 ack 则丢失。
- 怎么验证重复执行?答:日志带去重键,观察同一键多次执行记录。
04.7.21.2-029 prefetch_multiplier 怎么影响调度公平性?
一句话结论
prefetch_multiplier(默认 4)决定每个 worker 进程预取的任务数;预取越多吞吐越高,但长任务会把短任务「囤」在进程本地,导致队列空闲而本地任务排队,公平性下降。CPU/IO 混合任务调低(1–2),同构短任务可适当调高;配合 acks_late 理解任务所有权。
概念解释
- 预取:broker 一次推多个任务到 worker 本地内存。
- 囤任务问题:某 worker 拿到长任务,其他短任务留在本地队列,其他 worker 空闲。
- 公平调度:低预取让任务在 worker 间更均匀分发。
原理流程
- broker 按 multiplier 向空闲 worker 推送任务。
- worker 逐个执行;本地未执行完的任务不回流。
- 任务时长差异大时,低预取减少本地排队。
- 压测不同 multiplier 下的队列等待时间与吞吐。
代码或图示
app.conf.worker_prefetch_multiplier = 1
# 命令行:celery -A app worker --prefetch-multiplier 2
常见误区
- 预取越大越好:长任务囤积短任务,整体 P95 恶化。
- 混合任务不调预取:慢任务拖累快任务响应。
- 忽略 prefetch 与 acks_late 配合:崩溃时本地未 ack 任务重新投递。
追问
- 默认值是多少?答:Celery 默认
worker_prefetch_multiplier=4。 - 单 worker 并发数和预取什么关系?答:并发数决定同时执行几个;预取决定缓存多少待执行。
- 怎么判断预取过大?答:队列有积压但部分 worker 空闲,本地任务排队指标上升。
04.7.21.2-030 可见性超时是什么?为什么会重复消费?
一句话结论
可见性超时:消息投递给 worker 后,在超时时间内对其他消费者不可见;worker 未 ack 且超时,消息重新可见并被再次投递。超时时间小于任务执行时长时,任务还在跑消息就被重投,形成并发重复消费。需把可见性超时设为大于任务 P99 执行时长,并依赖幂等兜底。
概念解释
- RabbitMQ:消息投递后未 ack,连接断开才重投;Redis broker/Stream 有自己的可见性/PEL 机制。
- 超时设置过短:长任务被重复派发;过长:worker 崩溃后消息恢复延迟。
- 重复消费窗口:原任务与重投任务并发执行,风险高于串行重试。
原理流程
- 消息投递给 worker,进入不可见状态。
- 执行超过可见性超时仍未 ack。
- 消息重新可见,被另一个 worker 拉取。
- 两个实例并发执行同一任务,幂等键拦截重复副作用。
代码或图示
任务执行 120s,可见性超时 60s
→ 60s 时消息重投,两个 worker 并发跑同一任务
常见误区
- 可见性超时按平均执行时间设:长尾任务必然超时重投,应按 P99/P999。
- 重复消费只靠晚 ack 理解:broker 层可见性超时是另一道机制。
- 长任务心跳不更新:部分 broker 依赖心跳判断存活,超时判定误触发。
追问
- RabbitMQ 有可见性超时吗?答:RabbitMQ 靠 ack/连接断开重投,无固定超时;Redis broker/Stream 的 pending 消息有 reclaim 机制(待确认:各 broker 超时参数名)。
- 任务执行中怎么续期可见性?答:部分 broker 支持心跳/延长不可见时间;长任务应拆分或上调超时。
- 并发重复怎么发现?答:同一去重键同时出现在两个 worker 日志,处理中状态冲突告警。
04.7.21.2-031 soft_time_limit 与 time_limit 区别?
一句话结论
soft_time_limit 到点抛 SoftTimeLimitExceeded,任务可捕获做清理/保存现场;time_limit 是硬上限,到点直接 SIGKILL 终止任务,无清理机会。两者按任务类型配置:长任务放宽硬上限,短任务收紧;超时任务在 acks_late 下可能被重投,需幂等。
概念解释
- soft:软超时,异常可捕获,优雅退出。
- hard:硬超时,进程级强杀,资源(连接、临时文件)可能未释放。
- 全局配置
task_soft_time_limit/task_time_limit,任务装饰器可覆盖。
原理流程
- 任务开始计时,达到 soft 限触发软超时异常。
- 任务内捕获异常,记录进度、关闭连接后退出。
- 未处理继续执行,达到 hard 限被信号强杀。
- 强杀后 broker 按 ack 策略决定是否重投。
代码或图示
from celery.exceptions import SoftTimeLimitExceeded
@app.task(soft_time_limit=60, time_limit=90)
def export_task(...):
try:
...
except SoftTimeLimitExceeded:
save_partial_progress()
raise
常见误区
- 只设硬超时:任务被强杀,临时文件/连接泄漏,数据状态不清晰。
- 超时时间按 CPU 任务估:IO 等待/外部慢调用会拉长实际时长。
- 超时后不排查:反复超时说明任务拆分或下游依赖有问题,不是调大限就解决。
追问
- 硬超时用什么信号?答:prefork 模型下给子进程发 SIGKILL(待确认:不同池模型的终止信号细节)。
- 超时任务会被重试吗?答:取决于 ack 配置与重试规则;soft 超时被捕获退出不会自动重试。
- 怎么查任务执行时长分布?答:flower/backend 记录任务起止时间,按任务类型看 P95/P99。
04.7.21.2-032 chain、group、chord 分别表达什么组合?
一句话结论
chain:任务链式顺序执行,前一个结果传给后一个;group:并发执行一组任务,全部完成后汇聚;chord:group 并发执行完成后触发一个回调任务。三者可嵌套表达 DAG;回调依赖前序全部成功,失败处理要单独设计。
概念解释
- chain:流水线,任务 A → B → C。
- group:扇出并行,互不依赖,等待全部返回。
- chord:group + 收尾回调,常用于并行分片后汇总。
原理流程
- chain 把任务签名串成列表,依次投递执行。
- group 一次性投递多个并行任务。
- chord 等待 group 全部完成,结果交给回调。
- 任一任务失败:group/chord 的汇聚结果按失败策略处理,需定义补偿。
代码或图示
from celery import chain, group, chord
res = chain(add.s(2, 2), multiply.s(3))()
res = group(import_user.s(u) for u in users)()
res = chord(
[process.s(i) for i in items],
summarize.s()
)()
常见误区
- chord 回调无失败兜底:前序部分失败,回调可能拿到残缺结果或不触发。
- group 内任务互相依赖:并行任务间应无共享写冲突。
- 嵌套层级过深:组合调试困难,任务状态追踪复杂。
追问
- 任务结果怎么传给下一个?答:chain 自动把前一任务返回值作为下一任务首参;签名里也可显式传参。
- chord 回调什么时候触发?答:group 所有任务成功完成后;失败任务需配合重试/错误处理。
- 组合任务超时怎么算?答:每个子任务独立超时;整体 DAG 时长需单独监控。
04.7.21.2-033 worker 的 prefork、gevent、eventlet 模型怎么选?
一句话结论
prefork(多进程,默认):隔离性好、兼容同步阻塞库,CPU/IO 任务通用;gevent/eventlet(协程):monkey patch 后单进程承载大量并发 IO,适合 IO 密集、阻塞调用少的场景。选协程模型必须确认所有依赖兼容 monkey patch,同步阻塞库会卡住整个协程池。
概念解释
- prefork:主进程 fork 子进程,并发度 = 进程数,内存独立。
- gevent/eventlet:猴子补丁把标准库 IO 改为协程非阻塞,单进程高并发。
- 协程模型对 C 扩展、线程本地、阻塞调用敏感,兼容性测试要充分。
原理流程
- 评估任务类型:CPU 密集 → prefork;纯 IO 密集 → 协程池。
- prefork 用
-c控制子进程数;协程模型用-c控制并发协程数。 - 协程启动前执行 monkey patch,替换阻塞 IO。
- 压测对比吞吐、内存、稳定性后定型。
代码或图示
celery -A app worker --pool=prefork -c 8
celery -A app worker --pool=gevent -c 100
celery -A app worker --pool=eventlet -c 100
常见误区
- 协程池里跑未打补丁的阻塞库:整个事件循环被卡住,并发能力归零。
- CPU 密集任务用协程:GIL 下无提速,进程隔离更合适。
- gevent 与 eventlet 混用依赖:补丁机制不同,兼容性互相干扰。
追问
- prefork 子进程崩溃会被替换吗?答:master 监控子进程,异常退出后重新 fork(待确认:Celery 5.x 进程回收策略)。
- 协程池并发数设多少?答:按 IO 等待比例与下游连接上限估,远超进程数但受限于外部依赖。
- 什么库不兼容 monkey patch?答:部分 C 扩展、原生线程库、阻塞系统调用较多的客户端,需逐一验证。
04.7.21.2-034 max_tasks_per_child 怎么防内存泄漏?
一句话结论
max_tasks_per_child(max-tasks-per-child)指定 prefork 子进程执行多少个任务后退出重启,由 master 拉起新进程,释放长期积累的内存与泄漏对象。Python 进程常见内存膨胀:未释放的大对象、第三方库缓存、循环引用;定期回收子进程是生产兜底手段。
概念解释
- 重启间隔按内存增长速度定:任务后内存明显上涨就调小。
- 重启瞬间该子进程任务执行完毕才退出,
max_memory_per_child可按内存阈值重启(待确认:版本支持情况)。 - 不能替代内存泄漏排查:只是把泄漏限制在单进程生命周期内。
原理流程
- 子进程每完成一个任务计数加一。
- 达到阈值,子进程完成当前任务后退出。
- master 监控到子进程退出,fork 新子进程补位。
- 新进程内存基线重置,泄漏对象随进程销毁回收。
代码或图示
app.conf.worker_max_tasks_per_child = 200
# 命令行:celery -A app worker --max-tasks-per-child 200
常见误区
- 阈值过大:进程长期不重启,内存涨到触发 OOM。
- 阈值过小:进程频繁 fork,启动成本与连接重建开销上升。
- 以为重启解决泄漏:根因对象/缓存仍在代码里,需结合内存分析定位。
追问
- 还有按内存重启的参数吗?答:
max_memory_per_child按 RSS 阈值回收(待确认:当前版本参数名与默认值)。 - 重启会丢任务吗?答:完成当前任务后退出,未执行的预取任务按 ack 策略重投。
- 怎么观察内存增长?答:worker RSS 随任务数趋势,结合
tracemalloc/内存分析定位泄漏点。
04.7.21.2-035 beat 定时任务怎么配置?时区怎么处理?
一句话结论
beat 按 schedule 周期投递任务:crontab(分/时/日/月/周)、timedelta 间隔、schedule 类。时区由 timezone 配置决定,crontab 表达式按该时区解释;容器化部署要确认容器时区与应用配置一致,避免定时任务偏移。
概念解释
- 周期任务:固定间隔;crontab:按日历时刻。
- 时区配置:
app.conf.timezone,naive 时间按配置时区解释。 - 定时任务定义可在代码
beat_schedule或数据库/监控界面管理。
原理流程
- 定义任务签名与 schedule(crontab/interval)。
- beat 进程按时区计算下次触发时间。
- 到点把任务投递到 broker。
- worker 消费执行;beat 自身不执行任务。
代码或图示
from celery.schedules import crontab
app.conf.timezone = "Asia/Shanghai"
app.conf.beat_schedule = {
"daily-report": {
"task": "tasks.report",
"schedule": crontab(hour=8, minute=0),
},
}
常见误区
- 容器 UTC 时区与业务时区不一致:定时任务按 UTC 触发,时刻偏移 8 小时。
- crontab 字段顺序记错:分/时/日/月/周,写错导致触发时刻异常。
- 定时任务无幂等:重复触发产生重复数据。
追问
- beat 存调度状态吗?答:持久化调度器记录上次触发时间,重启后继续(待确认:默认持久化方式与配置)。
- 时区能按任务单独设吗?答:通常应用级统一时区;跨时区业务在任务内换算。
- 错过调度时间会补跑吗?答:beat 错过窗口一般不补历史执行,需业务明确是否补偿。
04.7.21.2-036 多实例部署 beat 怎么避免重复调度?
一句话结论
beat 正常应单点运行;多实例部署时必须选主机制:分布式锁(Redis/DB 锁)保证只有一个 beat 持锁调度,或用托管调度器/主备切换。否则同一周期任务被多个 beat 重复投递,worker 重复执行。
概念解释
- 单点 beat:简单可靠,故障需重启或备机接管。
- 选主方案:beat 启动抢锁,持锁者调度;锁心跳续租,故障释放。
- 数据库持久化调度器可配合锁记录避免双写调度状态。
原理流程
- 各 beat 实例启动后竞争分布式锁。
- 获锁实例成为主 beat,按 schedule 投递任务。
- 主 beat 故障/释放锁,备机抢到锁接管。
- 调度状态持久化,避免重启后重复触发。
代码或图示
beat-A 持锁 -> 调度
beat-B 等待锁 -> 不投递
A 故障 -> 锁超时 -> B 接管
常见误区
- 多副本 Celery 部署顺手多开 beat:任务重复触发,通知/报表翻倍。
- 锁不设过期:主 beat 卡死,备机永远抢不到锁。
- 调度状态多实例并发写:状态错乱,重复/漏调度。
追问
- worker 多副本需要选主吗?答:不需要,worker 是并行消费,broker 分发任务。
- 选主锁用什么实现?答:Redis
SET NX PX或数据库行锁/乐观锁,与应用锁方案一致。 - beat 宕机期间任务会补跑吗?答:取决于调度器持久化与补偿策略,一般需人工或定时对账发现漏跑。
04.7.21.2-037 Celery 怎么与 Flask/Django 共享应用上下文?
一句话结论
任务运行在独立 worker 进程,不继承 Web 请求上下文;需要应用配置/ORM/扩展时,在任务内显式推送应用上下文(Flask app.app_context(),Django 直接使用 ORM)。配置、数据库连接在任务函数内初始化,不依赖请求期的 g/request 对象。
概念解释
- Web 请求上下文只存在于请求生命周期,worker 进程无此栈。
- 复用应用工厂:任务模块导入 app 实例,上下文内执行业务。
- 数据库会话在任务内独立创建与关闭,不复用请求 Session。
原理流程
- 创建 Celery 实例并初始化应用扩展。
- 任务执行时进入应用上下文,获取配置/ORM 会话。
- 业务逻辑在上下文内完成,独立 commit/close。
- 任务结束上下文退出,连接归还池。
代码或图示
# Flask 集成
@app.task
def send_mail(user_id):
with app.app_context():
user = User.query.get(user_id)
...
常见误区
- 任务里直接访问
request/g:上下文不存在,抛上下文错误。 - 复用 Web 请求的数据库 Session:生命周期错位,连接泄漏/状态串扰。
- 扩展初始化两次:app 与 celery 配置不一致,数据库/缓存连接参数漂移。
追问
- Django 任务要推上下文吗?答:Django ORM 不依赖请求上下文,任务内直接查询即可;配置走 Django settings。
- Celery 实例和 app 怎么绑定?答:
Celery(__name__, broker=...),工厂内init_app模式注册扩展。 - 任务里能用当前登录用户吗?答:不能直接取,需投递时把用户 ID 作为参数传入。
04.7.21.2-038 为什么要在 on_commit 后再投递任务?
一句话结论
数据库事务未提交时投递任务,worker 可能在事务回滚前读到未提交数据,产生脏任务/悬空通知;正确做法是在事务提交成功后(Django transaction.on_commit,SQLAlchemy 提交后回调)再 delay() 投递,保证任务只处理已落库的数据。
概念解释
- 事务内投递:任务消息先进 broker,事务回滚后任务仍执行,查不到数据或通知错误对象。
on_commit钩子:事务成功提交后执行回调;回滚/异常不触发。- 进程重启时未执行的回调会丢失,关键路径需消息表兜底。
原理流程
- 请求内写库变更,事务暂未提交。
- 注册
on_commit回调,回调内投递 Celery 任务。 - 事务提交成功,钩子执行,消息进 broker。
- 事务回滚,钩子不执行,任务不会被投递。
代码或图示
from django.db import transaction
def create_order(payload):
order = Order.objects.create(**payload)
transaction.on_commit(lambda: notify_order.delay(order.id))
常见误区
- 事务里直接
task.delay():回滚后脏任务执行,外部副作用已发出。 - 回调闭包引用未提交对象:提交后对象状态需重新加载/用 ID 传参。
- 依赖 on_commit 做关键可靠投递:进程在提交后、回调执行前崩溃,消息丢失,需 outbox 表补偿。
追问
- SQLAlchemy 怎么实现等价时机?答:
commit()成功后再调用delay();需要钩子可在会话提交事件上挂回调(待确认:事件钩子名称)。 - on_commit 回调异常会回滚事务吗?答:钩子在提交后执行,异常不影响已提交事务,但任务投递失败需重试。
- 多数据库事务怎么处理?答:按主事务边界注册,跨库一致性用 outbox/消息表方案。
04.7.21.2-039 result backend 存什么?过期怎么清理?
一句话结论
backend 存任务状态(PENDING/STARTED/SUCCESS/FAILURE)、返回值、异常信息与 traceback;配置 result_expires 控制结果保留时长,过期自动清理。不需要查询结果的任务关闭 backend,避免 Redis/数据库被结果数据占满;大返回值不应走 backend。
概念解释
- 结果存储可选 Redis、数据库、RPC 等;与 broker 可分离。
- 返回值序列化占用存储,大对象应落对象存储,backend 只存引用。
- 任务状态查询依赖 backend,关闭后只能靠日志/监控观察。
原理流程
- 任务执行,状态与结果写入 backend。
- 生产者/flower 按任务 ID 查询状态。
- 超过
result_expires由 backend 清理(Redis 按 TTL,DB 定时清理)。 - 不查结果的任务配置关闭结果存储。
代码或图示
app.conf.result_backend = "redis://redis:6379/2"
app.conf.result_expires = 3600
app.conf.task_ignore_result = False # 不需要结果可置 True
常见误区
- 大列表/文件内容塞进任务返回值:backend 内存暴涨,序列化耗时。
- 结果不设过期:Redis key 只增不减,最终打满。
- 把 backend 当业务数据库:结果是临时执行记录,不持久保存业务状态。
追问
- 任务结果在哪查?答:
AsyncResult(task_id).status/get(),或 flower 界面。 - backend 丢了影响任务执行吗?答:不影响 worker 执行,只影响结果查询。
- 失败任务 traceback 保留多久?答:受
result_expires控制,排障关键失败可额外落日志/告警系统。
04.7.21.2-040 flower 能看哪些指标?怎么排查积压?
一句话结论
flower 提供 worker 列表与状态、任务详情(状态/耗时/参数/异常)、队列深度、定时任务与 broker 监控。排查积压:先看各队列任务数与 worker 在线数 → 对比单任务耗时与并发数 → 识别慢任务/失败任务 → 扩容或拆分队列。
概念解释
- 核心视图:workers(在线进程/并发/任务数)、tasks(按状态过滤)、queues(深度)、scheduled(beat)。
- flower 是监控辅助,不替代业务指标与日志系统。
- 多 broker 下 flower 连接 broker/backend 读取状态。
原理流程
- 打开 flower,按队列查看深度与消费速率。
- 检查 worker 数量、并发配置、是否有离线进程。
- 按任务类型聚合耗时,找出长尾任务。
- 失败/重试任务查看异常堆栈,定位下游问题。
代码或图示
celery -A app flower --port=5555
常见误区
- 只看队列长度不看消费速率:长度高但消费快是正常;消费停滞才是积压。
- flower 暴露公网无认证:任务参数/异常信息泄露,需加访问控制。
- 依赖 flower 做容量规划:样本有限,应结合历史指标趋势。
追问
- flower 怎么部署?答:随 Celery 栈单独进程启动,连接同一 broker/backend。
- 任务参数能看全吗?答:取决于序列化与 backend 存储,敏感参数不应入队。
- 积压时 flower 看不到的信息?答:数据库/下游依赖耗时需结合 APM 与慢日志。
04.7.21.2-041 任务积压的排查思路是什么?
一句话结论
排查链路:确认积压队列与深度趋势 → 检查 worker 在线数/并发/是否卡死 → 拆分任务耗时分布找长尾 → 检查下游依赖(DB/外部接口)是否变慢 → 判断是容量不足还是故障导致。处置:扩容对应队列 worker、隔离慢任务、限流生产者,故障恢复后逐步消化积压。
概念解释
- 积压根因类别:消费能力不足、慢任务占用并发、下游故障阻塞、任务量突增、worker 崩溃。
- 区分队列:隔离队列的积压不影响其他业务。
- 积压消化要控制速率,避免恢复瞬间二次冲击下游。
原理流程
- 监控队列深度曲线,确认积压开始时间与增速。
- flower/指标核对 worker 数、并发、运行中任务。
- 按任务类型聚合 P95/P99 耗时与失败率。
- 检查下游依赖指标与日志,定位阻塞点。
- 扩容/隔离/限流,积压回落观察消费速率。
代码或图示
队列深度 ↑ -> worker 是否在线/并发是否打满
-> 慢任务是哪些 -> 下游依赖是否异常 -> 容量 vs 故障
常见误区
- 积压就无脑加 worker:下游 DB/连接上限可能先被打满。
- 不区分队列统一扩容:慢任务所在队列才是瓶颈。
- 积压消化不限速:恢复后大量任务并发压垮外部接口。
追问
- 怎么判断是 worker 卡死?答:运行中任务长时间无状态更新,worker 心跳丢失,CPU/连接占用异常。
- 任务量突增怎么限流?答:生产者侧按下游容量控制投递速率,低优任务延后。
- 积压期间新任务 SLA 怎么保证?答:高优队列优先消费,低优任务排队延后。
04.7.21.2-042 任务粒度怎么拆?长任务有什么问题?
一句话结论
任务粒度应单一职责、可独立重试、耗时可控:一次业务动作一个任务,大流程用 chain/group 编排。长任务问题:占用 worker 并发久、超时风险高、崩溃重跑成本大、可见性超时重复消费、进度不可见。拆分方式:按数据分片、按步骤分段、增量处理并记录断点。
概念解释
- 过粗:单任务几十分钟,失败重跑代价大,阻塞并发。
- 过细:任务编排与消息开销上升,状态追踪复杂。
- 粒度权衡:重试成本、编排复杂度、下游批量效率。
原理流程
- 识别大流程:列出步骤与数据分片。
- 步骤间依赖用 chain,可并行分片用 group。
- 每段记录进度状态,失败从断点续跑。
- 监控单任务时长,超长任务进一步拆分。
代码或图示
批量导入 N 万用户
→ group(import_chunk.s(batch) for batch in chunks)
→ 每批 500 条,失败仅重跑当前批
常见误区
- 大循环塞一个任务:中途失败全部重跑,锁与超时风险高。
- 拆得过碎:broker 消息量与编排复杂度增加。
- 分片无边界:进度记录缺失,重启后不知从哪继续。
追问
- 长任务怎么做进度上报?答:状态/进度写 backend 或数据库,前端/监控轮询。
- 拆分后数据一致性怎么保证?答:各分片幂等,状态机记录整体阶段,失败补偿。
- 导出类任务怎么拆?答:分片查询生成临时文件,合并任务收尾,避免单任务内存爆炸。
04.7.21.2-043 任务序列化 pickle 和 JSON 怎么选?
一句话结论
默认 pickle 可序列化 Python 对象,但跨语言不安全、依赖类定义;JSON 通用可读、跨语言友好,但只能传基本类型,不能直接传模型实例。生产建议 JSON:参数只传 ID/基本数据,对象在任务内重新加载;pickle 仅限可信内网且类版本稳定。
概念解释
- pickle:反序列化不可信数据有代码执行风险,broker 被入侵或数据污染时危险。
- JSON:无对象还原能力,datetime/枚举需显式转换。
- 序列化配置:
task_serializer、accept_content、result_serializer。
原理流程
- 投递参数按
task_serializer编码进消息。 - worker 按
accept_content允许格式解码。 - JSON 任务内根据 ID 查库重建对象。
- 结果按
result_serializer写 backend。
代码或图示
app.conf.task_serializer = "json"
app.conf.accept_content = ["json"]
app.conf.result_serializer = "json"
常见误区
- 任务参数直接传 ORM 对象:pickle 依赖类路径,模型变更后旧消息无法解码。
- 开放 pickle 接收外部消息:反序列化漏洞风险。
- JSON 传 datetime 对象:序列化报错或变成字符串,需转换格式。
追问
- 还有哪些序列化格式?答:msgpack 等二进制格式,按团队栈选择(待确认:当前 Celery 支持矩阵)。
- 跨语言任务怎么传参?答:必须 JSON/msgpack 等通用格式,约定 schema 与版本。
- 类定义变更后旧 pickle 消息怎么办?答:兼容旧类名/字段,或清理积压消息后升级。
04.7.21.2-044 任务怎么注册和发现?
一句话结论
Celery 按模块导入收集任务:worker 启动时 include 指定任务模块,装饰器注册的任务进入任务表;任务名默认按模块+函数名生成。新任务模块要在 worker 配置中 include,否则投递后找不到任务报错。
概念解释
@app.task装饰器把函数登记为可调度任务。- worker 启动导入 include 列表中的模块,扫描装饰器。
- 任务名可显式指定,避免模块改名导致任务名漂移。
原理流程
- 任务模块定义函数并加
@app.task。 - Celery 配置
include=[...]列出模块。 - worker 启动导入模块,任务注册到 app registry。
- 投递消息按任务名匹配到注册函数。
代码或图示
app.conf.include = ["tasks.notify", "tasks.export"]
@app.task(name="tasks.notify_order")
def notify_order(order_id): ...
常见误区
- 新任务模块没加 include:worker 报
NotRegistered,消息积压或失败。 - 模块路径调整不显式命名:任务名变化,旧消息路由失败。
- 循环导入:app 与任务模块互相引用,注册顺序出错。
追问
- 任务名冲突怎么排查?答:检查注册名与投递名,重复名后注册覆盖前者。
- 怎么列出已注册任务?答:
celery -A app inspect registered或 flower 视图。 - 任务可以动态加载吗?答:一般启动时导入;运行期动态注册需重启 worker 或自定义加载机制。
04.7.21.2-045 Redis 作为 broker 有哪些限制?
一句话结论
Redis broker 部署简单,但缺少 RabbitMQ 级别的交换路由、死信/重试队列精细机制;消息可见性与重投依赖 list/Stream 实现,持久化与高可用需额外配置;复杂重试、延迟队列、死信路由场景能力有限。适合轻量异步任务,复杂可靠消息链路评估 RabbitMQ/Kafka。
概念解释
- Redis broker 消息存于 list(或 Stream),ack 后移除。
- 无 exchange/绑定模型,路由靠队列名。
- 消息可靠性受 Redis 持久化、主从切换影响;未 ack 消息恢复机制有限。
原理流程
- 任务消息 LPUSH 到队列 list。
- worker RPOP/阻塞读取,执行后 ack 移除。
- 未 ack/崩溃消息的重投按 broker 实现处理。
- 复杂死信/重试需应用层配合实现。
代码或图示
app.conf.broker_url = "redis://redis:6379/1"
# 结果后端建议分 db
app.conf.result_backend = "redis://redis:6379/2"
常见误区
- 用 Redis broker 期待死信队列:需自行维护重试队列与失败队列。
- broker 与缓存共用实例:缓存大 key/淘汰策略可能影响任务消息。
- Redis 未开持久化:宕机后未消费任务丢失。
追问
- Redis Stream 作 broker 有什么改进?答:消费组、pending 条目追踪,比 list 更接近消息队列模型(待确认:Celery 对 Stream 模式的支持版本)。
- 延迟任务在 Redis broker 怎么实现?答:
countdown/eta由客户端/broker 调度,复杂延迟队列评估专用组件。 - 消息顺序性有保证吗?答:单队列单消费者下按投递顺序;多消费者并行不保证顺序。
04.7.21.2-046 任务抛异常后怎么处理?死信怎么落地?
一句话结论
任务异常写入 backend 与日志,按可重试类型自动重试,超过次数进入失败处理:失败告警、死信/补偿表记录参数与堆栈,人工或定时任务补偿。关键任务不能只靠 worker 内存状态,失败记录要落持久化存储,便于回溯与重跑。
概念解释
- 异常分类:瞬时故障(重试)、参数错误(不重试,落死信)、外部系统故障(延迟重试+告警)。
- 死信队列:失败/超次数任务转入独立队列,区别于正常任务。
- 补偿记录:任务参数、失败原因、时间、重试次数、当前状态。
原理流程
- 任务执行抛异常,记录堆栈到日志/backend。
- 匹配重试策略:可重试则退避重投;不可重试标记失败。
- 超最大重试:写入死信队列/补偿表,触发告警。
- 补偿任务或人工介入后重跑成功,关闭死信记录。
代码或图示
@app.task(autoretry_for=(ConnectionError,), max_retries=3)
def process(...):
try:
...
except ValidationError as e:
dead_letter.save(task=request.id, args=..., reason=str(e))
raise
常见误区
- 异常只打日志不落库:重启/清理后失败任务无法追溯重跑。
- 所有失败都自动重试:fatal 错误反复执行,污染队列。
- 死信无人消费:失败任务长期堆积,问题被掩盖。
追问
- 怎么告警失败任务?答:监控 backend 失败率/死信队列深度,超阈值通知值班。
- 死信任务重跑要注意什么?答:确认根因已修复,按原始参数幂等重放。
- 任务异常会影响其他任务吗?答:单个 worker 任务异常不影响同进程其他任务;进程崩溃才触发重投与重启。
04.7.21.2-047 延迟任务怎么投递?countdown 和 eta 区别?
一句话结论
countdown=N:从当前时刻起延迟 N 秒执行;eta=datetime:指定绝对时间执行。两者都把消息暂存到调度层,到点投递给 worker。Celery 延迟依赖 beat/broker 调度能力,长时间延迟或海量延迟任务需评估调度存储压力。
概念解释
- countdown:相对延迟,简单直观。
- eta:绝对时刻,适合「明天 9 点」类计划任务。
- 延迟消息在调度器/内存或 broker 中等待,重启可能影响待执行任务。
原理流程
- 调用
apply_async(countdown=30)或eta=dt。 - 调度层记录触发时间。
- 到点消息进入工作队列,worker 拉取执行。
- 错过触发时间的处理取决于 broker/调度器实现。
代码或图示
notify.apply_async(args=[order.id], countdown=300)
notify.apply_async(args=[order.id], eta=datetime(2026, 11, 20, 9, 0))
常见误区
- 把延迟任务当定时调度:周期任务用 beat 配置,不是每条消息设 eta。
- 海量长延迟消息压在 broker:调度存储膨胀,需专用延迟队列组件。
- 时区混用:eta 时间带时区信息,避免 naive 时间按错误时区解释。
追问
- 延迟任务重启会丢吗?答:取决于 broker 持久化与调度器存储,关键延迟任务需可靠方案。
- 延迟期间任务参数会变吗?答:参数在投递时固化,业务变更需重新投递。
- 延迟任务能取消吗?答:已投递调度的消息取消需按任务 ID 从调度/队列移除,能力随 broker 不同。
04.7.21.2-048 任务频率限制怎么配?
一句话结论
Celery 任务级 rate limit 限制单位时间执行次数(如 rate_limit="10/m"),由 worker 调度层限速;适合保护外部接口、避免短时并发过高。注意限速是消费侧节流,不限制生产者投递;高并发下未执行任务留在 broker 排队。
概念解释
- 速率格式:
n/s(秒)、n/m(分)、n/h(时)。 - 限速按 worker 实例聚合还是单实例,需确认实现语义(待确认:当前版本 rate limit 作用域)。
- 外部依赖有明确 QPS 上限时,任务限速与下游限流对齐。
原理流程
- 任务配置
rate_limit。 - worker 取任务前判断是否超过速率窗口。
- 超限任务在 worker 侧等待,不进入执行。
- 窗口滑动后放行执行。
代码或图示
@app.task(rate_limit="30/m")
def call_external_api(...): ...
常见误区
- 用 rate limit 替代下游限流:broker 排队堆积,生产者侧仍需控制投递。
- 限速值按单 worker 估:多 worker 聚合后 QPS 可能超下游上限。
- 限速任务与高优任务混池:被低优限速占用并发。
追问
- 频率限制和 prefetch 什么关系?答:prefetch 控制预取数量,rate limit 控制执行速率,二者独立。
- 限速排队会超时吗?答:等待时间计入任务生命周期,
time_limit需覆盖排队+执行。 - 怎么按外部接口动态调速?答:静态配置起步;动态限速需自定义调度逻辑或客户端限流。
04.7.21.2-049 worker 并发度 -c 怎么定?
一句话结论
prefork 模型 -c 是子进程数,按 CPU 核数与任务类型估:CPU 密集接近核数,IO 密集可适当放大但受下游连接与内存限制;协程模型 -c 是并发协程数,可远高于核数。最终压测确定,并发过高导致上下文切换、连接打满,过低吞吐不足。
概念解释
- 同步进程模型:每进程串行执行任务,并发 = 进程数。
- 内存基线 × 并发数是主要约束;数据库/外部连接数同步受限。
- 容器按 CPU limit 核算可用核数,不以宿主机物理核为准。
原理流程
- 判断任务 CPU/IO 占比。
- 初始并发:CPU 密集 ≈ 核数;IO 密集按等待比例放大。
- 压测吞吐、P95 耗时、内存、下游连接占用。
- 调整并发并监控拐点,固定生产值。
代码或图示
celery -A app worker -c 8 # prefork 进程数
celery -A app worker --pool=gevent -c 200 # 协程并发
常见误区
- 并发数越大吞吐越高:IO 等待下放大有限,CPU/连接先到瓶颈。
- 忽略内存:每进程加载代码与依赖,并发 × 单进程内存可能超容器 limit。
- 多队列 worker 并发不区分:慢任务队列单独配并发。
追问
- 并发度和数据库连接怎么匹配?答:
worker 并发 × 任务内连接数 ≤ 数据库可用连接,留余量。 - 协程模型并发能开多少?答:按 IO 等待与下游上限,常见数百,需压测验证。
- 在线扩容怎么操作?答:增加 worker 进程/实例,broker 自动分发任务;注意连接预算同步增长。
04.7.21.2-050 任务结果 .get() 同步等待有什么问题?
一句话结论
在 Web 请求里对 AsyncResult.get() 阻塞等待任务完成,会占用请求 worker/连接直到任务结束,任务慢时接口超时、并发被拖垮。异步任务的正确姿势是投递后立即返回,前端/回调/状态查询获取结果;确需同步等待要设超时并限制并发。
概念解释
.get()轮询/阻塞 backend 等待 SUCCESS/FAILURE。- Web 同步等待把异步退化为同步,失去解耦意义。
- 结果获取:回调任务、轮询状态接口、消息通知。
原理流程
- 任务投递后返回 task_id。
- 反模式:请求线程阻塞
result.get(timeout=...)等结果。 - 正确:接口返回 task_id,客户端轮询状态或由回调推送。
- 必须等待的内部流程:限制并发、设短超时、隔离线程池。
代码或图示
# 反模式
result = export_task.delay(...)
data = result.get(timeout=30) # 阻塞请求 worker
# 推荐
task_id = export_task.delay(...).id
return {"task_id": task_id}
常见误区
.get()不设超时:任务卡住,请求线程永久挂起。- 批量任务循环
.get():串行等待,总时长叠加。 - 把 backend 当实时通道:轮询频率过高增加 Redis/DB 压力。
追问
- 怎么实现完成通知?答:任务成功后发消息/回调接口通知前端,或写入状态表供轮询。
- 内部流程必须等结果怎么办?答:用线程池/异步编排等待,隔离于 Web worker,设超时与降级。
.get()超时任务还在跑吗?答:在跑,只是等待方放弃;结果后续仍写 backend。
04.7.21.2-051 任务命名冲突怎么避免?
一句话结论
任务默认名是「模块路径.函数名」,模块移动/重命名会改变任务名,导致旧消息找不到注册任务。生产建议显式指定 name(如 tasks.notify_order),并在代码评审中检查命名唯一;投递名与注册名不一致时报 NotRegistered。
概念解释
- 显式
name与代码路径解耦,重构模块不影响线上任务名。 - 同名任务后注册覆盖前者,排查时先列注册表。
- 任务名应包含业务域,避免通用名冲突。
原理流程
- 装饰器写
name="域.动作"。 - worker 启动注册到 app registry。
- 投递消息按名匹配;缺失/重复立即定位。
- 重构时不改显式 name,保持消息兼容。
代码或图示
@app.task(name="order.notify_order")
def notify_order(order_id): ...
常见误区
- 模块改名后线上旧消息失败:默认任务名漂移,未做兼容过渡。
- 多个函数用通用名
task:注册表互相覆盖。 - 投递时手写任务名与注册名拼写不一致:运行时才暴露。
追问
- 怎么查看注册任务?答:
inspect registered或 flower,核对名称列表。 - 任务改名怎么平滑过渡?答:新旧名短期共存注册,消息迁移后再删旧名。
- 任务名能含中文吗?答:技术上不推荐,路由与日志排查用英文标识更稳妥。
04.7.21.2-052 缓存预热和热点数据保护怎么做?
一句话结论
预热:系统上线/重启后主动加载高频数据到缓存,避免冷启动全部回源;热点保护:识别访问量极高的 key,配合互斥重建、本地缓存、不过期逻辑,防止过期瞬间击穿。预热清单按业务 Top N 数据与访问统计生成。
概念解释
- 冷启动风险:缓存空,首个高峰请求全部查库。
- 预热时机:发布后、缓存集群重建后、大促前。
- 热点识别:按 key 访问频率/命令统计排序,定期更新清单。
原理流程
- 统计访问 Top N 数据,生成预热清单。
- 启动后定时任务批量回填缓存,设合理 TTL。
- 运行期监控热 key,对超热点加保护策略。
- 缓存节点故障后按清单快速重建。
代码或图示
# 预热任务
@app.task
def warmup_hot_data():
for uid in hot_user_ids:
data = db.get_user(uid)
r.setex(f"user:{uid}", TTL, json.dumps(data))
常见误区
- 预热全量数据:缓存空间与回源压力过大,只预热热点。
- 预热后不更新清单:业务热点迁移,预热失效。
- 热点 key 与普通 key 同策略:过期击穿风险集中在热点上。
追问
- 怎么发现热 key?答:Redis 命令统计/monitor 抽样、客户端埋点访问计数、代理层统计。
- 预热失败怎么办?答:预热任务失败告警,首请求走缓存兜底与限流。
- 本地缓存二级怎么配合?答:进程内缓存挡高频重复读,Redis 做共享层,两级 TTL 错开。
04.7.21.2-053 空值缓存怎么落地?更新后怎么清理?
一句话结论
查库不存在的数据写入空标记(空字符串/约定 JSON),短 TTL 防穿透;数据后来入库时,更新流程要主动删除该空值键,否则真实数据被空值缓存挡住。空值 TTL 短于正常缓存,键结构与正常值区分,避免序列化混淆。
概念解释
- 空标记方案:固定空串或
{"_null": true},读取时识别。 - 写入路径补救:新建数据成功后删除对应空值缓存。
- 空值缓存占空间小,但恶意枚举会产生大量键,需限流配合。
原理流程
- 读缓存未命中 → 查库不存在 → 写空标记,短 TTL。
- 后续同请求命中空标记,不查库。
- 数据创建成功:业务流程删除空值键,下次读重建正常缓存。
- 空值到期自然消失。
代码或图示
def get_user(uid):
raw = r.get(f"user:{uid}")
if raw is not None:
return None if raw == "" else json.loads(raw)
user = db.query(User).get(uid)
if user is None:
r.setex(f"user:{uid}", 60, "")
else:
r.setex(f"user:{uid}", 300, json.dumps(user.to_dict()))
return user
def create_user(uid, payload):
db.create(uid, payload)
r.delete(f"user:{uid}") # 清掉可能存在的空值键
常见误区
- 数据入库不删空值键:新用户读不到,直到空值 TTL 到期。
- 空值与正常值混用同一序列化:类型判断出错。
- 空值 TTL 设太长:错误状态长期残留。
追问
- 空值缓存和布隆过滤器怎么配合?答:布隆前置拦截明确不存在的集合,空值缓存兜住动态新增/边界数据。
- 批量空值键怎么清理?答:按前缀 SCAN 扫描匹配,避免 KEYS。
- 空值标记能存错误原因吗?答:可存结构化标记,但短 TTL 内原因可能过时,只做存在性拦截。
04.7.21.2-054 大 key 怎么识别和拆分?
一句话结论
大 key 指单键体积大(MB 级)或集合元素极多:读写阻塞 Redis、网络传输慢、删除阻塞、内存倾斜。识别用 MEMORY USAGE、DEBUG OBJECT、客户端统计与大 key 扫描;拆分方式:集合拆分片、大对象压缩/字段拆分、按时间分键;删除用 UNLINK 异步释放。
概念解释
- 字符串大值:整体读写一次占用大;list/hash/set/zset 元素多:操作成本随规模增长。
- 危害:阻塞主线程、复制/持久化压力、集群内存不均衡。
- 大 key 不在线上直接
DEL:用UNLINK异步删除。
原理流程
- 定期扫描键大小与元素数,标记超阈值大 key。
- 分析结构:适合拆分的集合按 id/时间哈希分多键。
- 大对象压缩或只缓存必要字段,原始数据落库/对象存储。
- 迁移双写过渡,校验后删除旧大 key,UNLINK 释放。
代码或图示
# 查看键占用
MEMORY USAGE user:1001
# 异步删除
UNLINK big_key
常见误区
- 大 key 直接 DEL:同步释放大内存阻塞 Redis 主线程。
- 集合无限追加:历史元素不清理,key 持续膨胀。
- 把整份报表/列表缓存成一个字符串:应分页/分片存取。
追问
- 大 key 阈值怎么定?答:字符串 KB 级关注、MB 级处理;集合元素按业务与命令复杂度评估。
- 集群下大 key 有什么影响?答:单分片内存倾斜,热点集中,扩缩容迁移慢。
- 怎么监控大 key 增长?答:周期采样记录 key 大小趋势,超阈值告警。
04.7.21.2-055 热 key 和二级本地缓存怎么设计?
一句话结论
热 key 访问量极高,Redis 单点承压;二级缓存:进程内本地缓存(如字典/LRU 库)挡高频重复读,Redis 做共享一致层,本地 TTL 短于 Redis,失效回源 Redis。本地缓存注意多实例数据短暂不一致、内存占用与实例数量放大。
概念解释
- 一级:进程内缓存,命中最快,不跨实例共享。
- 二级:Redis,各实例共享,一致性更好。
- 本地缓存适合超热点、可容忍秒级不一致的数据。
原理流程
- 读请求先查本地缓存,命中返回。
- 未命中查 Redis,命中后回填本地(短 TTL)。
- Redis 未命中查库,按 cache-aside 回填。
- 数据变更:删 Redis 缓存;本地缓存靠短 TTL 过期,必要时发失效消息。
代码或图示
request -> local cache -> Redis -> DB
本地 TTL 10s,Redis TTL 300s
常见误区
- 本地缓存无界 LRU:内存随实例数膨胀,需设容量上限与淘汰。
- 两级 TTL 相同:同时失效回源,失去缓冲意义。
- 强一致数据放本地缓存:多实例读到旧值,不适合资金/权限数据。
追问
- 本地缓存怎么跨实例失效?答:发布订阅消息通知各实例清除,或靠短 TTL 自然过期。
- 实例很多时本地缓存放大多少?答:总缓存内存 ≈ 单实例本地缓存 × 实例数,需评估。
- 本地缓存库选什么?答:LRU 实现库或
cachetools等,线程安全按需确认。
04.7.21.2-056 Redis 连接池大小怎么定?和实例上限什么关系?
一句话结论
客户端连接池大小按并发 worker/线程数与 Redis maxclients 估算:多进程/多实例连接叠加,总连接不得超过实例上限并留余量。Redis 单实例连接数有上限,连接过多增加服务端开销;池过小排队等待,过大挤占其他客户端。
概念解释
- 连接复用减少握手;池大小 ≈ 并发访问者数量,不是越大越好。
- 多服务共享实例:连接预算按服务拆分核算。
- 云端托管 Redis 有连接规格限制,需对照套餐。
原理流程
- 统计应用实例数 × 进程/线程数 × 每进程池大小。
- 加其他客户端(worker、脚本、监控)连接。
- 对照 Redis
maxclients与套餐上限,留 20% 余量。 - 压测连接占用峰值,调整池参数。
代码或图示
示例:3 实例 × 8 进程 × 每进程池 20 = 480 连接
maxclients 需 ≥ 600 并留余量
常见误区
- 池大小按单进程配,漏乘实例/进程数:上线后连接被拒。
- Redis 与缓存大 key/慢命令混跑:连接被慢操作占住,等效连接不足。
- 连接不释放:客户端泄漏连接,池单调上涨直到上限。
追问
- Redis 连接数在哪看?答:
INFO clients的 connected_clients,CONFIG GET maxclients。 - 连接被拒报什么错?答:
max number of clients reached,客户端连接超时/拒绝。 - 池满了怎么排队?答:客户端按超时等待,超时抛连接异常;业务侧限流兜底。
04.7.21.2-057 缓存双写一致性有哪些极端场景?
一句话结论
极端场景包括:读写并发交叉(读旧库回填覆盖新缓存)、删缓存失败、数据库主从延迟(读到从库旧值)、多服务并发写、缓存节点故障丢失。兜底:延迟双删、删除重试补偿、读库走主库或容忍从库延迟、变更消息订阅刷新缓存、TTL 最终一致;资金类路径降低缓存依赖。
概念解释
- 并发交叉:A 读旧库过程中 B 更新库并删缓存,A 旧值后写回缓存。
- 删失败:缓存未清,旧值驻留到 TTL。
- 主从延迟:回填读到从库旧值。
- 多服务写:各自更新库与删缓存,顺序不确定。
原理流程
- 列出读写并发、删除失败、副本延迟、多写、故障五类场景。
- 每类配兜底:双删/重试/主库读/消息刷新/TTL。
- 监控不一致迹象:缓存值与库值抽样对账。
- 强一致要求数据评估是否去缓存化。
代码或图示
更新库 -> 删缓存 -> 延迟再删
删除失败 -> 重试队列补偿
读路径 -> 强一致读主库;允许延迟读从库
常见误区
- 认为 TTL 能掩盖所有不一致:窗口内脏数据被读到,业务感知取决于数据类型。
- 缓存对账只抽样不告警:不一致长期存在无人发现。
- 多服务各自删缓存无统一顺序:并发顺序问题难以根治。
追问
- 怎么抽样对账缓存与库?答:定时读热点键对比库值,差异记录告警。
- binlog 订阅刷新缓存是什么方案?答:监听数据库变更,异步删/刷缓存,解耦业务写路径。
- 哪些数据不该缓存?答:强实时、高频变更、一致性极高的余额/库存扣减结果。
04.7.21.2-058 Celery worker 崩溃后任务怎么恢复?
一句话结论
worker 进程崩溃:master 拉起新子进程;未 ack 任务按 broker 机制重新投递给存活 worker,前提是 acks_late=True 且消息持久化。任务恢复后靠幂等逻辑避免重复副作用;beat 调度状态持久化,崩溃恢复后继续周期调度。
概念解释
- 早 ack 模式:崩溃即丢任务,不可恢复。
- 晚 ack + 持久化:崩溃消息重投,可能重复执行。
- 进程级崩溃与任务级异常不同:前者 broker 重投,后者走重试逻辑。
原理流程
- worker 进程异常退出(OOM、崩溃、被杀)。
- broker 发现连接断开/消息未确认,重新入队。
- 其他 worker 拉取重投任务执行。
- 幂等键拦截重复副作用;失败记录可追溯。
代码或图示
worker crash -> 未 ack 消息重回 broker -> 其他 worker 执行
任务幂等:重复命中去重记录,跳过副作用
常见误区
- 不开消息持久化:broker 重启/故障后任务直接丢失。
- 恢复任务不幂等:重跑产生重复通知/重复扣款。
- 崩溃后不监控:反复崩溃重投形成循环,积压放大。
追问
- OOM 被杀任务会重投吗?答:晚 ack 下 broker 重投;需同时修复内存问题,否则反复 OOM。
- 怎么判断任务被重投过?答:任务参数/去重键的执行记录与重试次数日志。
- beat 崩溃恢复会补跑错过的任务吗?答:取决于调度器持久化配置,错过周期一般不自动补历史。
04.7.21.2-059 生产环境缓存与任务队列故障怎么排查?
一句话结论
按链路排查:先看现象分类(缓存未命中/Redis 不可用、任务积压/失败/重复)→ 查组件健康(连接、内存、持久化、broker 队列深度)→ 查应用日志与任务堆栈 → 定位下游依赖或代码缺陷 → 处置后观察恢复趋势。建立监控:命中率、key 数量、队列深度、任务耗时、失败/重试率。
概念解释
- 缓存类:命中率下降、穿透/击穿/雪崩迹象、大 key 慢命令。
- 队列类:积压、worker 离线、超时、重复执行、结果后端异常。
- 排查顺序:组件层 → 应用层 → 下游层,避免一上来改代码。
原理流程
- 收集现象:接口报错形态、任务状态、影响范围与开始时间。
- 组件检查:Redis INFO、broker 队列/连接、worker 在线与并发。
- 应用日志:慢任务、异常堆栈、重试与去重记录。
- 下游依赖:DB 慢查询、外部接口超时。
- 处置:扩容/隔离/限流/修复,监控指标回落。
代码或图示
现象 -> 组件健康 -> 应用日志/堆栈 -> 下游依赖 -> 处置与观察
常见误区
- 不看时间线:故障开始时刻对应发布/配置变更/下游故障。
- 只重启不定位:进程重启掩盖根因,复发概率高。
- 缺少基线指标:无法判断命中率/积压是异常还是常态。
追问
- 缓存雪崩应急怎么做?答:限流保护数据库、降级返回、预热回填,恢复后逐步放开。
- 任务重复执行怎么临时止血?答:检查去重表生效,必要时暂停生产者,修复幂等后恢复。
- 怎么沉淀故障?答:记录时间线、根因、处置动作与指标变化,补监控告警。
04.7.21.2-060 缓存与任务队列怎么做容量规划?
一句话结论
缓存容量:按热点数据量 × 冗余系数 + 预留淘汰空间估算内存,评估 key 数量与单键大小;任务队列容量:按峰值任务 QPS × 平均耗时估算并发与 worker 数,结合 broker 积压缓冲、下游连接上限。规划留余量,压测拐点后定型,并随业务增长定期复盘。
概念解释
- 缓存:命中率、数据新鲜度、过期策略影响实际占用;大 key/热 key 单独评估。
- 队列:消费速率 ≥ 生产速率才能不积压;积压缓冲深度按可接受延迟定。
- 共享组件:Redis/broker 上多业务连接与存储叠加核算。
原理流程
- 统计数据规模、访问热点、TTL 分布 → 缓存内存预估。
- 统计任务峰值速率、单任务耗时、并发需求 → worker 与并发数。
- 核对下游 DB/外部接口连接与 QPS 上限。
- 压测验证拐点,配置预留 20%–30% 余量。
- 定期复盘指标趋势,扩容或拆分业务。
代码或图示
并发需求 ≈ 峰值 QPS × 平均耗时(Little's Law)
缓存内存 ≈ 热点数据量 × 1.5 + 预留淘汰空间
常见误区
- 按平均流量规划:高峰与突发流量下积压/击穿。
- 只算 worker 不算下游:任务并发打满数据库或外部接口。
- 容量只算一次:业务增长后不复核,临近上限才被动扩容。
追问
- 怎么评估缓存命中率是否达标?答:按业务数据类型定基线,命中率下降结合穿透/失效分析。
- 积压缓冲留多少?答:按故障恢复时间内可接受排队时长 × 峰值速率估算。
- 容量规划要考虑多环境吗?答:dev/staging 缩小配比,prod 按真实峰值;配置同步复核。
本节高频题
- 连接池与编码/超时参数(001、002、003)
- pipeline、事务与 Lua 原子性(004、005、006)
- 缓存模式与 key/TTL 设计(007、008、009、010)
- 击穿、穿透、雪崩与布隆过滤器(011、012、013、014)
- 一致性与延迟双删(015、057)
- 分布式锁与 Redlock(017、018、019、020)
- Celery 架构与 broker 选型(021、022)
- 路由、优先级与幂等去重(023、024、025)
- 重试、acks_late、预取与可见性超时(026、027、028、029、030)
- 超时、组合原语与并发模型(031、032、033)
- beat 调度与框架集成(035、036、037、038)
- 积压排查与任务粒度(040、041、042)
- 序列化、注册与 Redis broker 限制(043、044、045)
- 结果等待、故障恢复与容量规划(050、058、059、060)