本地缓存


性能瓶颈的再思考

分片计数方案上线后,系统性能提升了很多。

但我发现了一个有趣的现象:

监控数据:

热门文章(前 100 篇):
- 访问量:占总访问的 80%
- Redis QPS:约 5000
- 响应时间:平均 5ms

普通文章:
- 访问量:占总访问的 20%
- Redis QPS:约 1000
- 响应时间:平均 8ms

热门文章的访问太频繁了!

虽然 Redis 很快,但:

  • 每次请求都要网络往返
  • 网络延迟至少 1-2ms
  • 高峰期网络可能拥堵

能否再优化?

我想到了本地缓存。


本地缓存原理

传统方案:
用户请求 → 应用服务器 → Redis(网络往返)

本地缓存方案:
用户请求 → 应用服务器(本地内存)→ 命中则返回
          ↓
      未命中 → Redis(网络往返)

优势:

  • 本地读取速度极快(纳秒级)
  • 减少 Redis 压力
  • 降低网络延迟

劣势:

  • 数据可能不一致
  • 占用应用服务器内存
  • 需要处理缓存失效

实现方案

方案 1:简单内存缓存

最朴素的做法:在应用进程里维护一个 dict,键是文章 ID,值是 (计数, 过期时间戳)。

import time
from threading import Lock


class SimpleLocalCache:
    """最简单的本地缓存:dict + TTL,无容量上限"""

    def __init__(self, ttl=5.0):
        self.ttl = ttl
        self._data = {}          # article_id -> (value, expire_at)
        self._lock = Lock()

    def get(self, article_id, loader):
        """先查缓存,未命中则调用 loader 回源"""
        with self._lock:
            entry = self._data.get(article_id)
            if entry is not None:
                value, expire_at = entry
                if time.monotonic() < expire_at:
                    return value
                # 已过期,删除后回源
                del self._data[article_id]

        value = loader(article_id)

        with self._lock:
            self._data[article_id] = (value, time.monotonic() + self.ttl)
        return value

    def set(self, article_id, value):
        with self._lock:
            self._data[article_id] = (value, time.monotonic() + self.ttl)

    def invalidate(self, article_id):
        """主动失效:写路径上调用"""
        with self._lock:
            self._data.pop(article_id, None)

这个方案的三个特点:

维度行为代价
命中O(1),不产生网络往返—
淘汰只按 TTL 过期,没有容量上限条目只增不减,内存可能被撑爆
一致性最多滞后一个 TTL多实例之间仍然不一致

最需要警惕的是”没有容量上限”。

TTL 过期只在下次访问该 key 时才会真正删除条目。再也没被访问过的过期条目会一直留在 dict 里,典型表现是:服务跑得越久内存占用越高,最后 OOM。

10000 篇文章 × 每条缓存 ~100 字节 ≈ 1 MB   —— 看起来不多

但如果 key 是"用户 + 文章"的组合:
50000 用户 × 100 篇文章 = 5,000,000 条 ≈ 500 MB  —— 内存告急

所以生产环境一定要用方案 2 的有界缓存。

点赞计数本地缓存

把上面的缓存接到点赞计数上:读路径走缓存,写路径同步更新缓存。

class LikeCountService:
    """点赞计数服务:本地缓存 + Redis 回源"""

    CACHE_TTL = 5.0   # 秒

    def __init__(self, redis_client, local_cache=None):
        self.redis = redis_client
        self.cache = local_cache or SimpleLocalCache(self.CACHE_TTL)

    def _counter_key(self, article_id):
        return f"article:{article_id}:like_count"

    def get_like_count(self, article_id):
        """读路径:缓存优先,未命中回源 Redis"""
        def loader(aid):
            value = self.redis.get(self._counter_key(aid))
            return int(value) if value is not None else 0

        return self.cache.get(article_id, loader)

    def like(self, article_id, user_id):
        """写路径:先改 Redis,再更新本地缓存"""
        # Redis 才是真值来源,INCR 是原子的
        new_count = int(self.redis.incr(self._counter_key(article_id)))
        # 本地缓存同步为最新值,避免同一实例读到旧数
        self.cache.set(article_id, new_count)
        return new_count

    def unlike(self, article_id, user_id):
        """写路径:DECR 后同步缓存"""
        new_count = int(self.redis.decr(self._counter_key(article_id)))
        self.cache.set(article_id, new_count)
        return new_count

读写路径的分工:

读:用户请求 → 本地缓存
                  ├─ 命中   → 直接返回(0 次网络往返)
                  └─ 未命中 → Redis(1 次网络往返)→ 写入缓存 → 返回

写:用户点赞 → Redis INCR(真值)→ 更新本地缓存 → 返回

写路径为什么必须先改 Redis?

Redis 是唯一真值来源,本地缓存只是它的副本。如果先改缓存再改 Redis,一旦 Redis 写失败,本地缓存就会持有一个”从未存在过的计数”,而且要等 TTL 过期才能恢复。

写路径为什么还要更新本地缓存?

不更新也能工作——本地缓存会在 TTL 到期后自然回源。但如果 TTL 是 5 秒,点赞者自己在 5 秒内刷新页面会看到旧数字,这正是”点了赞数字没变”最直观的投诉来源。

一个容易被忽略的问题:写路径只更新了”当前实例”的缓存。

用户 A 的请求落在实例 1,实例 2 上的本地缓存还是旧值。实例 1 的 self.cache.set() 对实例 2 没有任何影响。这正是下一节”多实例缓存不一致”要解决的问题。

方案 2:LRU 缓存

方案 1 的问题是没有容量上限。LRU(Least Recently Used)缓存加上两个约束:有最大容量,超出时淘汰最久没用的。

from collections import OrderedDict


class LRUCache:
    """有界 LRU 缓存:容量满时淘汰最久未使用的条目"""

    def __init__(self, max_size=10000, ttl=5.0):
        self.max_size = max_size
        self.ttl = ttl
        self._data = OrderedDict()   # article_id -> (value, expire_at)
        self._lock = Lock()

    def get(self, article_id, loader):
        with self._lock:
            entry = self._data.get(article_id)
            if entry is None:
                return self._miss(article_id, loader)
            value, expire_at = entry
            if time.monotonic() >= expire_at:
                del self._data[article_id]
                return self._miss(article_id, loader)
            # 命中:移到末尾,它就是"最近使用"
            self._data.move_to_end(article_id)
            return value

    def _miss(self, article_id, loader):
        value = loader(article_id)
        self.set(article_id, value)
        return value

    def set(self, article_id, value):
        with self._lock:
            self._data[article_id] = (value, time.monotonic() + self.ttl)
            self._data.move_to_end(article_id)
            # 超出容量:淘汰最久未使用的(OrderedDict 的第一个)
            while len(self._data) > self.max_size:
                self._data.popitem(last=False)

    def invalidate(self, article_id):
        with self._lock:
            self._data.pop(article_id, None)

    def stats(self):
        return {"size": len(self._data), "max_size": self.max_size}

淘汰策略对比:

策略规则适合
TTL 过期到期就失效所有数据都有新鲜度要求
LRU淘汰最久未使用的热点集中、访问有局部性
LFU淘汰使用次数最少的访问分布均匀、热点不明显
随机随机淘汰实现最简单、性能最好

点赞计数是典型的热点集中场景——前 100 篇文章占了 80% 的访问,LRU 正好能把容量留给真正的热点。

一个工程细节:move_to_end 不是免费的。

每次命中都要更新链表位置,这是一次 O(1) 但需要持锁的操作。高并发下这把锁会成为新的瓶颈。生产上更常见的做法是分片缓存(每个分片一把锁)来降低锁竞争。

容量怎么定?

max_size = 预期热点文章数 × 1.5

例:Top 100 文章占了 80% 访问
max_size = 100 × 1.5 = 150

太小 → 命中率低,白白回源
太大 → 内存占用高,但没必要

方案 3:多级缓存

单级本地缓存只解决”本实例读得快”。多级缓存把回源链路也分层:L1 本地内存 → L2 Redis → L3 数据库。

class MultiLevelCache:
    """多级缓存:L1 本地 → L2 Redis → L3 数据库"""

    def __init__(self, redis_client, db, local_cache=None):
        self.redis = redis_client
        self.db = db
        self.l1 = local_cache or LRUCache(max_size=10000, ttl=5.0)
        self.l2_ttl = 60      # Redis 层缓存更久,兜住 L1 的空窗
        self.stats = {"l1_hit": 0, "l2_hit": 0, "l3_hit": 0}

    def _key(self, article_id):
        return f"article:{article_id}:like_count"

    def get(self, article_id):
        # L1:本地内存
        value = self.l1.get(article_id, loader=self._from_l2)
        if value is not None:
            return value
        return self._from_l2(article_id)

    def _from_l2(self, article_id):
        # L2:Redis
        raw = self.redis.get(self._key(article_id))
        if raw is not None:
            self.stats["l2_hit"] += 1
            value = int(raw)
            self.l1.set(article_id, value)
            return value

        # L3:数据库(Redis 挂了或缓存未命中)
        self.stats["l3_hit"] += 1
        row = self.db.query(
            "SELECT like_count FROM articles WHERE id = %s", (article_id,)
        )
        value = row[0]["like_count"] if row else 0

        # 回填 L2 和 L1
        self.redis.setex(self._key(article_id), self.l2_ttl, value)
        self.l1.set(article_id, value)
        return value

各级缓存的定位:

层级介质延迟容量一致性
L1进程内存~100ns最小最弱
L2Redis~1ms中等较强
L3数据库~50ms最大最强

多级缓存的核心收益是”故障降级”,不只是性能优化。

Redis 宕机时:
只做 L1 + L2   → 全部请求打到数据库 → 数据库雪崩
做 L1 + L2 + L3 → L1 命中 95% 的请求 → 只有 5% 打到数据库 → 系统存活

代价是写路径变复杂。

写路径必须逐层更新或失效,不能只更新 L1:

like(article_id):
    Redis INCR → 新值 N
    L2 SETEX (key, 60, N)     # 更新 L2
    L1 set(article_id, N)      # 更新 L1

如果只更新 L1 不更新 L2,当 L1 过期回源时会把 L2 里的旧值再写回 L1,造成”旧值复活”。

踩坑提醒:回源时的并发击穿。

L1 过期的那一刻,成千上万个请求会同时回源 L2,形成击穿。解决办法是在回源路径上加一把”单飞(single-flight)“锁,同一个 key 同一时刻只允许一个请求真正回源。


缓存一致性

问题:多实例缓存不一致

场景:多个应用服务器

服务器 A:
- 本地缓存:article:123:like_count = 100

服务器 B:
- 本地缓存:article:123:like_count = 100

用户点赞(请求到达服务器 A):
- 服务器 A:更新 Redis → 101
- 服务器 A:更新本地缓存 → 101
- 服务器 B:本地缓存仍是 100(旧数据)

结果:不同服务器返回不同的值

解决方案 1:短 TTL

最简单的本地缓存一致性方案:给缓存一个足够短的 TTL。

CACHE_TTL = 5.0   # 秒

它是怎么工作的:

T0: 实例 A 缓存 article:123 = 100(TTL 5s)
T1: 用户点赞 → Redis 变成 101,实例 A 更新本地缓存
T2: 实例 B 仍然缓存着 100
T5: 实例 B 的缓存过期 → 回源 Redis → 拿到 101

一致窗口 = TTL。

TTL 就是你能接受的最大不一致时间。TTL 设 5 秒,意味着”最多 5 秒内,不同实例可能返回不同的数字”。

TTL 怎么选?

TTL一致性Redis 压力适用
1s最好极高计数要求准、QPS 不高
5s较好适中通用选择
30s较差低展示型计数
不设 TTL无保证最低静态数据

短 TTL 解决不了的两个问题:

1. 缓存雪崩。

TTL 相同的缓存会在同一时刻集体过期,瞬间把所有请求打到 Redis。生产上要给 TTL 加随机抖动:

ttl = base_ttl + random.uniform(0, jitter)   # jitter 取 base_ttl 的 10%~20%

2. 短 TTL 换不来强一致性。

5 秒的窗口对于”用户点赞后立刻刷新”这种场景还是太长。TTL 只能压缩不一致窗口,不能消除它。

优点:

  • 实现最简单,零额外组件
  • 不需要任何跨实例通信
  • 没有额外的故障点

缺点:

  • 一致窗口 = TTL,不可控
  • 过期瞬间会有回源尖峰
  • 热点数据的 TTL 越短,Redis 压力越大

解决方案 2:主动失效

主动失效的思路是:写路径发生时,主动通知所有实例把本地缓存删掉。

# 写路径:更新 Redis 后广播失效消息
def like(self, article_id, user_id):
    new_count = int(self.redis.incr(self._counter_key(article_id)))
    # 广播:让所有实例删掉这条本地缓存
    self.redis.publish(
        "cache:invalidate",
        json.dumps({"key": self._counter_key(article_id)})
    )
    return new_count
# 每个实例订阅频道,收到消息就删本地缓存
def on_invalidate(self, message):
    payload = json.loads(message)
    self.cache.invalidate(payload["key"])
# 订阅线程
def start_subscriber(self):
    pubsub = self.redis.pubsub()
    pubsub.subscribe("cache:invalidate")
    for message in pubsub.listen():
        if message["type"] == "message":
            self.on_invalidate(message["data"])

它的价值:把一致窗口从”TTL”压缩到”消息传播时间”。

短 TTL:   T0 写入 → 最多等 5 秒  → 全部实例一致
主动失效: T0 写入 → 几毫秒后     → 全部实例一致

三个必须注意的点:

1. Pub/Sub 是”即发即弃”的,不可靠。

如果某个实例此刻正好重启、或者订阅连接断开了,它就收不到这条失效消息,本地缓存会一直保留旧值直到 TTL 过期。所以主动失效必须配合 TTL 兜底,不能单独使用。

2. 消息风暴。

一次批量操作(比如给 100 篇文章点赞)会产生 100 条消息。热门文章的写 QPS 高达几千,订阅端要处理同样量级的消息。可以把消息改成”按前缀失效”,让实例自己判断要不要删。

3. Pub/Sub 的额外延迟。

Redis Pub/Sub 的消息在集群模式下只在订阅节点所在的分片内传播,跨实例通知还要额外一跳。实测延迟通常在 1~5ms,远好于 TTL,但确实存在。

主动失效 vs 短 TTL:

维度短 TTL主动失效
一致窗口TTL消息延迟
实现复杂度极低中(需要订阅端)
额外组件无需要 Pub/Sub 通道
可靠性高(一定会过期)中(消息可能丢)
推荐用法兜底主方案 + TTL 兜底

解决方案 3:版本号

版本号方案把”数据”和”数据的版本”分开:Redis 里存计数,同时存一个单调递增的版本号。写操作递增版本号,读操作比对版本。

# Redis 中的两个 key
article:123:like_count      = 101
article:123:like_count:ver  = 57
class VersionedCache:
    """版本号缓存:本地缓存同时保存值和版本号"""

    def __init__(self, redis_client, local_cache=None):
        self.redis = redis_client
        self.cache = local_cache or LRUCache(max_size=10000, ttl=30.0)

    def get(self, article_id):
        count_key = f"article:{article_id}:like_count"
        ver_key = f"{count_key}:ver"

        # 一次 Pipeline 取回值和版本,避免两次往返
        pipe = self.redis.pipeline()
        pipe.get(count_key)
        pipe.get(ver_key)
        raw_count, raw_ver = pipe.execute()

        remote_ver = int(raw_ver) if raw_ver else 0
        remote_count = int(raw_count) if raw_count else 0

        # 本地缓存命中且版本一致 → 直接用
        cached = self.cache.get(article_id, loader=lambda _: None)
        if cached is not None:
            local_count, local_ver = cached
            if local_ver == remote_ver:
                return local_count

        # 版本不一致 → 用远端的新值刷新本地缓存
        self.cache.set(article_id, (remote_count, remote_ver))
        return remote_count

    def like(self, article_id, user_id):
        """写路径:计数和版本一起自增,保证它们同批变化"""
        count_key = f"article:{article_id}:like_count"
        ver_key = f"{count_key}:ver"
        pipe = self.redis.pipeline()
        pipe.incr(count_key)
        pipe.incr(ver_key)
        new_count, new_ver = pipe.execute()
        self.cache.set(article_id, (new_count, new_ver))
        return new_count

关键点:版本号必须和计数一起变化。

如果计数和版本分两次写,中间会有一个窗口:计数已经是 101,版本还是 56。此时另一个实例读到”值 101、版本 56”,而它本地缓存是”值 100、版本 56”——版本相同,看起来是新鲜的,实际值已经过期。

用 Pipeline 把 INCR count 和 INCR ver 打包,两条命令在同一批里执行,窗口极小。更严格的做法是用 Lua 脚本,见《Lua 脚本》一章。

版本号方案解决了什么?

短 TTL:    只能"等 TTL 到期"
主动失效:  依赖消息送达,可能丢
版本号:    每次读都主动比对,不一致就用新值

版本号的本质是乐观校验:读的时候拿远端版本和本地版本比,不一致说明本地数据已经过时。与《乐观锁》一章的思路是同一个。

版本号方案没解决什么?

它没有消除一次网络往返。

每次读都要向 Redis 取一次版本号才能判断本地缓存是否新鲜——那本地缓存省下的往返去哪了?

实际省下的是数据读取那部分:命中时不需要反序列化大对象、不需要查数据库。对于点赞数这种小整数收益不明显,所以版本号方案更适合”数据量大、更新不频繁”的场景。

版本号会一直增长。

INCR 的版本号理论上会用尽 64 位整数,实际不可能。但为了可观测性,运维系统通常会定期记录快照。

三种方案对比:

维度短 TTL主动失效版本号
一致窗口TTL消息延迟一次读的时间
实现复杂度极低中中
是否需要额外往返否否是(取版本号)
消息丢失影响无本地缓存脏到 TTL 过期无(下次读自愈)
适用场景通用兜底高频写、低容忍延迟读多写少、数据大

实际建议:组合使用。

主方案:短 TTL(简单,覆盖大多数场景)
增强:  写热点高的数据加主动失效
兜底:  对一致性要求高的数据加版本号校验

性能对比

测试代码

测试要覆盖缓存的四种关键行为:命中与回源、TTL 过期、LRU 淘汰、一致性失效。

import unittest
from unittest.mock import MagicMock


class LocalCacheTestCase(unittest.TestCase):
    """本地缓存的单元测试"""

    def setUp(self):
        self.calls = []          # 记录回源次数
        self.cache = SimpleLocalCache(ttl=5.0)

    def loader(self, article_id):
        self.calls.append(article_id)
        return 100

    def test_hit_does_not_call_loader(self):
        """命中缓存:不回源"""
        self.assertEqual(self.cache.get(1, self.loader), 100)
        self.assertEqual(self.cache.get(1, self.loader), 100)

        self.assertEqual(len(self.calls), 1)   # 只回源了 1 次

    def test_miss_calls_loader(self):
        """未命中:回源并写入缓存"""
        value = self.cache.get(1, self.loader)

        self.assertEqual(value, 100)
        self.assertEqual(len(self.calls), 1)

    def test_expired_entry_triggers_reload(self):
        """TTL 过期:重新回源拿到新值"""
        self.cache.set(1, 100)
        self.cache.ttl = 0        # 让条目立即过期

        value = self.cache.get(1, self.loader)

        self.assertEqual(value, 100)
        self.assertEqual(len(self.calls), 1)   # 过期后回源了

    def test_invalidate_removes_entry(self):
        """主动失效:下次读必须回源"""
        self.cache.get(1, self.loader)
        self.cache.invalidate(1)
        self.cache.get(1, self.loader)

        self.assertEqual(len(self.calls), 2)   # 失效后又回源了一次


class LRUCacheTestCase(unittest.TestCase):
    """LRU 缓存的单元测试"""

    def setUp(self):
        self.cache = LRUCache(max_size=2, ttl=60.0)

    def test_evicts_least_recently_used(self):
        """超出容量:淘汰最久未使用的"""
        self.cache.set("a", 1)
        self.cache.set("b", 2)
        self.cache.get("a")        # a 变成"最近使用",b 才是最久未使用
        self.cache.set("c", 3)     # 触发淘汰

        self.assertEqual(self.cache.stats()["size"], 2)
        self.assertIsNone(self.cache._data.get("b"))    # b 被淘汰
        self.assertIsNotNone(self.cache._data.get("a"))
        self.assertIsNotNone(self.cache._data.get("c"))

    def test_size_never_exceeds_max(self):
        """容量上限:任何时候都不超过 max_size"""
        for i in range(100):
            self.cache.set(i, i)

        self.assertEqual(self.cache.stats()["size"], 2)


class VersionedCacheTestCase(unittest.TestCase):
    """版本号缓存的单元测试"""

    def setUp(self):
        self.redis = MagicMock()
        self.cache = VersionedCache(self.redis)
        self.remote_count = 100
        self.remote_ver = 57

    def fake_pipeline(self):
        pipe = MagicMock()
        pipe.execute.return_value = [str(self.remote_count), str(self.remote_ver)]
        self.redis.pipeline.return_value = pipe
        return pipe

    def test_same_version_uses_local_cache(self):
        """版本一致:直接用本地缓存"""
        self.fake_pipeline()
        self.cache.cache.set(1, (100, 57))

        value = self.cache.get(1)

        self.assertEqual(value, 100)

    def test_version_changed_refreshes_local_cache(self):
        """版本变了:用远端新值刷新本地缓存"""
        self.fake_pipeline()
        self.cache.cache.set(1, (100, 56))     # 本地版本落后

        value = self.cache.get(1)

        self.assertEqual(value, 100)
        # 本地缓存已被刷新到新版本
        self.assertEqual(self.cache.cache._data[1], (100, 57))


if __name__ == "__main__":
    unittest.main()

测试和真实行为的一致性检查表:

行为对应断言失败意味着
命中不回源test_hit_does_not_call_loader缓存没生效,Redis 压力不会下降
TTL 过期会回源test_expired_entry_triggers_reload过期条目被当成新鲜的返回
LRU 淘汰最久未用test_evicts_least_recently_used淘汰规则写错,热点数据被踢出
容量有上限test_size_never_exceeds_max内存会无限增长
版本变化会刷新test_version_changed_refreshes_local_cache一致性方案形同虚设

运行:

python -m unittest test_local_cache.py -v

实际效果

监控数据

本地缓存上线后:

热门文章访问:
- 本地缓存命中率:95%
- Redis QPS:从 5000 降到 250
- 响应时间:从 5ms 降到 0.1ms

应用服务器:
- CPU:从 45% 降到 20%
- 内存:增加约 100MB(可接受)

用户体验:
- 页面加载更快
- 点赞响应更流畅

适用场景

适合使用本地缓存的场景:
1. 热点数据(访问频繁)
2. 可容忍短暂不一致
3. 读多写少
4. 数据量不大

不适合使用本地缓存的场景:
1. 数据实时性要求高
2. 数据量大(内存有限)
3. 频繁更新
4. 需要强一致性

课后练习

练习 1

本地缓存和 Redis 缓存有什么区别?如何选择?

缓存架构设计性能

解题思路:

这道题问的是两级缓存的分工,要从读延迟、容量、一致性、网络开销四个维度对比,再按『数据是否热点、是否要求全局一致』给出选择规则。

详细步骤:

对比:

特性本地缓存Redis 缓存
读取速度极快(纳秒级)快(微秒级)
容量受应用服务器内存限制可扩展(集群)
一致性多实例不一致全局一致
网络开销无有
适用数据热点数据通用数据

选择建议:

使用本地缓存:
- 热点数据(如热门文章)
- 配置数据
- 不变数据
- 读多写少

使用 Redis 缓存:
- 通用数据
- 需要全局一致
- 数据量大
- 频繁更新

最终答案:

本地缓存读取是纳秒级、无网络开销,但容量受单机内存限制、多实例之间天然不一致;Redis 是微秒级、有网络开销,但可以集群扩容且全局一致。选择规则是:热点数据、配置数据、不变数据、读多写少的数据放本地缓存;通用数据、数据量大、频繁更新、需要全局一致的数据放 Redis。实践中两者配合使用,Redis 做权威数据源,本地缓存只做热点副本。

练习 2

如何实现本地缓存的”预热”?

缓存预热性能优化

解题思路:

这道题问的是本地缓存刚启动时是空的、首批请求全部回源打到 Redis 的问题,要从『什么时候预热、预热什么、怎么不拖慢启动』三个角度展开。

详细步骤:

预热方案:

预热步骤:

  1. 应用启动时读取本地缓存配置(容量上限、TTL 上限)
  2. 从热点榜单 / 配置中心拿到候选 key 列表
  3. 后台线程分批从 Redis 拉取并写入本地缓存
  4. 设置 TTL,避免预热数据永久驻留
  5. 预热未完成前,未命中的 key 走『回源 + 回填』而不是直接放行

注意事项:

  • 预热必须是异步的,不能阻塞应用启动
  • 预热流量要限速,避免和正常请求抢 Redis 连接
  • 预热失败要能降级:跳过该 key,等正常请求回源填充

最终答案:

预热在应用启动阶段由后台线程异步完成:先从配置中心或热点榜单拿到候选 key,分批从 Redis 拉取并写入本地缓存、设置 TTL,同时限制并发数与速率,避免预热流量挤占正常请求。生产上还要配合『预热完成后再放量』以及『Redis 侧变更时主动推送失效』,保证预热数据不会长期陈旧。

练习 3

本地缓存如何实现”防雪崩”?

缓存雪崩高可用

解题思路:

这道题问的是『大量 key 同时过期导致请求集中打到 Redis』,本质是过期时间的同步性问题,所以解法要落在『打散过期时刻 + 回源时不要同时放行』上。

详细步骤:

防雪崩方案:

雪崩成因:

  • 批量写入的 key 使用了相同 TTL,会在同一时刻集体过期
  • 回源请求全部打到 Redis(甚至穿透到数据库),下游被打垮
  • 连锁反应导致大面积超时

防雪崩措施:

  1. TTL 随机抖动:实际 TTL = 基础 TTL + random(0, 基础 TTL / 5)
  2. 逻辑过期:value 里带上过期时间戳,过期后仍返回旧值,由后台线程异步重建
  3. 单飞去重:同一个 key 并发回源只放行一个请求,其余等待它的结果
  4. 资源兜底:Redis 侧限流 + 熔断,必要时返回兜底值

最终答案:

防雪崩靠三件事:给 TTL 加随机抖动(如基础 TTL ± 20%),让同一批写入的 key 不会同时过期;过期后采用『逻辑过期 + 后台刷新』,旧值继续可读、由后台线程异步重建;再配合本地缓存的单飞(single-flight)去重与 Redis 侧的限流/熔断兜底。核心是让过期时刻散开,并且回源时不要把全部请求同时放行。

练习 4

如何监控本地缓存的命中率?

监控缓存性能指标

解题思路:

这道题问的是『怎么知道本地缓存到底有没有起作用』,要先把命中率的分子分母口径定义清楚,再补上能解释命中率变化的辅助指标和告警线。

详细步骤:

监控方案:

统计口径:

  • 分子:本地缓存命中并直接返回的请求数
  • 分母:所有经过本地缓存的读请求数
  • 注意排除因写操作主动失效引发的 miss,否则会低估真实命中率

建议上报的指标:

  1. 命中率(按 key 前缀分组)
  2. 缓存条目数与内存占用
  3. 回源 Redis 的 QPS 与平均耗时
  4. 淘汰次数(容量不足导致的 LRU 淘汰)

告警建议:

  • 命中率持续 5 分钟低于 70% → 告警
  • 回源 Redis QPS 突增 → 告警

最终答案:

用 Micrometer 或 Spring Cache 自带的缓存指标,也可以在缓存装饰器里自行埋点,统计 cacheGetTotal(含命中与未命中)并算出命中率 = 命中次数 / 总次数;同时上报缓存条目数与内存占用、回源 Redis 的 QPS 与耗时、淘汰次数等辅助指标,并对命中率跌破阈值告警。口径上要排除『写操作主动失效』造成的 miss,否则会低估真实命中率。

练习 5

多实例环境下,如何保证本地缓存的一致性?

分布式缓存一致性架构

解题思路:

这道题问的是本地缓存在多实例下天然不一致的问题,要先承认『做不到强一致』,再在四种最终一致方案之间按性能与复杂度取舍。

详细步骤:

方案对比:

方案实现复杂度一致性性能
短 TTL低最终一致中
Pub/Sub中最终一致高
版本号中最终一致高
定期刷新低最终一致低

推荐:短 TTL + Pub/Sub

最终答案:

多实例下本地缓存只能做到最终一致,可选短 TTL、Pub/Sub 广播失效、版本号校验、定期刷新四种方案。推荐『短 TTL + Pub/Sub』组合:TTL 保证即使变更消息丢失也会在有限时间内自动收敛,Pub/Sub 让变更能立刻广播到其他实例,把不一致窗口压到最小。版本号方案更严格但需要额外存储和比对成本。


思考题

  1. 本地缓存会占用应用服务器内存,如何控制内存使用?

  2. 如果本地缓存和 Redis 数据不一致,如何处理?

  3. 如何实现本地缓存的”按需加载”?

💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。

发现内容有问题?

告诉我们哪里需要改进。