本地缓存
分片计数方案上线后,系统性能提升了很多。
但我发现了一个有趣的现象:
监控数据:
热门文章(前 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 | 最小 | 最弱 |
| L2 | Redis | ~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 的问题,要从『什么时候预热、预热什么、怎么不拖慢启动』三个角度展开。
详细步骤:
预热方案:
预热步骤:
- 应用启动时读取本地缓存配置(容量上限、TTL 上限)
- 从热点榜单 / 配置中心拿到候选 key 列表
- 后台线程分批从 Redis 拉取并写入本地缓存
- 设置 TTL,避免预热数据永久驻留
- 预热未完成前,未命中的 key 走『回源 + 回填』而不是直接放行
注意事项:
- 预热必须是异步的,不能阻塞应用启动
- 预热流量要限速,避免和正常请求抢 Redis 连接
- 预热失败要能降级:跳过该 key,等正常请求回源填充
最终答案:
预热在应用启动阶段由后台线程异步完成:先从配置中心或热点榜单拿到候选 key,分批从 Redis 拉取并写入本地缓存、设置 TTL,同时限制并发数与速率,避免预热流量挤占正常请求。生产上还要配合『预热完成后再放量』以及『Redis 侧变更时主动推送失效』,保证预热数据不会长期陈旧。
练习 3
本地缓存如何实现”防雪崩”?
解题思路:
这道题问的是『大量 key 同时过期导致请求集中打到 Redis』,本质是过期时间的同步性问题,所以解法要落在『打散过期时刻 + 回源时不要同时放行』上。
详细步骤:
防雪崩方案:
雪崩成因:
- 批量写入的 key 使用了相同 TTL,会在同一时刻集体过期
- 回源请求全部打到 Redis(甚至穿透到数据库),下游被打垮
- 连锁反应导致大面积超时
防雪崩措施:
- TTL 随机抖动:实际 TTL = 基础 TTL + random(0, 基础 TTL / 5)
- 逻辑过期:value 里带上过期时间戳,过期后仍返回旧值,由后台线程异步重建
- 单飞去重:同一个 key 并发回源只放行一个请求,其余等待它的结果
- 资源兜底:Redis 侧限流 + 熔断,必要时返回兜底值
最终答案:
防雪崩靠三件事:给 TTL 加随机抖动(如基础 TTL ± 20%),让同一批写入的 key 不会同时过期;过期后采用『逻辑过期 + 后台刷新』,旧值继续可读、由后台线程异步重建;再配合本地缓存的单飞(single-flight)去重与 Redis 侧的限流/熔断兜底。核心是让过期时刻散开,并且回源时不要把全部请求同时放行。
练习 4
如何监控本地缓存的命中率?
解题思路:
这道题问的是『怎么知道本地缓存到底有没有起作用』,要先把命中率的分子分母口径定义清楚,再补上能解释命中率变化的辅助指标和告警线。
详细步骤:
监控方案:
统计口径:
- 分子:本地缓存命中并直接返回的请求数
- 分母:所有经过本地缓存的读请求数
- 注意排除因写操作主动失效引发的 miss,否则会低估真实命中率
建议上报的指标:
- 命中率(按 key 前缀分组)
- 缓存条目数与内存占用
- 回源 Redis 的 QPS 与平均耗时
- 淘汰次数(容量不足导致的 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 让变更能立刻广播到其他实例,把不一致窗口压到最小。版本号方案更严格但需要额外存储和比对成本。
-
本地缓存会占用应用服务器内存,如何控制内存使用?
-
如果本地缓存和 Redis 数据不一致,如何处理?
-
如何实现本地缓存的”按需加载”?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
