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

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

原文: https://fdetimes.net/zh/guides/redis-caching-strategies-slow-client-systems/

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

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

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

## 要做什么，需要准备什么？

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

## 第 1 步：旁路缓存，默认策略

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

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

```python
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`，主动让缓存失效。

```python
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 步：必须保证新鲜时用直写

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

```python
# 简化版：由应用同时写两处。
# 经典模式中，由缓存层自己负责写入存储。
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 更早。请求到达这个时间点时，仍然立即拿到当前副本，而调用慢系统的工作交给后台线程。

```python
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 的旁路缓存文档。

**要点:** TTL 不是随手填的数字：它代表客户能容忍的数据陈旧程度。

## 最常见的错误有哪些？

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

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

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

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

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

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

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

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

**本周动手试试:**

- 按本文做出耗时 2 秒的慢系统模拟函数，套上旁路缓存，对比第一次和第二次调用的耗时
- 针对手头的系统列一张表：每类数据能容忍几秒的陈旧，是否有人在应用之外修改它
- 在简历上写一行，描述你做过的一层缓存，写明所用策略、TTL 以及如何处理过期数据

## 信源

- [Database Caching - AWS](https://aws.amazon.com/caching/database-caching/)

- [GitHub - donnemartin/system-design-primer](https://github.com/donnemartin/system-design-primer#application-caching)

- [Introduction to database caching (Prisma Dataguide)](https://www.prisma.io/dataguide/managing-databases/introduction-database-caching)

- [Redis cache-aside](https://redis.io/docs/latest/develop/use-cases/cache-aside/)
