
Hello,我是小兔大白糖。 读完能区分穿透/击穿/雪崩,并与 Cache Aside 失效策略对齐;补充已有一致性文的灾害侧。
缓存三害是穿透、击穿、雪崩;Cache Aside 解决的是读写职责,不是强一致银弹。
估计阅读时间:31 分钟
一句话结论是什么?
Redis 缓存策略的核心是 "三防一治" —— 防穿透(布隆过滤器拦截非法 Key)、防击穿(互斥锁/Lua 原子脚本保证单线程回源)、防雪崩(随机 TTL + 多级缓存 + 熔断降级)、治一致(Cache Aside + 延迟双删 + 消息补偿实现最终一致)。大 Key 与热 Key 治理是生产环境稳定性的生死线,RedLock 分布式锁在风控场景下需谨慎评估时钟漂移风险。
1. 这是什么?概念怎么定义
1.1 缓存世界的 "三大灾难"
在高并发系统中,缓存失效可能引发三种典型问题,它们看似相近,实则机理完全不同:
| 问题 | 定义 | 根本原因 | 影响范围 |
|---|---|---|---|
| 缓存穿透 (Cache Penetration) | 查询不存在的数据,缓存和 DB 都无命中,请求直接打到 DB | 恶意攻击(构造大量不存在的 Key)或业务 Bug | 持续高并发请求,DB 压力线性增长 |
| 缓存击穿 (Cache Breakdown) | 热点 Key 过期瞬间,大量并发请求同时回源 DB | 热点数据 TTL 到期,并发读未命中缓存 | 单点 DB 压力骤增,可能打挂单库 |
| 缓存雪崩 (Cache Avalanche) | 大量 Key 同时过期 或 Redis 集群宕机,所有请求回源 DB | 批量设置相同 TTL、缓存节点故障、网络分区 | 全量 DB 压力激增,引发级联故障 |
类比理解:
- 穿透 = 有人拿着假门票(不存在的 Key)反复闯景区入口,检票员(缓存)发现是假的,每次都去问经理(DB),经理被烦死。
- 击穿 = 明星演唱会最热门的座位信息刚好过期了,一瞬间几万人同时问售票系统(DB),系统崩溃。
- 雪崩 = 景区所有导游手册同时过期,所有游客同时涌向咨询台(DB),咨询台被挤爆。
1.2 分布式锁 RedLock
RedLock(Redis Distributed Lock)是 Redis 作者 antirez 提出的一种多主节点分布式锁算法,旨在解决单节点 Redis 作为分布式锁时的单点故障问题。
核心思想:在 N(通常 N=5)个完全独立的 Redis 主节点上尝试获取锁,当在**大多数节点(> N/2)**上成功获取锁,且总耗时小于锁的有效时间时,才认为加锁成功。
1.3 缓存一致性模型
缓存与数据库的一致性并非非黑即白,而是存在多种权衡:
| 模式 | 读策略 | 写策略 | 一致性级别 | 复杂度 |
|---|---|---|---|---|
| Cache Aside | 先读缓存,miss 则读 DB 并回填 | 先更新 DB,再删缓存 | 最终一致 | 低 |
| Read Through | 读缓存,miss 时由缓存组件自动读 DB 回填 | 直接写缓存,缓存同步写 DB | 最终一致 | 中 |
| Write Through | 同 Read Through | 同步写缓存 + 同步写 DB(写透) | 强一致 | 中 |
| Write Behind | 同 Read Through | 先写缓存,异步批量写 DB | 最终一致(窗口期长) | 高 |
类比:Cache Aside 就像你自己管理冰箱(缓存)和超市(DB),发现冰箱里没菜了再去超市买;Read Through 像请了一个管家(缓存中间件),你只管问管家要,管家自己决定要不要去超市;Write Through 像每次买菜都同时往冰箱和超市仓库各放一份;Write Behind 像先往冰箱放,等有空了再统一往超市仓库补货。
2. 核心原理是什么?
2.1 布隆过滤器:用空间换确定性的 "可能存在"
布隆过滤器(Bloom Filter)是一种概率型数据结构,用于高效判断一个元素 "一定不存在" 或 "可能存在"。
核心结构:
- 一个长度为 M 的 bit 数组(初始全 0)
- K 个独立的哈希函数
操作流程:
- 添加元素:对元素用 K 个哈希函数计算得到 K 个位置,将这些位置的 bit 置为 1
- 查询元素:对元素用相同的 K 个哈希函数计算,如果所有位置都是 1,则 "可能存在";如果任意位置是 0,则 "一定不存在"
误判率公式:
p ≈ (1 - e^(-kn/m))^k
其中:
- m = bit 数组长度
- n = 已插入元素数量
- k = 哈希函数数量
- p = 误判率(假阳性率)
最优 k = (m/n) * ln(2)
最优 m = -n * ln(p) / (ln(2)^2)
关键特性:布隆过滤器只能添加,不能删除(标准实现)。因为删除一个元素的某一位可能会影响其他元素的判断。如果需要删除,需使用 Counting Bloom Filter(每个位改为计数器,增加空间开销)。
2.2 缓存击穿:互斥锁 vs 逻辑过期
解决缓存击穿的两种主流方案:
| 方案 | 核心思想 | 优点 | 缺点 |
|---|---|---|---|
| 互斥锁(Mutex) | 热点 Key 过期时,只允许一个线程回源 DB,其他线程等待或返回降级数据 | 保证数据一致性,实现简单 | 其他线程可能阻塞或降级 |
| 逻辑过期(Logical TTL) | 缓存中永不过期,但存储一个逻辑过期时间字段,由后台线程异步更新 | 无阻塞,用户体验好 | 可能返回过期数据,需额外异步更新机制 |
互斥锁的实现核心:
- 使用 Redis
SET key value NX EX seconds原子命令获取锁 - 获取锁成功的线程查询 DB 并回填缓存
- 获取锁失败的线程:要么自旋重试,要么直接返回降级数据(如默认值、缓存中的旧值)
- 必须使用
Lua脚本或 Redisson 的看门狗机制保证锁的释放安全性
2.3 RedLock 算法步骤与争议
RedLock 算法流程
1. 获取当前时间戳 T1(毫秒级)
2. 依次向 N 个独立的 Redis 节点发送 SET resource_name random_value NX PX lock_timeout
3. 计算获取锁的总耗时 = 当前时间 - T1
4. 如果成功获取锁的节点数 >= N/2 + 1,且总耗时 < lock_timeout,则加锁成功
5. 如果加锁成功,锁的实际有效时间 = lock_timeout - 获取锁的耗时
6. 如果加锁失败,向所有节点发送 DEL 释放已获得的锁(脚本原子执行)
7. 业务执行完毕后,向所有节点发送 DEL 释放锁(需校验 random_value 防止误删)
Martin Kleppmann 的质疑(2016)
分布式系统专家 Martin Kleppmann 在《How to do distributed locking》中提出了对 RedLock 的核心质疑:
- 时钟漂移问题:RedLock 依赖各节点的系统时钟,如果某个节点的时钟被 NTP 同步回调,可能导致锁提前过期
- 网络延迟与 GC 停顿:客户端获取锁后发生长时间 GC 或网络分区,锁在 Redis 端已过期,但客户端认为自己仍持有锁
- fencing token 缺失:RedLock 没有提供类似 ZooKeeper 的单调递增序号,无法防止客户端延迟导致的 "脑裂写入"
结论:Martin 认为 RedLock 在**不需要容错(tolerate faults)**的场景下可用,但在严肃的生产环境中,更推荐使用 ZooKeeper 或 etcd 实现分布式锁,因为它们基于共识算法(ZAB / Raft),天然处理时钟和网络分区问题。
面试要点:回答 RedLock 时,必须主动提及 Martin Kleppmann 的质疑,展示你对分布式系统边界的深刻理解。在 大型加密货币交易所 风控场景下,如果必须使用 Redis 分布式锁,建议:Redisson 看门狗续期 + 业务幂等兜底 + 锁超时设置保守,而不是盲目信任 RedLock。
2.4 大 Key 与热 Key 治理
大 Key(Big Key)
界定标准(因业务而异,常见阈值):
- String 类型:value > 10KB(或 > 1MB 为严重)
- Hash / ZSet / List / Set:元素数量 > 5000(或总大小 > 1MB)
危害:
- 删除大 Key 时阻塞 Redis 主线程(单线程模型)
- 序列化/反序列化耗时高,占用大量网络带宽
- 主从同步延迟,可能导致主从数据不一致
- Redis 内存碎片化
治理手段:
- 拆分:将 Hash 拆分为多个小 Hash(如
user:1000:profile、user:1000:settings) - 压缩:使用 MessagePack、Protobuf 替代 JSON
- 异步删除:Redis 4.0+ 使用
UNLINK(非阻塞删除)替代DEL - 定期清理:设置合理的 TTL,避免 Key 无限增长
热 Key(Hot Key)
界定标准:单个 Key 的 QPS 超过 Redis 单实例的处理能力(通常 > 10万 QPS)或占实例总流量的显著比例(> 10%)。
危害:
- 单实例 CPU 打满,影响该实例上的所有 Key
- 主从复制延迟激增
- 集群模式下某分片成为热点,无法通过水平扩容解决
治理手段:
- 本地缓存(Local Cache):在应用层引入 Caffeine / Guava Cache,作为 Redis 的 L1 缓存,降低 Redis 压力
- Key 拆分:将热点 Key 拆分为多个副本(如
hot_key_0到hot_key_99),通过哈希分散读取 - 读写分离:热 Key 的读操作路由到从节点(但需注意主从延迟)
- 自动发现与告警:通过 Redis 的
MONITOR命令或代理层(如 Twemproxy、Codis)统计 Key 访问频率
2.5 缓存一致性:Cache Aside 的延迟双删
Cache Aside 是最常用的缓存模式,但在并发场景下仍可能出现不一致:
并发写 + 读导致的不一致:
时间点 线程A(写) 线程B(读)
T1 删除缓存
T2 缓存 miss,读 DB = 旧值 v1
T3 回填缓存 = v1
T4 更新 DB = 新值 v2
结果:缓存中是 v1(旧值),DB 中是 v2(新值),不一致!
延迟双删解决方案:
写操作:
1. 删除缓存
2. 更新 DB
3. 休眠一段时间(如 200ms,大于主从同步延迟 + 读操作耗时)
4. 再次删除缓存
原理:在 T3 回填旧值之后,通过第二次删除清空脏缓存,后续读取会回源 DB 获取最新值。
注意:延迟双删只能降低不一致概率,无法完全消除。在极端并发下,仍可能有不一致窗口。金融核心场景应配合 消息队列异步补偿 或 Binlog 监听(Canal/Maxwell) 实现缓存的可靠同步。
2.6 图解:互斥锁解决缓存击穿流程
2.7 图解:缓存与 DB 一致性方案全景
3. 怎么用?关键代码与配置
3.1 互斥锁防止缓存击穿(生产级实现)
@Component
@RequiredArgsConstructor
@Slf4j
public class CacheBreakdownProtector {
private final StringRedisTemplate redisTemplate;
private final ObjectMapper objectMapper;
// 锁前缀
private static final String LOCK_PREFIX = "lock:cache:";
// 锁等待时间
private static final long LOCK_WAIT_TIME_MS = 100;
// 锁持有时间(秒),需大于 DB 查询 + 缓存回填时间
private static final long LOCK_LEASE_TIME_SECONDS = 10;
// 缓存空值过期时间(防止穿透)
private static final long NULL_VALUE_TTL_SECONDS = 60;
/**
* 防击穿查询:带互斥锁 + 空值缓存 + 降级策略
*
* @param key 缓存Key
* @param clazz 返回值类型
* @param dbLoader DB回源函数
* @param ttlSeconds 正常缓存TTL
* @param <T> 泛型类型
* @return 查询结果,可能为null
*/
public <T> T getWithMutex(String key, Class<T> clazz,
Supplier<T> dbLoader, long ttlSeconds) {
// 1. 先查缓存
String cached = redisTemplate.opsForValue().get(key);
if (cached != null) {
// 命中缓存,处理空值占位符
if ("__NULL__".equals(cached)) {
return null;
}
try {
return objectMapper.readValue(cached, clazz);
} catch (JsonProcessingException e) {
log.error("缓存反序列化失败, key={}, class={}", key, clazz.getName(), e);
// 反序列化失败,删除脏数据,继续走回源
redisTemplate.delete(key);
}
}
// 2. 缓存未命中,尝试获取互斥锁
String lockKey = LOCK_PREFIX + key;
String lockValue = UUID.randomUUID().toString();
boolean locked = tryLock(lockKey, lockValue, LOCK_LEASE_TIME_SECONDS);
T result = null;
try {
if (locked) {
// 3. 获取锁成功,双重检查(防止其他线程已回填)
cached = redisTemplate.opsForValue().get(key);
if (cached != null && !"__NULL__".equals(cached)) {
return objectMapper.readValue(cached, clazz);
}
// 4. 回源 DB
log.info("缓存击穿,回源DB, key={}", key);
result = dbLoader.get();
// 5. 回填缓存(空值也缓存,防止穿透)
if (result != null) {
String json = objectMapper.writeValueAsString(result);
redisTemplate.opsForValue().set(key, json, ttlSeconds, TimeUnit.SECONDS);
} else {
// 缓存空值,防止恶意穿透
redisTemplate.opsForValue().set(key, "__NULL__",
NULL_VALUE_TTL_SECONDS, TimeUnit.SECONDS);
}
} else {
// 6. 获取锁失败,短暂等待后重试(或返回降级数据)
Thread.sleep(LOCK_WAIT_TIME_MS);
cached = redisTemplate.opsForValue().get(key);
if (cached != null && !"__NULL__".equals(cached)) {
return objectMapper.readValue(cached, clazz);
}
// 仍无缓存,返回降级数据(根据业务决定)
log.warn("获取缓存锁失败且重试无数据,返回null, key={}", key);
}
} catch (Exception e) {
log.error("缓存回源异常, key={}", key, e);
// 异常时直接回源,保证可用性(缓存降级)
result = dbLoader.get();
} finally {
// 7. 释放锁(Lua 原子脚本,防止误删)
if (locked) {
releaseLock(lockKey, lockValue);
}
}
return result;
}
/**
* 尝试获取分布式锁(SET NX EX)
*/
private boolean tryLock(String lockKey, String lockValue, long leaseTimeSeconds) {
Boolean success = redisTemplate.opsForValue()
.setIfAbsent(lockKey, lockValue, leaseTimeSeconds, TimeUnit.SECONDS);
return Boolean.TRUE.equals(success);
}
/**
* 释放锁(Lua 脚本保证原子性)
* 先判断 value 是否匹配,再删除,防止误删其他线程的锁
*/
private void releaseLock(String lockKey, String lockValue) {
String luaScript = """
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
else
return 0
end
""";
try {
redisTemplate.execute(new DefaultRedisScript<>( luaScript, Long.class),
Collections.singletonList(lockKey), lockValue);
} catch (Exception e) {
log.error("释放锁异常, lockKey={}", lockKey, e);
}
}
}3.2 布隆过滤器集成(Redisson)
@Component
@RequiredArgsConstructor
@Slf4j
public class RiskBloomFilter {
private final RedissonClient redissonClient;
// 预期插入元素数量
private static final long EXPECTED_INSERTIONS = 1_000_000L;
// 期望误判率
private static final double FALSE_POSITIVE_PROBABILITY = 0.01;
/**
* 初始化风控用户ID布隆过滤器
* 场景:拦截对不存在的用户ID的频繁查询(防止撞库/枚举攻击)
*/
public void initUserBloomFilter(Collection<Long> userIds) {
RBloomFilter<Long> bloomFilter = redissonClient.getBloomFilter("bf:risk:users");
// 初始化,只执行一次(生产环境应在启动时判断是否存在)
if (!bloomFilter.isExists()) {
bloomFilter.tryInit(EXPECTED_INSERTIONS, FALSE_POSITIVE_PROBABILITY);
}
// 批量添加已存在用户ID
for (Long userId : userIds) {
bloomFilter.add(userId);
}
log.info("布隆过滤器初始化完成, 已加载用户数量={}, 预计误判率={}",
userIds.size(), FALSE_POSITIVE_PROBABILITY);
}
/**
* 查询前先做布隆过滤器校验
* @return true = 可能存在(可继续查询),false = 一定不存在(直接拦截)
*/
public boolean mightContainUser(Long userId) {
RBloomFilter<Long> bloomFilter = redissonClient.getBloomFilter("bf:risk:users");
return bloomFilter.contains(userId);
}
/**
* 新用户注册后同步加入布隆过滤器
*/
public void addUser(Long userId) {
RBloomFilter<Long> bloomFilter = redissonClient.getBloomFilter("bf:risk:users");
bloomFilter.add(userId);
}
}
/**
* 风控查询服务:布隆过滤器 + 缓存 + DB 三级防护
*/
@Service
@RequiredArgsConstructor
public class RiskUserQueryService {
private final RiskBloomFilter bloomFilter;
private final CacheBreakdownProtector cacheProtector;
private final UserRepository userRepository;
public RiskProfile getUserRiskProfile(Long userId) {
// 第一层:布隆过滤器拦截(防止穿透)
if (!bloomFilter.mightContainUser(userId)) {
log.warn("布隆过滤器拦截非法用户ID查询, userId={}", userId);
throw new UserNotFoundException("用户不存在");
}
// 第二层:缓存 + 互斥锁防击穿
String cacheKey = "risk:profile:" + userId;
return cacheProtector.getWithMutex(cacheKey, RiskProfile.class,
() -> userRepository.findRiskProfileById(userId),
300); // 缓存5分钟
}
}3.3 延迟双删实现 Cache Aside
@Service
@RequiredArgsConstructor
@Slf4j
public class CacheAsideService {
private final StringRedisTemplate redisTemplate;
private final UserRepository userRepository;
private final ThreadPoolExecutor delayDeleteExecutor;
// 延迟双删的等待时间(毫秒),需根据业务实际主从延迟调整
private static final long DELAY_DELETE_MS = 500;
/**
* 更新用户风险等级(Cache Aside + 延迟双删)
*/
@Transactional
public void updateUserRiskLevel(Long userId, RiskLevel newLevel) {
String cacheKey = "risk:profile:" + userId;
// 1. 先删除缓存
redisTemplate.delete(cacheKey);
log.debug("第一次删除缓存, key={}", cacheKey);
// 2. 更新数据库
userRepository.updateRiskLevel(userId, newLevel);
log.info("更新用户风险等级, userId={}, newLevel={}", userId, newLevel);
// 3. 异步延迟双删(防止并发读导致脏数据回填)
delayDeleteExecutor.execute(() -> {
try {
Thread.sleep(DELAY_DELETE_MS);
redisTemplate.delete(cacheKey);
log.debug("延迟双删完成, key={}", cacheKey);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("延迟删除被中断, key={}", cacheKey, e);
}
});
}
/**
* Canal/Maxwell 监听 Binlog 后的缓存删除(最终兜底)
* 消费 Kafka 中的 Binlog 变更事件,删除对应缓存
*/
@KafkaListener(topics = "user-db-binlog", groupId = "cache-invalidator")
public void onBinlogChange(BinlogEvent event) {
if ("t_user_risk".equals(event.getTable()) &&
("UPDATE".equals(event.getType()) || "DELETE".equals(event.getType()))) {
Long userId = event.getAfterColumns().get("user_id");
String cacheKey = "risk:profile:" + userId;
redisTemplate.delete(cacheKey);
log.info("Binlog驱动缓存失效, userId={}, eventType={}", userId, event.getType());
}
}
}3.4 热 Key 本地缓存降级(Caffeine + Redis 二级缓存)
@Component
@Slf4j
public class HotKeyLocalCache {
// Caffeine 本地缓存:应对热 Key 的 L1 缓存
private final LoadingCache<String, RiskRuleConfig> localCache = Caffeine.newBuilder()
.maximumSize(10_000) // 最多缓存1万个Key
.expireAfterWrite(10, TimeUnit.SECONDS) // 本地缓存10秒过期(短于Redis)
.recordStats() // 开启统计
.build(this::loadFromRedis);
private final StringRedisTemplate redisTemplate;
private final ObjectMapper objectMapper;
public HotKeyLocalCache(StringRedisTemplate redisTemplate, ObjectMapper objectMapper) {
this.redisTemplate = redisTemplate;
this.objectMapper = objectMapper;
}
/**
* 获取风控规则配置(L1本地缓存 → L2 Redis缓存 → DB)
* 场景:风控规则配置在交易高峰时被频繁读取,属于典型热Key
*/
public RiskRuleConfig getRuleConfig(String ruleId) {
try {
return localCache.get("risk:rule:" + ruleId);
} catch (Exception e) {
log.error("获取规则配置失败, ruleId={}", ruleId, e);
// 降级:直接读DB
return loadFromDb(ruleId);
}
}
private RiskRuleConfig loadFromRedis(String cacheKey) {
String value = redisTemplate.opsForValue().get(cacheKey);
if (value != null) {
try {
return objectMapper.readValue(value, RiskRuleConfig.class);
} catch (JsonProcessingException e) {
log.error("Redis缓存反序列化失败, key={}", cacheKey, e);
}
}
// Redis miss,回源DB
String ruleId = cacheKey.replace("risk:rule:", "");
return loadFromDb(ruleId);
}
private RiskRuleConfig loadFromDb(String ruleId) {
// 模拟从DB加载
RiskRuleConfig config = mockDbLoad(ruleId);
if (config != null) {
try {
redisTemplate.opsForValue().set("risk:rule:" + ruleId,
objectMapper.writeValueAsString(config), 60, TimeUnit.SECONDS);
} catch (JsonProcessingException e) {
log.error("序列化规则配置失败, ruleId={}", ruleId, e);
}
}
return config;
}
// 规则更新后手动失效本地缓存
public void invalidateLocal(String ruleId) {
localCache.invalidate("risk:rule:" + ruleId);
}
private RiskRuleConfig mockDbLoad(String ruleId) {
// 实际实现中注入 Repository 查询
return new RiskRuleConfig(ruleId, "RULE_001", "交易金额限制", "...");
}
}
public record RiskRuleConfig(String ruleId, String code, String name, String expression) {}4. 业界怎么做?
4.1 阿里巴巴:双十一缓存击穿与热 Key 治理
背景:双十一是全球最大规模的流量洪峰,某热点商品(如 iPhone)的详情页缓存 Key 可能在瞬间被数百万次访问,一旦 TTL 到期,将直接击穿到 DB。
阿里解决方案:
-
热点 Key 自动发现:阿里内部开发了一套基于 Redis 代理层的 "热点探测系统"。通过在代理层(如 RedisProxy)统计每个 Key 的访问频率,实时识别 QPS 突增的热 Key。
-
本地缓存二级架构:发现热 Key 后,自动将该 Key 的 Value 下发到应用服务器的本地缓存(类似 Caffeine),并设置较短的本地 TTL(如 3-5 秒)。后续读请求优先读本地缓存,大幅降低 Redis 集群压力。
-
热点 Key 永不失效策略:对于已识别的热点 Key,后台启动一个独立线程(或定时任务)在 TTL 过期前主动刷新缓存(缓存预热 + 自动续期),避免 Key 真正过期。
-
缓存击穿的互斥锁优化:阿里在早期使用数据库行锁做互斥,但发现性能瓶颈后,改为 Redis SET NX + 短等待 + 快速失败 模式。获取锁失败的请求不阻塞等待,而是直接返回降级页面(如商品缩略信息),保证用户体验不降为零。
经验总结:阿里的核心经验是 "热点 Key 的治理要从被动防御转为主动发现"。通过实时监控 + 本地缓存 + 自动续期的组合拳,将缓存击穿的风险前置化解。
4.2 美团:Redis 大 Key 治理与智能删除
背景:美团外卖业务中,骑手的实时位置信息以 Hash 形式存储在 Redis 中。早期设计为 rider:location:{city_id},一个 Hash 里存了全城数万骑手的坐标。这个 Key 的大小达到了几十 MB,成为典型的大 Key。
问题:
- 每次更新单个骑手位置时,需要对整个 Hash 做序列化/反序列化,CPU 和网络开销巨大
- 某次运维人员误执行
HGETALL,导致 Redis 主线程阻塞 2 秒,期间所有请求延迟飙升 - 主从复制时,这个大 Key 的传输导致从节点长时间处于 SYNC 状态
治理方案:
-
Hash 拆分:将
rider:location:{city_id}拆分为多个小 Hash,按rider_id % 100分片:rider:loc:010:0 ~ rider:loc:010:99 (北京,100个分片)每个 Hash 仅存储约 1% 的骑手,大小从几十 MB 降到几百 KB。
-
大 Key 自动扫描:美团开发了内部工具,基于
redis-rdb-tools定期扫描 RDB 文件,生成大 Key 报表,自动推送给业务负责人。 -
非阻塞删除:所有删除操作统一使用
UNLINK(Redis 4.0+ 的异步删除),替代DEL。UNLINK将 Key 的内存回收工作放到后台 BIO 线程,不阻塞主线程。 -
压缩优化:将坐标从 JSON
[{"rider_id":123,"lat":39.9,"lng":116.3}]改为自定义二进制格式(8 bytes rider_id + 8 bytes lat + 8 bytes lng),体积减少约 60%。
美团总结:"大 Key 的发现容易,治理难。关键在于设计阶段就规避,而不是上线后拆弹。对于 Hash、ZSet 这类聚合结构,一定要提前规划分片策略。"
4.3 字节跳动:TikTok 推荐系统的 Write Behind 缓存一致性
背景:TikTok 的推荐系统需要实时反映用户的点赞、关注行为。这些写操作极高频(每秒数百万次),直接同步写 MySQL 无法承受。
方案:
- 使用 Write Behind 模式:写操作先进入 Redis(缓存 + 写缓冲),用户侧读操作直接读 Redis,保证极低延迟
- 后台使用 Flink 流处理 消费 Redis 的变更流(通过 Redis Streams 或自定义 Binlog),批量、异步地写入 TiDB(分布式数据库)
- 对于 "缓存丢失后的读请求",使用 Read Through 模式:应用层只读缓存,缓存 miss 时由中间件自动从 TiDB 回填
一致性保障:
- 容忍秒级不一致(社交点赞场景允许短暂延迟)
- 对强一致性要求高的场景(如账户资金),单独走同步写链路,不走 Write Behind
- 使用 消息队列(Kafka) 做写缓冲的持久化兜底,防止 Redis 宕机丢数据
5. 业务场景怎么对照?
5.1 风控/Risk 场景的缓存策略矩阵
| 风控场景 | 数据特点 | 推荐策略 | 一致性要求 |
|---|---|---|---|
| 用户风险画像 | 读多写少,单个用户数据量中等 | Cache Aside + 延迟双删 + Binlog兜底 | 最终一致(秒级) |
| 风控规则配置 | 全局热 Key,极少变更 | 本地缓存(L1) + Redis(L2) + DB,主动刷新 | 最终一致(可容忍分钟级) |
| 黑白名单查询 | 极高频读,数据量小 | 全量本地缓存(Caffeine)+ 定时刷新,不走 Redis | 最终一致(分钟级) |
| 交易频控计数器 | 极高频读写,数据有效期短 | Redis String + Lua 原子脚本,不缓存到 DB | 强一致(Redis 单机内) |
| 风险事件详情 | 写一次读多次,ID 连续递增 | 布隆过滤器防穿透 + Cache Aside | 最终一致 |
| 设备指纹库 | 数据量大,单次查询结果大 | 布隆过滤器预过滤 + 分片缓存 + 压缩存储 | 最终一致 |
5.2 常见误区 vs 正确做法
| 误区 | 正确做法 |
|---|---|
| ❌ "缓存穿透就是缓存击穿" | ✅ 穿透是 DB 和缓存都无数据;击穿是 缓存过期瞬间的热点 Key;机理和解决方案完全不同 |
| ❌ "RedLock 是完美的分布式锁方案" | ✅ RedLock 有时钟漂移和网络分区的固有风险,严肃场景优先选 ZooKeeper/etcd,Redis 锁需配合业务幂等兜底 |
| ❌ "延迟双删能保证缓存强一致" | ✅ 延迟双删只能降低不一致概率,无法消除。金融核心场景需配合 Binlog 监听 + 消息补偿 |
| ❌ "大 Key 直接 DEL 删除就行" | ✅ 生产环境必须用 UNLINK 异步删除,或直接 清空 + 异步淘汰。DEL 大 Key 会导致 Redis 主线程阻塞数秒 |
| ❌ "热 Key 加机器就能解决" | ✅ 热 Key 是单 Key 访问集中,水平扩容无效(同一 Key 仍落在同一分片)。必须用 本地缓存 或 Key 拆分 |
| ❌ "所有数据都要缓存" | ✅ 缓存只适用于 读多写少、容忍短暂不一致 的数据。实时风控决策(如是否拦截交易)应直接读内存/本地缓存,不走 Redis 网络 I/O |
| ❌ "缓存 TTL 设置统一值" | ✅ 必须设置 基础 TTL + 随机偏移量(如 TTL = 300 + random(0, 60)),防止大量 Key 同时过期引发雪崩 |
5.3 选型建议
When to use 布隆过滤器:
- 数据量极大(千万级以上),需要快速判断 "是否存在"
- 查询 Key 的合法性格校验(如用户ID、订单号是否有效)
- 可容忍极小概率的误判(假阳性)
When NOT to use 布隆过滤器:
- 需要删除元素(标准布隆过滤器不支持)
- 误判不可接受(如资金类操作)
- 数据量很小(百万级以下直接用 HashSet 或 Redis Set)
When to use 本地缓存(Caffeine/Guava):
- 存在明确的热 Key(如全局配置、黑名单)
- 对延迟极其敏感(< 1ms)
- 数据更新频率低,可容忍秒级不一致
When to use Write Behind:
- 写操作极高频(如点赞、浏览计数)
- 业务可容忍秒级到分钟级的不一致
- 有完善的消息队列和流处理兜底链路
6. 高频问题怎么答?
Q1: RedLock 被 Martin Kleppmann 质疑的核心点是什么?生产环境应该怎么选?
简要答案:
Martin 的核心质疑有三点:
- 时钟依赖:RedLock 假设各 Redis 节点的时钟是同步的,但 NTP 同步可能导致时钟回调,使锁提前过期
- 客户端 GC 停顿:客户端获取锁后发生长时间 GC,锁在 Redis 端已过期,但客户端仍认为自己持有锁
- 缺乏 Fencing Token:RedLock 没有提供单调递增的 Token,无法防止 "客户端延迟导致的数据覆盖"
生产环境选择:
- 强一致要求(如资金扣减、库存扣减):优先使用 ZooKeeper(ZAB 协议)或 etcd(Raft 协议),它们的锁基于共识算法,天然处理网络分区
- 最终一致要求(如缓存刷新、任务调度):Redis 分布式锁(Redisson)足够,但需配合:
- 看门狗自动续期(避免业务未完成锁过期)
- 业务层幂等校验(防止重复执行)
- 锁超时设置保守(> 业务最大执行时间)
Q2: 缓存一致性真的能做到强一致吗?如果做不到,大型加密货币交易所 这种交易所怎么保证数据正确?
简要答案:
缓存与 DB 之间做不到绝对的强一致,因为网络延迟和并发写入的本质决定了总存在一个不一致窗口。
大型加密货币交易所 等交易所的应对策略是 "分层一致性":
- 核心资金数据(余额、持仓):不走缓存,直接读写 DB(或内存数据库如 Aeron/MemoryDB),通过悲观锁保证强一致
- 非核心数据(用户配置、风险评分、历史记录):走 Cache Aside + 延迟双删 + Binlog 兜底,接受秒级不一致
- 读多写少的配置类数据:本地缓存 + 定时刷新,接受分钟级不一致
- 关键操作(如下单、划转):采用 "先写 DB,再异步同步" 的反向思路,缓存只作为读取加速,不参与写决策
Q3: 布隆过滤器的误判率如何控制?如果误判导致合法请求被拦截怎么办?
简要答案:
误判率由三个参数决定:bit 数组长度 m、哈希函数数量 k、已插入元素数量 n。
控制方法:
- 预估容量:根据业务增长预留 2-3 倍空间,避免 n 超过预期导致误判率飙升
- 调整 m 和 k:使用公式
m = -n * ln(p) / (ln(2)^2)和k = m/n * ln(2)计算最优参数 - 双层校验:布隆过滤器返回 "可能存在" 后,再查一次 Redis/DB 做精确校验。布隆过滤器的价值在于拦截 "一定不存在" 的请求,而非替代精确查询
风控场景应对:
- 在风控场景中,布隆过滤器用于拦截明显不存在的用户/设备 ID,误判后多一次 DB 查询的成本是可接受的
- 如果误判可能导致严重后果(如资金损失),则不应使用布隆过滤器,改用精确存储(Redis Set / Hash)
Q4: 缓存雪崩发生时,除了随机 TTL,还有哪些应急手段?
简要答案:
缓存雪崩的应急手段分为 预防 和 应急 两个层面:
预防:
- 随机 TTL:基础 TTL + 随机偏移(如
300 + random(0, 60)) - 多级缓存:本地缓存(L1)+ Redis 集群(L2)+ DB,即使 L2 失效,L1 仍能扛住部分流量
- 缓存预热:在高峰期前(如双十一零点前)主动将热点数据加载到缓存
- 熔断降级:当 DB 负载超过阈值时,自动熔断回源请求,返回降级数据(如静态页面、默认值)
应急:
- 快速扩容:Redis 集群水平扩容(增加分片),分散请求压力
- 限流:在接入层(Nginx / API Gateway)对请求限流,保护 DB 不被打垮
- 手动刷新:运维人员手动触发热点 Key 的缓存重建
- 主从切换:如果是 Redis 主节点宕机导致的雪崩,快速执行主从切换(Sentinel / Cluster 自动完成)
Q5: 大 Key 的界定标准是什么?如何在生产环境快速发现大 Key?
简要答案:
界定标准(各公司略有不同,以下为常见阈值):
| 数据类型 | 大 Key 阈值 | 严重阈值 |
|---|---|---|
| String | value > 10KB | > 1MB |
| Hash | 元素数 > 5000 或总大小 > 1MB | > 10MB |
| List | 元素数 > 5000 或总大小 > 1MB | > 10MB |
| Set | 元素数 > 5000 或总大小 > 1MB | > 10MB |
| ZSet | 元素数 > 5000 或总大小 > 1MB | > 10MB |
发现手段:
redis-cli --bigkeys(线上慎用):对线上实例执行全量扫描,会阻塞主线程。建议在从节点执行,或低峰期执行redis-rdb-tools:离线分析 RDB 文件,生成大 Key 报表,无阻塞风险MEMORY USAGE key(Redis 4.0+):精确计算单个 Key 的内存占用- 代理层统计:在 Twemproxy / Codis / Redis Cluster Proxy 层统计每个 Key 的流量和大小
- 监控告警:基于 Info 命令的
used_memory和客户端连接数,结合业务 Key 前缀做聚合监控
Q6: 热 Key 的探测除了 Redis 代理层,还有其他方法吗?本地缓存与 Redis 的一致性怎么保证?
简要答案:
热 Key 探测方法:
- Redis Monitor 命令:
MONITOR可以实时打印所有命令,但性能开销极大(建议采样,如只监控 1% 的请求) - Redis Hot Keys 特性:Redis 4.0+ 提供了
redis-cli --hotkeys(基于 LFU 算法统计访问频率) - 客户端采样:在应用层的 Redis Client(如 Lettuce、Jedis)中埋点,统计每个 Key 的访问频率,上报到监控系统
- 网络抓包:通过 eBPF 或 tcpdump 抓包分析 Redis 协议,统计 Key 频率(无侵入,但实现复杂)
本地缓存与 Redis 的一致性:
- 短 TTL:本地缓存 TTL 设置为 Redis TTL 的 1/5 ~ 1/10(如 Redis 60 秒,本地 5-10 秒),保证本地不会长期过期
- 主动失效:数据更新时,通过 消息队列(如 Redis Pub/Sub、RocketMQ) 广播失效消息,各应用节点收到后清空本地缓存
- 版本号机制:缓存 Value 中携带版本号,读取时比较本地版本号与 Redis 版本号,低版本则刷新
- 接受不一致:对于配置类、规则类数据,业务上可容忍秒级不一致,无需强同步
Q7: 在 大型加密货币交易所 全球化多地域部署下,Redis 缓存架构应该如何设计?
简要答案:
大型加密货币交易所 的全球化部署对缓存架构提出了特殊挑战:
- 就近访问:每个地域部署独立的 Redis Cluster,用户请求优先访问本地域缓存,降低跨地域网络延迟(> 100ms)
- 跨地域同步:对于全局一致性要求的数据(如用户黑名单、系统开关),使用 Redis CRDT(Conflict-free Replicated Data Types) 或 主从复制 + 消息队列补偿 实现跨地域同步
- 数据分片策略:按用户 ID 分片,保证同一用户的数据始终路由到同一地域的同一分片,避免跨分片事务
- 灾备切换:每个地域的 Redis Cluster 配备跨地域从节点,主地域故障时可快速提升从节点为主节点
- 风控特殊考虑:实时风控决策对延迟极其敏感(< 50ms),应在应用层本地缓存风控规则和常用特征,减少对跨地域 Redis 的依赖
7. 还要关联学什么?
- C4 - Redis 数据结构:理解底层结构(SDS/ziplist/quicklist)是识别大 Key 的前提
- B3 - 分布式锁:RedLock 与 ZooKeeper/etcd 锁的对比与选型
- B5 - 限流与熔断:缓存雪崩时的应急保护手段(Sentinel / Hystrix)
- E2 - 实时风控系统:风控系统对缓存延迟和一致性的特殊要求
- D1 - Kafka 架构:Binlog 监听(Canal)通过 Kafka 做缓存失效的异步补偿