FDE Times 数据在招 FDE 职位 924▲33 近 7 天在招职位数的变化(同口径比较):不计入本周新开始追踪的公司的职位近 7 天新增 80在招公司 196支持远程 25%美国薪资中位数 $200k招聘最多 Databricks 107
ENVI

前线部署工程师(FDE)的专业媒体

技能指南 · 指南

给慢系统加缓存,可能把“慢”换成“错”

Redis 三种策略按需选用:默认旁路缓存,要新鲜数据用直写,热点键用提前刷新。

分享微博

要点速览

  • 旁路缓存是不错的默认选择,但每次未命中要多花三次往返,数据也可能过期。
  • 直写能让缓存保持新鲜,代价是写入变慢,缓存里可能存着没人读的数据。
  • 提前刷新和防击穿措施,对挡在慢系统前面的热点键最重要。
示意图:应用调用 Redis 缓存(GET、DEL)和缓慢的 ERP(读、写)。会计直接在 ERP 中修改数据;从 ERP 到缓存的路径被划掉,因为缓存并不知道这次修改。Redis 上设置的 300 秒 TTL 是唯一的安全网。
DEL 或直写只能覆盖经过应用代码的写入。数据在 ERP 中被直接修改时,只有 TTL 能限制缓存返回旧数据的时长。来源:本文示例代码,Redis 旁路缓存文档。

在旁路缓存(cache-aside)模式下,每次缓存未命中都要多花三次往返:先查缓存,再查数据源,最后把结果写回缓存。数据库够快时,这三次往返几乎无害。可一旦挡在一套每次查询要好几秒的老旧企业资源计划(ERP)系统前面,用户马上就能感觉到。

前线部署工程师(FDE)对这种场面再熟悉不过:到了客户现场,核心系统很慢,没人允许你改它,下周的演示还必须顺畅。AWS 指出,缓存最大的好处是部署时对现有系统的侵入很小,这也正是缓存常常成为第一选择的原因。

但缓存策略选错了,只不过是把“慢”换成了“错”。本文按实际使用中大概率会遇到的顺序,介绍 Redis 上的三种策略:先用旁路缓存,需要新鲜数据时用直写(write-through),热点键用提前刷新(refresh-ahead)。

要做什么,需要准备什么?

你将用 Python 写一层缓存,放在几个模拟“客户慢系统”的函数前面,比如从 ERP 获取客户详情和价目表的 API。需要准备本地 Redis 实例、Python 3 和 redis-py 库。这里的代码为讲清思路做了精简,缺少生产版本所需的错误处理和连接池。

第 1 步:旁路缓存,默认策略

在旁路缓存中,读写数据源由应用负责,缓存本身从不接触存储。Redis 文档建议每个实体用 cache:{entity}:{id} 形式的键存储,并设置过期时间(TTL),限制过期数据最多能被返回多久。

第一段代码还定义了后续步骤要用到的三个慢系统模拟函数,整篇指南可以在一个文件里跑完。

import json, time
import redis

r = redis.Redis(decode_responses=True)
TTL_SECONDS = 300

# --- 模拟客户的慢系统(每次调用耗时 2 秒)---
def slow_erp_get_customer(customer_id):
    time.sleep(2)
    return {"id": customer_id, "name": "Cong ty A"}

def slow_erp_update_customer(customer_id, fields):
    time.sleep(2)
    return {"id": customer_id, "name": "Cong ty A", **fields}  # 更新后的记录

def slow_erp_get_price(sku):
    time.sleep(2)
    return {"sku": sku, "price": 100000}

# --- 旁路缓存 ---
def get_customer(customer_id):
    key = f"cache:customer:{customer_id}"
    cached = r.get(key)
    if cached is not None:
        return json.loads(cached)          # 命中
    data = slow_erp_get_customer(customer_id)  # 未命中
    r.set(key, json.dumps(data), ex=TTL_SECONDS)
    return data

检查:调用 get_customer(42) 两次并计时。第一次约 2 秒,第二次几乎瞬间返回。打开 redis-cli,运行 GET cache:customer:42,可以看到这条记录已经存进 Redis。

ex=TTL_SECONDS 选项对应 Redis 的 SET ... EX。AWS 建议始终给键设置合适的 TTL,原因在下一步就会清楚。

第 2 步:过期数据从哪里来?

Prisma 认为旁路缓存是不错的通用策略,但它存在一个缓存与数据库不一致的时间窗口:数据库里的记录一旦更新,缓存中的数据就过期了。Redis 给出的解决办法分两层:给每个键设 TTL,让每条数据的过期程度都有上限;写入时执行 DEL,主动让缓存失效。

def update_customer(customer_id, fields):
    slow_erp_update_customer(customer_id, fields)
    r.delete(f"cache:customer:{customer_id}")  # 下次读取会未命中,从而拿到新版本

检查:调用 update_customer(42, {"name": "Cong ty B"}),再在 redis-cli 中运行 GET cache:customer:42,结果应为空。

容易忽略的一点是:DEL 只能防住经过你代码的写入。设想客户的会计直接在 ERP 界面里改了公司名称。

应用对此一无所知,TTL 就成了唯一的安全网。所以 TTL 不是随手填的数字,它回答的是:“客户最多能接受看到多久的旧数据?”

第 3 步:必须保证新鲜时用直写

如果业务无法容忍过期窗口,比如刚审批通过的订单状态,直写更合适。每次写入都同步更新缓存,缓存里始终是刚写入的数据,不会过期。

# 简化版:由应用同时写两处。
# 经典模式中,由缓存层自己负责写入存储。
def update_customer_write_through(customer_id, fields):
    data = slow_erp_update_customer(customer_id, fields)  # 返回新记录
    r.set(f"cache:customer:{customer_id}", json.dumps(data), ex=TTL_SECONDS)
    return data

检查:更新之后,GET cache:customer:42 应返回新值,而不是第 2 步那样的空结果。

代价有两部分。一是写入变慢,因为要写两处;二是写入的大部分数据可能从来没人读,白白占用缓存内存。system-design-primer 建议用 TTL 来控制这部分损失。

还要记住,直写同样防不住应用之外的写入,比如上面会计的例子。

第 4 步:提前刷新与热点键上的风暴

回到那三次往返。对于热点键,比如每个页面都要读的价目表,最危险的时刻是它过期的那一刻。

Redis 描述过缓存击穿(cache stampede):热门键在高负载下过期时,几十个进程会同时去数据库查同一条记录。面对客户的慢系统,这场风暴足以把它彻底压垮。

提前刷新的做法是:在最近被访问过的条目过期之前就刷新它。下面的简化版在值里存一个“软过期”时间戳,比真正的 TTL 更早。请求到达这个时间点时,仍然立即拿到当前副本,而调用慢系统的工作交给后台线程。

import threading

REFRESH_BEFORE = 60  # 在真正的 TTL 到期前 60 秒刷新

def _load_price(key, sku):
    data = slow_erp_get_price(sku)
    entry = {"data": data,
             "soft_expire": time.time() + TTL_SECONDS - REFRESH_BEFORE}
    r.set(key, json.dumps(entry), ex=TTL_SECONDS)
    return data

def get_price_refresh_ahead(sku):
    key = f"cache:price:{sku}"
    cached = r.get(key)
    if cached is None:
        return _load_price(key, sku)  # 真正的未命中:仍需等待
    entry = json.loads(cached)
    if time.time() >= entry["soft_expire"]:
        # 已过软过期时间:后台刷新,当前请求不等待
        threading.Thread(target=_load_price, args=(key, sku), daemon=True).start()
    return entry["data"]

检查:测试时把 TTL_SECONDS 和 REFRESH_BEFORE 调小,反复调用该函数,并在每次调用慢函数时打日志。你会看到刷新发生在键真正从 Redis 消失之前,第一次未命中之后的请求都不用再等 2 秒。

需要说明,这只是一个草图。经典模式中,由缓存本身配置自动刷新;这里则由应用用线程来完成。如果去掉线程、在请求里直接调用 _load_price,得到的只是一个同步的“软 TTL”:碰上软过期的请求依然要站着等慢系统。

这个版本上生产前还有一个缺口要补。每个碰上软过期的请求都会各自启动一个线程,所以同一时刻碰上的请求或进程一多,就会一起去调用客户的系统。击穿只是被提前了,并没有消除。

Redis 建议用 Lua 脚本在一个原子步骤内实现互斥锁或概率性提前刷新,无需任何外部锁机制。这是下一步升级的方向,可以去读 Redis 的旁路缓存文档。

最常见的错误有哪些?

最常见的错误是:既然写入时已经有 DEL,就省掉 TTL,结果外部改过的数据让缓存一直错下去。

第二个错误是给所有键都开提前刷新。system-design-primer 提醒,对接下来需要哪些数据判断失误,反而会降低性能,因为你在花力气调用慢系统去取没人要的数据。

第三个错误是只用一个用户做测试,击穿问题直到演示当天才冒出来。

这项技能在客户现场如何体现?

在现场,代码只是一半工作。另一半是问对问题:哪些数据会在应用之外被修改,每类数据能容忍几秒的陈旧,哪些键被读得最频繁。

答案决定了策略。例如:客户资料用旁路缓存,TTL 设几分钟;订单状态用直写;价目表用提前刷新并加上防击穿措施。

阅读 FDE 岗位描述时,留意“integrate with legacy systems”(对接遗留系统)或“performance under real customer load”(真实客户负载下的性能)这类表述,这正是考察这项技能的地方。简历上不要只写“用过 Redis”,要写清选了哪种策略、为什么选,TTL 由哪条业务需求决定,以及如何处理过期数据。

你离开之后,客户的慢系统依然会很慢。你留下的是一层缓存:任何人读代码,都能明白每个键为什么恰好存活那么多秒。

这篇文章对你有帮助吗?

4 个信源
路线图上的下一篇 · 阶段 5: 部署上线99.9% 的 SLA,每天只给你 86 秒停机时间数据库、第三方 API 和两分钟的故障切换层层相乘,这个看似稳妥的承诺就开始松动。