缓存三害:穿透、击穿、雪崩与 Cache Aside 边界

缓存三害:穿透、击穿、雪崩与 Cache Aside 边界

Hello,我是小兔大白糖。 读完能区分穿透/击穿/雪崩,并与 Cache Aside 失效策略对齐;补充已有一致性文的灾害侧。

缓存三害是穿透、击穿、雪崩;Cache Aside 解决的是读写职责,不是强一致银弹。

估计阅读时间:31 分钟

穿透、击穿、雪崩三害
穿透、击穿、雪崩三害 · 点击查看 SVG 原图

一句话结论是什么?

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 个独立的哈希函数

操作流程:

  1. 添加元素:对元素用 K 个哈希函数计算得到 K 个位置,将这些位置的 bit 置为 1
  2. 查询元素:对元素用相同的 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 的核心质疑:

  1. 时钟漂移问题:RedLock 依赖各节点的系统时钟,如果某个节点的时钟被 NTP 同步回调,可能导致锁提前过期
  2. 网络延迟与 GC 停顿:客户端获取锁后发生长时间 GC 或网络分区,锁在 Redis 端已过期,但客户端认为自己仍持有锁
  3. 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 图解:互斥锁解决缓存击穿流程

redis cache aside hazards · 图 2
redis cache aside hazards · 图 2 · 点击查看 SVG 原图

2.7 图解:缓存与 DB 一致性方案全景

redis cache aside hazards · 图 3
redis cache aside hazards · 图 3 · 点击查看 SVG 原图

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。

阿里解决方案:

  1. 热点 Key 自动发现:阿里内部开发了一套基于 Redis 代理层的 "热点探测系统"。通过在代理层(如 RedisProxy)统计每个 Key 的访问频率,实时识别 QPS 突增的热 Key。

  2. 本地缓存二级架构:发现热 Key 后,自动将该 Key 的 Value 下发到应用服务器的本地缓存(类似 Caffeine),并设置较短的本地 TTL(如 3-5 秒)。后续读请求优先读本地缓存,大幅降低 Redis 集群压力。

  3. 热点 Key 永不失效策略:对于已识别的热点 Key,后台启动一个独立线程(或定时任务)在 TTL 过期前主动刷新缓存(缓存预热 + 自动续期),避免 Key 真正过期。

  4. 缓存击穿的互斥锁优化:阿里在早期使用数据库行锁做互斥,但发现性能瓶颈后,改为 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 状态

治理方案:

  1. Hash 拆分:将 rider:location:{city_id} 拆分为多个小 Hash,按 rider_id % 100 分片:

    rider:loc:010:0  ~ rider:loc:010:99  (北京,100个分片)
    

    每个 Hash 仅存储约 1% 的骑手,大小从几十 MB 降到几百 KB。

  2. 大 Key 自动扫描:美团开发了内部工具,基于 redis-rdb-tools 定期扫描 RDB 文件,生成大 Key 报表,自动推送给业务负责人。

  3. 非阻塞删除:所有删除操作统一使用 UNLINK(Redis 4.0+ 的异步删除),替代 DEL。UNLINK 将 Key 的内存回收工作放到后台 BIO 线程,不阻塞主线程。

  4. 压缩优化:将坐标从 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 的核心质疑有三点:

  1. 时钟依赖:RedLock 假设各 Redis 节点的时钟是同步的,但 NTP 同步可能导致时钟回调,使锁提前过期
  2. 客户端 GC 停顿:客户端获取锁后发生长时间 GC,锁在 Redis 端已过期,但客户端仍认为自己持有锁
  3. 缺乏 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 阈值严重阈值
Stringvalue > 10KB> 1MB
Hash元素数 > 5000 或总大小 > 1MB> 10MB
List元素数 > 5000 或总大小 > 1MB> 10MB
Set元素数 > 5000 或总大小 > 1MB> 10MB
ZSet元素数 > 5000 或总大小 > 1MB> 10MB

发现手段:

  1. redis-cli --bigkeys(线上慎用):对线上实例执行全量扫描,会阻塞主线程。建议在从节点执行,或低峰期执行
  2. redis-rdb-tools:离线分析 RDB 文件,生成大 Key 报表,无阻塞风险
  3. MEMORY USAGE key(Redis 4.0+):精确计算单个 Key 的内存占用
  4. 代理层统计:在 Twemproxy / Codis / Redis Cluster Proxy 层统计每个 Key 的流量和大小
  5. 监控告警:基于 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 缓存架构应该如何设计?

简要答案:

大型加密货币交易所 的全球化部署对缓存架构提出了特殊挑战:

  1. 就近访问:每个地域部署独立的 Redis Cluster,用户请求优先访问本地域缓存,降低跨地域网络延迟(> 100ms)
  2. 跨地域同步:对于全局一致性要求的数据(如用户黑名单、系统开关),使用 Redis CRDT(Conflict-free Replicated Data Types) 或 主从复制 + 消息队列补偿 实现跨地域同步
  3. 数据分片策略:按用户 ID 分片,保证同一用户的数据始终路由到同一地域的同一分片,避免跨分片事务
  4. 灾备切换:每个地域的 Redis Cluster 配备跨地域从节点,主地域故障时可快速提升从节点为主节点
  5. 风控特殊考虑:实时风控决策对延迟极其敏感(< 50ms),应在应用层本地缓存风控规则和常用特征,减少对跨地域 Redis 的依赖

7. 还要关联学什么?

  • C4 - Redis 数据结构:理解底层结构(SDS/ziplist/quicklist)是识别大 Key 的前提
  • B3 - 分布式锁:RedLock 与 ZooKeeper/etcd 锁的对比与选型
  • B5 - 限流与熔断:缓存雪崩时的应急保护手段(Sentinel / Hystrix)
  • E2 - 实时风控系统:风控系统对缓存延迟和一致性的特殊要求
  • D1 - Kafka 架构:Binlog 监听(Canal)通过 Kafka 做缓存失效的异步补偿