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

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 协调。
  • 生产一般在应用启动时创建客户端单例,请求层复用。

原理流程

  1. 创建 Redis(host=..., port=..., db=..., decode_responses=True),内部建池。
  2. 执行命令时从池取空闲连接,无空闲且未超上限则新建。
  3. 命令执行完连接归还池,供下次复用。
  4. 连接断开/超时由健康检查与重连机制处理。

代码或图示

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 中形成两个不同键。

原理流程

  1. 写入:Python 字符串按 UTF-8 编码为字节存入。
  2. 读取:decode_responses=False 返回原始 bytes;True 解码为 str。
  3. 代码统一按一种类型取值,序列化/反序列化在应用层处理。
  4. 复杂结构(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。
  • 重试只应对瞬时超时,业务写操作要考虑幂等。

原理流程

  1. 建立连接按 socket_connect_timeout 控制握手。
  2. 命令发出后按 socket_timeout 等待响应。
  3. 空闲连接超过间隔触发 health check,失效连接重建。
  4. 超时异常按业务分类:网络抖动重试,慢命令转排查。

代码或图示

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 内命令按顺序发送,结果按顺序取回。
  • 与事务的区别:无回滚语义、无隔离保证、单条失败不影响已执行命令。

原理流程

  1. 进入 pipeline,命令先在客户端缓冲。
  2. execute() 时批量发送到 Redis。
  3. 服务端逐条执行(非事务模式下),结果排队返回。
  4. 客户端按顺序取回结果列表。

代码或图示

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 提供乐观锁:监视键被改动则事务中止。

原理流程

  1. MULTI 开启事务状态,命令入队不立即执行。
  2. 可选 WATCH key 做乐观锁保护。
  3. EXEC 顺序执行队列命令,返回结果列表。
  4. 任一命令在执行期失败,已执行命令不回滚。

代码或图示

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,脚本期间其他命令排队。
  • 脚本原子性建立在「单线程不被抢占」上,不是加分布式锁。
  • 长脚本/大循环会阻塞所有请求,需控制复杂度。

原理流程

  1. EVAL 提交脚本与键、参数;服务端编译并执行。
  2. 执行期间独占事件循环,命令依次完成读写。
  3. 返回脚本结果;EVALSHA 命中缓存则不传源码。
  4. 脚本可通过 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 最常用模式,缓存与库由应用代码显式维护,一致性靠删除策略与过期时间兜底。

概念解释

  • 读路径:缓存 → 库 → 回填。
  • 写路径:更新库 → 删缓存;下次读再从库重建。
  • 删缓存而非更新缓存:避免并发写造成缓存旧值覆盖,且减少写时计算。

原理流程

  1. 读请求查 Redis,命中直接返回。
  2. 未命中查数据库,结果写入缓存并设 TTL。
  3. 写请求先提交数据库事务。
  4. 事务提交后删除对应缓存键;失败留待 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 不易实现严格语义。

原理流程

  1. write-through:应用写缓存 → 缓存同步写库 → 库确认 → 返回。
  2. write-behind:应用写缓存 → 标记脏 → 后台批量刷库 → 定时/容量触发。
  3. 后台落库失败需重试与告警;缓存重启要能恢复脏数据日志。
  4. 按一致性要求选择模式,不能为性能牺牲资金类数据安全。

代码或图示

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 按数据新鲜度分类,缓存键必须有过期时间。

原理流程

  1. 按业务域定义 key 规范与前缀。
  2. 标识用稳定主键,避免可变字段(如昵称)做键。
  3. 值选择合适结构:对象 JSON、计数 string、关联列表 list、标签集合 set、映射 hash。
  4. 配合 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)在内存达上限时生效,与过期删除是两层机制。

原理流程

  1. 写入键时记录过期时间。
  2. 每次访问先检查 TTL,过期即删除。
  3. 后台定期任务抽样扫描过期键并清理。
  4. 内存不足时按淘汰策略驱逐非过期键。

代码或图示

访问触发:惰性删除
后台任务:定期抽样删除
内存上限:淘汰策略驱逐

常见误区

  • 设了 TTL 就以为内存立刻释放:未访问的过期键仍占内存,靠定期任务回收。
  • 大量过期 key 集中到期:定期删除压力与缓存雪崩叠加。
  • 把过期删除和淘汰策略混为一谈:前者针对已过期键,后者在内存满时选择驱逐对象。

追问

  • 怎么查看 key 剩余 TTL?答:TTL key,返回剩余秒数;-1 无过期,-2 不存在。
  • 过期键占内存高怎么处理?答:错峰设置 TTL、增加定期清理效率、检查是否有 key 漏设过期。
  • Redis 持久化会保存过期键吗?答:RDB/AOF 加载时会过滤已过期键(待确认:各持久化模式过期键处理细节)。

04.7.21.2-011 缓存击穿怎么产生?怎么兜底?

一句话结论

击穿:某个热点 key 过期瞬间,大量并发请求同时未命中,全部压到数据库。兜底手段:热点 key 互斥重建(拿锁后由单线程查库回填,其他等待/返回旧值)、热点 key 不设物理过期(后台异步刷新)、提前预热与永不过期逻辑。

概念解释

  • 击穿针对「单个热点 key」,与雪崩(大面积过期)、穿透(查不存在)区分。
  • 互斥重建:第一个请求拿锁查库回填,后续请求短暂等待或读旧缓存。
  • 逻辑过期:缓存存逻辑过期时间,后台线程刷新,请求不阻塞。

原理流程

  1. 热点 key TTL 到期。
  2. 并发请求同时查缓存未命中。
  3. 方案一:请求竞争重建锁,持锁者查库回填,其余等待后读缓存。
  4. 方案二:数据带逻辑过期标记,发现过期即触发异步刷新,先返回旧值。

代码或图示

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 在入口拦截。

原理流程

  1. 请求查缓存,未命中。
  2. 查数据库,记录不存在。
  3. 写入空值缓存(如 ""/null,TTL 较短)。
  4. 后续相同请求命中空值,不再查库;布隆过滤器则在更前置位置拦截。

代码或图示

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 节点宕机/网络分区,缓存整体不可用。
  • 兜底链路:限流保护数据库、降级返回默认值、异步重建缓存。

原理流程

  1. 错峰 TTL:基础 TTL 上加随机秒数,打散过期时间。
  2. 缓存层高可用:主从+哨兵或集群,避免单点。
  3. 缓存不可用时,数据库入口限流,超阈值走降级响应。
  4. 服务恢复后按预热流程逐步回填缓存。

代码或图示

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 则「一定不存在」。特点是存在误报(可能存在但实际没有),不存在漏报(判定不存在就一定没有);误判率随位数与哈希数调整。

概念解释

  • 空间效率高,适合海量数据的前置存在性判断。
  • 不支持删除元素(普通布隆过滤器);计数布隆过滤器支持删除(待确认:实现库与限制)。
  • 数据集合要可枚举/可预热,动态新增需持续加入过滤器。

原理流程

  1. 初始化位数组,选定 k 个哈希函数。
  2. 元素加入:k 个哈希位置置 1。
  3. 查询:k 位全 1 → 可能存在(回源查库确认);有 0 → 拒绝。
  4. 误报率随填充率上升,需预留空间或定期重建。

代码或图示

# 伪代码示意;生产可用已实现的布隆过滤器库
# bf.add(uid);bf.exists(uid)

常见误区

  • 以为布隆过滤器能返回数据:它只回答「可能存在/一定不存在」,不存值。
  • 过滤器不随业务数据更新:新入库数据被误判不存在,形成新的穿透。
  • 误报当成精确判断:命中后仍要查缓存/库确认。

追问

  • 怎么降低误判率?答:增大位数组、调整哈希函数数量,控制元素填充率。
  • 布隆过滤器能删除吗?答:标准实现不能;需要删除用计数布隆过滤器或定期重建。
  • Redis 有原生布隆过滤器吗?答:Redis Stack/Module 提供布隆过滤器类型,普通开源版需应用层实现(待确认:当前模块可用性)。

04.7.21.2-015 缓存与数据库一致性怎么保证?延迟双删是什么?

一句话结论

cache-aside 下推荐「先更新数据库,再删除缓存」;并发读写的小概率窗口用延迟双删兜底:更新库后删一次缓存,延迟一小段时间再删一次,覆盖读旧库回填旧缓存的并发窗口。最终一致靠 TTL 兜底;强一致要求高的场景需读写加锁或接受读旧值。

概念解释

  • 并发窗口:线程 A 读旧库回填缓存,线程 B 更新库并删缓存,A 的旧值可能晚一步写回。
  • 延迟双删:第二次删除在读完回填之后执行,清掉旧值。
  • 删除失败可靠消息队列/重试任务补偿,不能静默丢弃。

原理流程

  1. 写事务更新数据库并提交。
  2. 第一次删除缓存键。
  3. 延迟数百毫秒到秒级(覆盖读库时长)后第二次删除。
  4. 仍不一致的数据由 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 的键中淘汰,未设过期的键受保护。
  • 淘汰与过期删除是两层:前者内存满触发,后者键到期触发。

原理流程

  1. 设置 maxmemory 上限与淘汰策略。
  2. 写入导致内存接近上限,按策略选择候选键驱逐。
  3. 缓存型实例优先淘汰冷数据;状态型实例禁止淘汰。
  4. 监控内存使用率与驱逐次数,容量不足时扩容而非依赖淘汰。

代码或图示

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 标识:防止业务执行超时后锁被自动释放,另一个进程拿到锁,原进程回来误删新锁。

原理流程

  1. 生成唯一 token 作为 value。
  2. SET lock:<biz> <token> NX PX 30000,成功即持锁。
  3. 业务执行;超时未完成需续期(看门狗)。
  4. 解锁 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 需自行实现后台续期协程/线程。
  • 续期不是无限延长:进程异常退出后续期停止,锁最终过期。

原理流程

  1. 加锁时设定基础 TTL。
  2. 启动续期任务:间隔小于 TTL 的三分之一。
  3. 每次续期校验 owner 后 PEXPIRE 延长。
  4. 业务完成/异常退出,停止续期并解锁;进程崩溃则靠 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 的公开讨论,结论是锁只能降低并发概率,不能替代资源层防护。

原理流程

  1. 客户端记录开始时间,依次向 N 个节点 SET NX PX。
  2. 统计成功节点数,达到多数派且耗时未超 TTL 视为持锁。
  3. 业务执行;释放时向所有节点发解锁脚本。
  4. 时钟跳变、进程长时间暂停可能让锁过期而客户端仍在操作。

代码或图示

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' 替代显式锁。

原理流程

  1. 判断业务一致性等级:强一致优先数据库。
  2. 短时互斥、防重、限流:Redis 锁。
  3. 关键写路径:数据库唯一约束/条件更新兜底,Redis 锁只做前置排队。
  4. 两层结合: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:可选,存返回值/异常/状态;不需要结果可关闭以减负。

原理流程

  1. beat 到点或生产者调用任务,消息投递 broker。
  2. worker 监听对应队列,拉取任务执行。
  3. 执行结果写入 backend(配置了才写)。
  4. 生产者/监控系统从 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 机制,复杂重试需自己实现。
  • 选型看:可靠性要求、路由复杂度、运维栈、消息积压容忍度。

原理流程

  1. 评估任务量级、可靠性、重试/死信需求。
  2. 高可靠/复杂路由 → RabbitMQ;简单异步/已有 Redis 栈 → Redis。
  3. broker 持久化与确认模式按可靠性配置。
  4. 迁移时消息格式与队列定义先在预发验证。

代码或图示

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 池。

原理流程

  1. 定义队列与路由规则:任务名 → 队列名。
  2. apply_async(queue=...) 可单次覆盖路由。
  3. worker 启动 -Q queue_a,queue_b 消费指定队列。
  4. 监控各队列深度,按队列扩容对应 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:用户交互类 > 通知类 > 报表导出类。

原理流程

  1. 按业务 SLA 划分高/中/低队列。
  2. 高优队列分配独立 worker 与充足并发。
  3. 低优队列worker 数少或限速,高峰时段可暂停消费。
  4. 监控各队列等待时长,动态调整 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,不含时间戳/随机数。
  • 状态机:待处理 → 处理中 → 成功/失败,重复投递按状态分流。
  • 副作用操作(发通知、扣款、写外部系统)必须可识别重复。

原理流程

  1. 任务入队前/执行首步生成或接收业务唯一键。
  2. 查去重记录:成功则直接返回;处理中则等待或退出。
  3. 执行业务,成功后写入去重记录与结果。
  4. 重试/重跑命中已有记录,跳过副作用。

代码或图示

@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 队列,不等于在原进程内循环。

原理流程

  1. 任务执行抛可重试异常。
  2. 达到重试条件:记录重试次数,按退避时间重新入队。
  3. 次数未超:worker 稍后再次拉取执行。
  4. 超过 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 积压、下游更难恢复。重试预算:限制单位时间重试占比、设置总重试次数与退避上限、熔断后停止重试;监控重试消息比例,超阈值触发降级,而不是无限重跑。

概念解释

  • 放大链条:任务失败 → 重试 → 重试再失败 → 二次重试,消息量指数增长。
  • 预算思路:重试消息不得超过新消息一定比例,超出后直接失败入死信/人工处理。
  • 退避抖动避免大量任务同时醒来再冲击下游。

原理流程

  1. 故障发生,首批任务失败。
  2. 按策略重试,退避间隔加随机抖动。
  3. 统计重试消息占比与队列深度,超预算阈值熔断。
  4. 熔断期间新失败任务直接标记失败/转补偿,不再重试。

代码或图示

# 退避加抖动
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 场景下重复执行是常态而非异常。

原理流程

  1. worker 拉取任务。
  2. acks_late=False:立即 ack,执行失败/崩溃不重投。
  3. acks_late=True:执行成功后 ack;进程崩溃,消息未 ack,broker 重新入队投给其他 worker。
  4. 重复执行由幂等逻辑拦截副作用。

代码或图示

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 间更均匀分发。

原理流程

  1. broker 按 multiplier 向空闲 worker 推送任务。
  2. worker 逐个执行;本地未执行完的任务不回流。
  3. 任务时长差异大时,低预取减少本地排队。
  4. 压测不同 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 崩溃后消息恢复延迟。
  • 重复消费窗口:原任务与重投任务并发执行,风险高于串行重试。

原理流程

  1. 消息投递给 worker,进入不可见状态。
  2. 执行超过可见性超时仍未 ack。
  3. 消息重新可见,被另一个 worker 拉取。
  4. 两个实例并发执行同一任务,幂等键拦截重复副作用。

代码或图示

任务执行 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,任务装饰器可覆盖。

原理流程

  1. 任务开始计时,达到 soft 限触发软超时异常。
  2. 任务内捕获异常,记录进度、关闭连接后退出。
  3. 未处理继续执行,达到 hard 限被信号强杀。
  4. 强杀后 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 + 收尾回调,常用于并行分片后汇总。

原理流程

  1. chain 把任务签名串成列表,依次投递执行。
  2. group 一次性投递多个并行任务。
  3. chord 等待 group 全部完成,结果交给回调。
  4. 任一任务失败: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 扩展、线程本地、阻塞调用敏感,兼容性测试要充分。

原理流程

  1. 评估任务类型:CPU 密集 → prefork;纯 IO 密集 → 协程池。
  2. prefork 用 -c 控制子进程数;协程模型用 -c 控制并发协程数。
  3. 协程启动前执行 monkey patch,替换阻塞 IO。
  4. 压测对比吞吐、内存、稳定性后定型。

代码或图示

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 可按内存阈值重启(待确认:版本支持情况)。
  • 不能替代内存泄漏排查:只是把泄漏限制在单进程生命周期内。

原理流程

  1. 子进程每完成一个任务计数加一。
  2. 达到阈值,子进程完成当前任务后退出。
  3. master 监控到子进程退出,fork 新子进程补位。
  4. 新进程内存基线重置,泄漏对象随进程销毁回收。

代码或图示

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 或数据库/监控界面管理。

原理流程

  1. 定义任务签名与 schedule(crontab/interval)。
  2. beat 进程按时区计算下次触发时间。
  3. 到点把任务投递到 broker。
  4. 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 启动抢锁,持锁者调度;锁心跳续租,故障释放。
  • 数据库持久化调度器可配合锁记录避免双写调度状态。

原理流程

  1. 各 beat 实例启动后竞争分布式锁。
  2. 获锁实例成为主 beat,按 schedule 投递任务。
  3. 主 beat 故障/释放锁,备机抢到锁接管。
  4. 调度状态持久化,避免重启后重复触发。

代码或图示

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。

原理流程

  1. 创建 Celery 实例并初始化应用扩展。
  2. 任务执行时进入应用上下文,获取配置/ORM 会话。
  3. 业务逻辑在上下文内完成,独立 commit/close。
  4. 任务结束上下文退出,连接归还池。

代码或图示

# 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 钩子:事务成功提交后执行回调;回滚/异常不触发。
  • 进程重启时未执行的回调会丢失,关键路径需消息表兜底。

原理流程

  1. 请求内写库变更,事务暂未提交。
  2. 注册 on_commit 回调,回调内投递 Celery 任务。
  3. 事务提交成功,钩子执行,消息进 broker。
  4. 事务回滚,钩子不执行,任务不会被投递。

代码或图示

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,关闭后只能靠日志/监控观察。

原理流程

  1. 任务执行,状态与结果写入 backend。
  2. 生产者/flower 按任务 ID 查询状态。
  3. 超过 result_expires 由 backend 清理(Redis 按 TTL,DB 定时清理)。
  4. 不查结果的任务配置关闭结果存储。

代码或图示

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 读取状态。

原理流程

  1. 打开 flower,按队列查看深度与消费速率。
  2. 检查 worker 数量、并发配置、是否有离线进程。
  3. 按任务类型聚合耗时,找出长尾任务。
  4. 失败/重试任务查看异常堆栈,定位下游问题。

代码或图示

celery -A app flower --port=5555

常见误区

  • 只看队列长度不看消费速率:长度高但消费快是正常;消费停滞才是积压。
  • flower 暴露公网无认证:任务参数/异常信息泄露,需加访问控制。
  • 依赖 flower 做容量规划:样本有限,应结合历史指标趋势。

追问

  • flower 怎么部署?答:随 Celery 栈单独进程启动,连接同一 broker/backend。
  • 任务参数能看全吗?答:取决于序列化与 backend 存储,敏感参数不应入队。
  • 积压时 flower 看不到的信息?答:数据库/下游依赖耗时需结合 APM 与慢日志。

04.7.21.2-041 任务积压的排查思路是什么?

一句话结论

排查链路:确认积压队列与深度趋势 → 检查 worker 在线数/并发/是否卡死 → 拆分任务耗时分布找长尾 → 检查下游依赖(DB/外部接口)是否变慢 → 判断是容量不足还是故障导致。处置:扩容对应队列 worker、隔离慢任务、限流生产者,故障恢复后逐步消化积压。

概念解释

  • 积压根因类别:消费能力不足、慢任务占用并发、下游故障阻塞、任务量突增、worker 崩溃。
  • 区分队列:隔离队列的积压不影响其他业务。
  • 积压消化要控制速率,避免恢复瞬间二次冲击下游。

原理流程

  1. 监控队列深度曲线,确认积压开始时间与增速。
  2. flower/指标核对 worker 数、并发、运行中任务。
  3. 按任务类型聚合 P95/P99 耗时与失败率。
  4. 检查下游依赖指标与日志,定位阻塞点。
  5. 扩容/隔离/限流,积压回落观察消费速率。

代码或图示

队列深度 ↑ -> worker 是否在线/并发是否打满
-> 慢任务是哪些 -> 下游依赖是否异常 -> 容量 vs 故障

常见误区

  • 积压就无脑加 worker:下游 DB/连接上限可能先被打满。
  • 不区分队列统一扩容:慢任务所在队列才是瓶颈。
  • 积压消化不限速:恢复后大量任务并发压垮外部接口。

追问

  • 怎么判断是 worker 卡死?答:运行中任务长时间无状态更新,worker 心跳丢失,CPU/连接占用异常。
  • 任务量突增怎么限流?答:生产者侧按下游容量控制投递速率,低优任务延后。
  • 积压期间新任务 SLA 怎么保证?答:高优队列优先消费,低优任务排队延后。

04.7.21.2-042 任务粒度怎么拆?长任务有什么问题?

一句话结论

任务粒度应单一职责、可独立重试、耗时可控:一次业务动作一个任务,大流程用 chain/group 编排。长任务问题:占用 worker 并发久、超时风险高、崩溃重跑成本大、可见性超时重复消费、进度不可见。拆分方式:按数据分片、按步骤分段、增量处理并记录断点。

概念解释

  • 过粗:单任务几十分钟,失败重跑代价大,阻塞并发。
  • 过细:任务编排与消息开销上升,状态追踪复杂。
  • 粒度权衡:重试成本、编排复杂度、下游批量效率。

原理流程

  1. 识别大流程:列出步骤与数据分片。
  2. 步骤间依赖用 chain,可并行分片用 group。
  3. 每段记录进度状态,失败从断点续跑。
  4. 监控单任务时长,超长任务进一步拆分。

代码或图示

批量导入 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。

原理流程

  1. 投递参数按 task_serializer 编码进消息。
  2. worker 按 accept_content 允许格式解码。
  3. JSON 任务内根据 ID 查库重建对象。
  4. 结果按 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 列表中的模块,扫描装饰器。
  • 任务名可显式指定,避免模块改名导致任务名漂移。

原理流程

  1. 任务模块定义函数并加 @app.task。
  2. Celery 配置 include=[...] 列出模块。
  3. worker 启动导入模块,任务注册到 app registry。
  4. 投递消息按任务名匹配到注册函数。

代码或图示

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 消息恢复机制有限。

原理流程

  1. 任务消息 LPUSH 到队列 list。
  2. worker RPOP/阻塞读取,执行后 ack 移除。
  3. 未 ack/崩溃消息的重投按 broker 实现处理。
  4. 复杂死信/重试需应用层配合实现。

代码或图示

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 内存状态,失败记录要落持久化存储,便于回溯与重跑。

概念解释

  • 异常分类:瞬时故障(重试)、参数错误(不重试,落死信)、外部系统故障(延迟重试+告警)。
  • 死信队列:失败/超次数任务转入独立队列,区别于正常任务。
  • 补偿记录:任务参数、失败原因、时间、重试次数、当前状态。

原理流程

  1. 任务执行抛异常,记录堆栈到日志/backend。
  2. 匹配重试策略:可重试则退避重投;不可重试标记失败。
  3. 超最大重试:写入死信队列/补偿表,触发告警。
  4. 补偿任务或人工介入后重跑成功,关闭死信记录。

代码或图示

@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 中等待,重启可能影响待执行任务。

原理流程

  1. 调用 apply_async(countdown=30) 或 eta=dt。
  2. 调度层记录触发时间。
  3. 到点消息进入工作队列,worker 拉取执行。
  4. 错过触发时间的处理取决于 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 上限时,任务限速与下游限流对齐。

原理流程

  1. 任务配置 rate_limit。
  2. worker 取任务前判断是否超过速率窗口。
  3. 超限任务在 worker 侧等待,不进入执行。
  4. 窗口滑动后放行执行。

代码或图示

@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 核算可用核数,不以宿主机物理核为准。

原理流程

  1. 判断任务 CPU/IO 占比。
  2. 初始并发:CPU 密集 ≈ 核数;IO 密集按等待比例放大。
  3. 压测吞吐、P95 耗时、内存、下游连接占用。
  4. 调整并发并监控拐点,固定生产值。

代码或图示

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 同步等待把异步退化为同步,失去解耦意义。
  • 结果获取:回调任务、轮询状态接口、消息通知。

原理流程

  1. 任务投递后返回 task_id。
  2. 反模式:请求线程阻塞 result.get(timeout=...) 等结果。
  3. 正确:接口返回 task_id,客户端轮询状态或由回调推送。
  4. 必须等待的内部流程:限制并发、设短超时、隔离线程池。

代码或图示

# 反模式
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 与代码路径解耦,重构模块不影响线上任务名。
  • 同名任务后注册覆盖前者,排查时先列注册表。
  • 任务名应包含业务域,避免通用名冲突。

原理流程

  1. 装饰器写 name="域.动作"。
  2. worker 启动注册到 app registry。
  3. 投递消息按名匹配;缺失/重复立即定位。
  4. 重构时不改显式 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 访问频率/命令统计排序,定期更新清单。

原理流程

  1. 统计访问 Top N 数据,生成预热清单。
  2. 启动后定时任务批量回填缓存,设合理 TTL。
  3. 运行期监控热 key,对超热点加保护策略。
  4. 缓存节点故障后按清单快速重建。

代码或图示

# 预热任务
@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},读取时识别。
  • 写入路径补救:新建数据成功后删除对应空值缓存。
  • 空值缓存占空间小,但恶意枚举会产生大量键,需限流配合。

原理流程

  1. 读缓存未命中 → 查库不存在 → 写空标记,短 TTL。
  2. 后续同请求命中空标记,不查库。
  3. 数据创建成功:业务流程删除空值键,下次读重建正常缓存。
  4. 空值到期自然消失。

代码或图示

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 异步删除。

原理流程

  1. 定期扫描键大小与元素数,标记超阈值大 key。
  2. 分析结构:适合拆分的集合按 id/时间哈希分多键。
  3. 大对象压缩或只缓存必要字段,原始数据落库/对象存储。
  4. 迁移双写过渡,校验后删除旧大 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,各实例共享,一致性更好。
  • 本地缓存适合超热点、可容忍秒级不一致的数据。

原理流程

  1. 读请求先查本地缓存,命中返回。
  2. 未命中查 Redis,命中后回填本地(短 TTL)。
  3. Redis 未命中查库,按 cache-aside 回填。
  4. 数据变更:删 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 有连接规格限制,需对照套餐。

原理流程

  1. 统计应用实例数 × 进程/线程数 × 每进程池大小。
  2. 加其他客户端(worker、脚本、监控)连接。
  3. 对照 Redis maxclients 与套餐上限,留 20% 余量。
  4. 压测连接占用峰值,调整池参数。

代码或图示

示例: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。
  • 主从延迟:回填读到从库旧值。
  • 多服务写:各自更新库与删缓存,顺序不确定。

原理流程

  1. 列出读写并发、删除失败、副本延迟、多写、故障五类场景。
  2. 每类配兜底:双删/重试/主库读/消息刷新/TTL。
  3. 监控不一致迹象:缓存值与库值抽样对账。
  4. 强一致要求数据评估是否去缓存化。

代码或图示

更新库 -> 删缓存 -> 延迟再删
删除失败 -> 重试队列补偿
读路径 -> 强一致读主库;允许延迟读从库

常见误区

  • 认为 TTL 能掩盖所有不一致:窗口内脏数据被读到,业务感知取决于数据类型。
  • 缓存对账只抽样不告警:不一致长期存在无人发现。
  • 多服务各自删缓存无统一顺序:并发顺序问题难以根治。

追问

  • 怎么抽样对账缓存与库?答:定时读热点键对比库值,差异记录告警。
  • binlog 订阅刷新缓存是什么方案?答:监听数据库变更,异步删/刷缓存,解耦业务写路径。
  • 哪些数据不该缓存?答:强实时、高频变更、一致性极高的余额/库存扣减结果。

04.7.21.2-058 Celery worker 崩溃后任务怎么恢复?

一句话结论

worker 进程崩溃:master 拉起新子进程;未 ack 任务按 broker 机制重新投递给存活 worker,前提是 acks_late=True 且消息持久化。任务恢复后靠幂等逻辑避免重复副作用;beat 调度状态持久化,崩溃恢复后继续周期调度。

概念解释

  • 早 ack 模式:崩溃即丢任务,不可恢复。
  • 晚 ack + 持久化:崩溃消息重投,可能重复执行。
  • 进程级崩溃与任务级异常不同:前者 broker 重投,后者走重试逻辑。

原理流程

  1. worker 进程异常退出(OOM、崩溃、被杀)。
  2. broker 发现连接断开/消息未确认,重新入队。
  3. 其他 worker 拉取重投任务执行。
  4. 幂等键拦截重复副作用;失败记录可追溯。

代码或图示

worker crash -> 未 ack 消息重回 broker -> 其他 worker 执行
任务幂等:重复命中去重记录,跳过副作用

常见误区

  • 不开消息持久化:broker 重启/故障后任务直接丢失。
  • 恢复任务不幂等:重跑产生重复通知/重复扣款。
  • 崩溃后不监控:反复崩溃重投形成循环,积压放大。

追问

  • OOM 被杀任务会重投吗?答:晚 ack 下 broker 重投;需同时修复内存问题,否则反复 OOM。
  • 怎么判断任务被重投过?答:任务参数/去重键的执行记录与重试次数日志。
  • beat 崩溃恢复会补跑错过的任务吗?答:取决于调度器持久化配置,错过周期一般不自动补历史。

04.7.21.2-059 生产环境缓存与任务队列故障怎么排查?

一句话结论

按链路排查:先看现象分类(缓存未命中/Redis 不可用、任务积压/失败/重复)→ 查组件健康(连接、内存、持久化、broker 队列深度)→ 查应用日志与任务堆栈 → 定位下游依赖或代码缺陷 → 处置后观察恢复趋势。建立监控:命中率、key 数量、队列深度、任务耗时、失败/重试率。

概念解释

  • 缓存类:命中率下降、穿透/击穿/雪崩迹象、大 key 慢命令。
  • 队列类:积压、worker 离线、超时、重复执行、结果后端异常。
  • 排查顺序:组件层 → 应用层 → 下游层,避免一上来改代码。

原理流程

  1. 收集现象:接口报错形态、任务状态、影响范围与开始时间。
  2. 组件检查:Redis INFO、broker 队列/连接、worker 在线与并发。
  3. 应用日志:慢任务、异常堆栈、重试与去重记录。
  4. 下游依赖:DB 慢查询、外部接口超时。
  5. 处置:扩容/隔离/限流/修复,监控指标回落。

代码或图示

现象 -> 组件健康 -> 应用日志/堆栈 -> 下游依赖 -> 处置与观察

常见误区

  • 不看时间线:故障开始时刻对应发布/配置变更/下游故障。
  • 只重启不定位:进程重启掩盖根因,复发概率高。
  • 缺少基线指标:无法判断命中率/积压是异常还是常态。

追问

  • 缓存雪崩应急怎么做?答:限流保护数据库、降级返回、预热回填,恢复后逐步放开。
  • 任务重复执行怎么临时止血?答:检查去重表生效,必要时暂停生产者,修复幂等后恢复。
  • 怎么沉淀故障?答:记录时间线、根因、处置动作与指标变化,补监控告警。

04.7.21.2-060 缓存与任务队列怎么做容量规划?

一句话结论

缓存容量:按热点数据量 × 冗余系数 + 预留淘汰空间估算内存,评估 key 数量与单键大小;任务队列容量:按峰值任务 QPS × 平均耗时估算并发与 worker 数,结合 broker 积压缓冲、下游连接上限。规划留余量,压测拐点后定型,并随业务增长定期复盘。

概念解释

  • 缓存:命中率、数据新鲜度、过期策略影响实际占用;大 key/热 key 单独评估。
  • 队列:消费速率 ≥ 生产速率才能不积压;积压缓冲深度按可接受延迟定。
  • 共享组件:Redis/broker 上多业务连接与存储叠加核算。

原理流程

  1. 统计数据规模、访问热点、TTL 分布 → 缓存内存预估。
  2. 统计任务峰值速率、单任务耗时、并发需求 → worker 与并发数。
  3. 核对下游 DB/外部接口连接与 QPS 上限。
  4. 压测验证拐点,配置预留 20%–30% 余量。
  5. 定期复盘指标趋势,扩容或拆分业务。

代码或图示

并发需求 ≈ 峰值 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)