目录

MySQL 做主库 + Redis 做缓存

这是最常见的「数据库 + 缓存」组合:MySQL 存全部数据、做唯一事实来源;Redis 挡在读请求前面,把热点数据放进内存。 目标是让绝大多数读请求根本不碰 MySQL。

本文按「架构定位 → 读路径 → 写路径 → key 设计 → 代码封装 → 三大缓存问题 → 一致性方案」组织,假设你已经了解 Redis 的基本用法;容器怎么起这两个服务,见 Docker 入门与实践 的「部署 MySQL 与 Redis」一节。

一句话记住:**缓存只有三个动作——读的时候回填、写的时候删除、过期时间兜底。** 剩下的一切都是这三个动作的细节与补救。

mdk height=520 color=#c74634 # MySQL 主库 + Redis 缓存 ## 定位 - MySQL 是唯一事实来源 - Redis 只是加速层 - 缓存数据随时可丢、可重建 ## 读路径 - 先查 Redis - 未命中查 MySQL - 查到后回填并设 TTL - 查不到就缓存空值 ## 写路径 - 先更新 MySQL - 再删除缓存(不是更新) - 删除失败要重试补偿 - TTL 作为最后兜底 ## Key 设计 - 业务:实体:ID 命名 - 值统一 JSON 序列化 - 控制单值与集合大小 - TTL 加随机抖动 ## 三大缓存问题 ### 穿透 - 缓存空值 - 布隆过滤器 - 参数校验与限流 ### 击穿 - 互斥锁回源 - 逻辑过期 - 热点预热 ### 雪崩 - TTL 抖动 - 多级缓存 - 熔断降级 ## 一致性方案 - 删缓存 + TTL 兜底 - 延时双删 - binlog 订阅补偿 - 要求强一致就别缓存 ## 不该缓存的 - 余额与库存 - 权限与支付状态 - 强一致的读 ## 别忘了 MySQL - 回源 SQL 必须走索引 - 写后读考虑主从延迟 - 连接池与慢查询监控

一、先定分工:谁是主,谁是缓存

这套架构能不能用好,取决于三条铁律:

推论很清楚:数据库里的数据都要有,缓存里的数据可以没有。 判断一段逻辑能不能走缓存,就问一句「这个 key 突然消失,业务会不会算错?」会,就不能缓存。

读请求:
  应用 ──① 查缓存──▶ Redis
        │  命中 ──▶ 直接返回(绝大多数请求走到这里就结束了)
        │
        └─② 未命中 ──▶ MySQL ──③ 回填缓存(带 TTL)──▶ 返回

写请求:
  应用 ──① 更新 MySQL(事务提交) ──② 删除 Redis 里的相关 key
                                    └─③ 删除失败 → 重试 / 由 binlog 订阅补偿

二、读路径:Cache Aside(旁路缓存)

读的标准写法,业界叫 Cache Aside,就是把「先查缓存、没有再查库、然后回填」这件事放在业务代码里(而不是让缓存中间件自己回源):

值 = GET key
如果缓存未命中:
    值 = 查 MySQL 走索引
    如果值存在:
        SET key 值 EX 300        # 回填,必须带过期时间
    否则:
        SET key 空值标记 EX 60   # 防穿透,TTL 要短
返回 值

几个必须做到的细节:

常见的另外两种模式(了解即可,多数项目用不上):

模式 读 写 评价
Cache Aside 应用自己查缓存 + 查库回填 应用自己更新库 + 删缓存 推荐默认选择,逻辑透明、可控
Read/Write Through 由缓存组件代为回源 由缓存组件代为写库 应用层更干净,但需要中间件支持,排错链条变长
Write Behind 同 Cache Aside 先写缓存,异步批量刷库 吞吐极高,宕机会丢数据,只适合日志、计数等可容忍丢失的场景

三、写路径:为什么「先更新库、再删缓存」

这一节是整套方案里最容易写错的地方,值得逐条说清楚。

1. 为什么是「删除」缓存,而不是「更新」缓存

2. 为什么是「先更新数据库,再删缓存」

反过来「先删缓存、再更新库」看上去更快,但会出现这种时序:

线程 A(写)           线程 B(读)                 时间
删缓存                 │                            t1
                     读缓存未命中                  t2
                     查 MySQL,读到旧值             t3
更新 MySQL(写新值)   │                            t4
                     回填缓存(旧值!)             t5

结果:库里是新值,缓存里是旧值,而且这条脏数据要等 TTL 到期才消失。

而「先更新库、再删缓存」的最坏情况,是读线程在删之前就把旧值读走、又延后回填——窗口极窄,且 TTL 兜底,工程上可以接受。

3. 删除失败了怎么办

删缓存失败(网络抖动、Redis 重启)会让脏数据长期存在,所以要有补偿:

4. 延时双删(什么时候需要)

写库后立刻删缓存,仍可能有「读线程在删之前读到旧值、删之后才回填」的极端情况。缓解办法是延迟再删一次:

$redis->del($key);                            // 第一次删
$pdo->exec("UPDATE users SET city='上海' WHERE id=1");
// 延迟 300~1000 ms 再删一次,覆盖极端时序下被回填的旧值
$redis->setex("delay:del:" . $key, 1, $key);  // 交给异步任务或定时脚本真正执行 DEL

它不精确(延迟多久是猜的),但能显著缩小窗口。只有在写并发很高、或 MySQL 主从复制导致读抖动时才有必要,普通项目用「删缓存 + TTL」就够了。

5. 真正需要强一致的数据,就别缓存

余额、库存、支付状态、权限判断这类数据,不要用「删缓存 + TTL」硬凑一致性,那只是把 bug 藏起来。正确做法是:

四、Key 设计与序列化规范

统一规范能省掉后期一大半排查时间:

建议 说明
命名用 业务:实体:ID:字段 如 user:1001:profile 、article:200:views ,层级用冒号分隔
加统一前缀 如 app: ,多项目共用一个 Redis 实例时不会撞 key
值用 JSON 序列化 可读性好、跨语言;对体积敏感再换 MessagePack 或压缩
中文不要转义 PHP 传 JSONUNESCAPEDUNICODE ,排查时肉眼能看懂
单值控制在 10 KB 内 大对象拆成多个 key,或只缓存热点字段
集合元素控制在几千级 超过就用 HSCAN / ZSCAN 分页,或拆 key
TTL 必须设,且加抖动 300 秒就设成 270 到 330 秒之间,避免同一批 key 同时过期
空值用独立标记 例如固定字符串,避免与真实值混淆
user:1001:profile          # 用户资料,JSON,TTL 5 分钟
user:1001:order:count      # 单字段计数,TTL 1 分钟
article:200:views          # 计数器,可以给较长 TTL
rank:hot:daily:2026-10-15  # 当日热榜,ZSet,第二天自然淘汰
lock:order:9527            # 互斥锁,TTL 10 秒

另外:Redis 的 16 个库不要当「环境隔离」用。开发、测试、生产各起实例或用不同前缀,别靠 SELECT 切库来区分。

五、封装一个通用的「读缓存」方法

把「查缓存 → 回源 → 回填 → 加锁」封成一个入口,业务代码只写一次 SQL 回调,是最省心的做法(这也是 Laravel 的 Cache::remember 、Spring 的 @Cacheable 在干的事)。

class Cache
{
    private const NULL_MARK = '@NULL';   // 空值标记
 
    public function __construct(private Redis $redis, private PDO $pdo) {}
 
    // $key 完整 key;$ttl 基础 TTL 秒数;$loader 回源回调(查 MySQL)
    public function remember(string $key, int $ttl, callable $loader)
    {
        $raw = $this->redis->get($key);
        if ($raw !== false) {
            return $raw === self::NULL_MARK ? null : json_decode($raw, true);
        }
 
        // 防击穿:只让一个请求回源,其余请求短暂等待
        $lock = "lock:fill:" . $key;
        if ($this->redis->set($lock, '1', ['nx', 'ex' => 5])) {
            try {
                $data = $loader();
                $this->write($key, $data, $ttl);
                return $data;
            } finally {
                $this->redis->del($lock);
            }
        }
 
        usleep(50000);                        // 等 50 毫秒再看一次缓存
        $raw = $this->redis->get($key);
        if ($raw === false) {
            return $loader();                 // 仍没有就降级直查 MySQL(要配合限流)
        }
        return $raw === self::NULL_MARK ? null : json_decode($raw, true);
    }
 
    // 回填:空值用短 TTL,正常值加 TTL 抖动
    private function write(string $key, $data, int $ttl): void
    {
        if ($data === null || $data === []) {
            $this->redis->setex($key, min($ttl, 60), self::NULL_MARK);
            return;
        }
        $ttl = (int) ($ttl * (0.9 + mt_rand(0, 20) / 100));   // 防雪崩:上下抖动一成
        $this->redis->setex($key, $ttl, json_encode($data, JSON_UNESCAPED_UNICODE));
    }
 
    public function forget(string ...$keys): void
    {
        if ($keys) {
            $this->redis->del($keys);
        }
    }
}

业务层用起来就三行——注意读写是分开的,写路径永远只碰数据库和删除:

// 读
$user = $cache->remember("user:" . $id . ":profile", 300, function () use ($id, $pdo) {
    return $pdo->query("SELECT id,name,city FROM users WHERE id=" . (int) $id)
               ->fetch(PDO::FETCH_ASSOC) ?: null;
});
 
// 写:先库后缓存,且是删除不是更新
$pdo->prepare("UPDATE users SET city=? WHERE id=?")->execute(['上海', $id]);
$cache->forget("user:" . $id . ":profile", "user:" . $id . ":order:count");

Python 侧是同样的思路,用 set(nx=True, ex=5) 抢锁:

NULL_MARK = b"@NULL"
 
def get_user(uid):
    key = "user:" + str(uid) + ":profile"
    raw = r.get(key)
    if raw is not None:
        return None if raw == NULL_MARK else json.loads(raw)
 
    lock = "lock:fill:" + key
    if r.set(lock, "1", nx=True, ex=5):
        try:
            row = db.query_one("SELECT id,name,city FROM users WHERE id = ?", (uid,))
            payload = NULL_MARK if row is None else json.dumps(row, ensure_ascii=False)
            r.setex(key, 300, payload)          # 生产环境再叠加随机抖动
            return row
        finally:
            r.delete(lock)
 
    time.sleep(0.05)
    raw = r.get(key)
    return None if raw in (None, NULL_MARK) else json.loads(raw)

六、三大缓存问题的具体打法

问题 触发场景 在 MySQL + Redis 里怎么做
缓存穿透 请求不存在的数据(例如把 id 传成负数刷接口),缓存和库都命中不了 缓存空值(短 TTL)+ 布隆过滤器(启动时把 MySQL 主键灌进去,可放 RedisBloom)+ 参数合法性校验 + 单 IP 限流
缓存击穿 单个热点 key 恰好过期(首页、大促商品) 互斥锁回源(上一节的写法)、逻辑过期(值里存过期时间戳,不设物理 TTL,过期后由一个线程异步刷新)、热点数据定时预热
缓存雪崩 大批 key 同时过期,或 Redis 整体挂掉 TTL 加随机抖动、分批预热错开时间、本地缓存 + Redis 两级、熔断降级直查 MySQL 并限流、Redis 用哨兵或集群做高可用

补充两点实战经验:

七、一致性方案分级:按业务选,不要一把梭

方案 一致性水平 复杂度 适用场景
更新库 + 删缓存 + TTL 兜底 最终一致,窗口秒级 低 默认方案,绝大多数业务
上面 + 延时双删 窗口更小但不精确 中 写并发高、存在主从复制延迟
上面 + binlog 订阅补偿(Canal / Debezium) 最终一致,不依赖业务代码 高 更新入口分散、缓存 key 多、团队有人维护
缓存内嵌版本号或时间戳 能发现不一致并回源 中高 对脏读敏感的展示类数据
不缓存,直接读主库 强一致 低 余额、库存、权限、支付状态

要接受的现实是:只要用了缓存,一致性就是「窗口有多小」的问题,而不是「有没有」的问题。 工程目标是让窗口足够小(毫秒到秒级)、并且有兜底(TTL、重试、监控告警),而不是追求零窗口。

八、别忘了 MySQL 这一侧的配合

九、上线检查清单

十、小结

参考

相关笔记:redis、docker