1. 项目背景
1.1 事故回放
凌晨三点,值班电话响起——商品详情接口大面积超时。登上监控一看,Redis 实例内存线已经横在 maxmemory 上不动了,evicted_keys 每分钟涨 8000,命中率从 94% 跌到 51%。数据库 QPS 被回源请求打满,连接池瞬间耗尽。
运维紧急扩容,把 maxmemory 从 32GB 调到 48GB。但调完之后 used_memory 只用了 35GB,实例却被 OOM Killer 杀掉了——因为 RSS(实际占用物理内存)已经 51GB,超过了容器的 48GB limit。碎片率 mem_fragmentation_ratio 高达 1.47,再加上 AOF rewrite 期间的 copy-on-write 内存,直接把进程推进了死亡线。
事后复盘暴露出五个治理盲区:
- 淘汰策略选的 volatile-lru,但 60% 的 key 没有设 TTL——内存满了只能写失败,根本淘汰不了。
- 碎片率持续 3 个月高于 1.4,团队只盯着 used_memory——没人看 RSS 和实际物理内存。
- maxmemory 贴容器 limit 配的,没留 fork 余量——BGSAVE 或 AOF rewrite 一触发就 OOM。
- 容量模型只有"QPS × 平均 value 大小",没算 dict 开销、过期字典、客户端缓冲区。
- 大 key 删除用了 DEL 而不是 UNLINK,主线程阻塞,延迟抖动没人追踪。
1.2 内存治理不是加机器
Redis 的内存是一个多租户的有限空间。它不是一个大池子随便装,而是由几十种消费者共同抢占:
| 内存消费者 | 占比(典型值) | 是否可观测 | 是否可控制 |
|---|---|---|---|
| 业务 key-value 数据 | 60-75% | used_memory_dataset |
TTL + maxmemory + 淘汰策略 |
| key 本身(字典开销) | 8-15% | MEMORY STATS |
key 命名长度、数量 |
| 过期字典 | 2-5% | MEMORY STATS |
TTL 比例 |
| 复制缓冲区 | 5-15% | INFO replication |
client-output-buffer-limit |
| 客户端输出缓冲区 | 2-10% | CLIENT LIST |
同上 |
| AOF rewrite 缓冲区 | 零时占用 | INFO persistence |
auto-aof-rewrite-percentage |
| fork COW 内存 | 零时占用 | 系统 /proc/pid/smaps |
减少写时复制 |
| jemalloc 碎片 | 0-50% | mem_fragmentation_ratio |
active defrag |
如果其中任何一项失控,都会把实例推向 OOM。内存治理不是"满了就扩",而是"分类、限额、观测、演练"的持续工程。
1.3 本章目标
以电商平台 10 亿次请求/天规模的商品缓存和用户状态缓存为背景,完成以下治理闭环:
- 建立 Redis 内存模型——理解 used_memory、RSS、碎片、fork COW 之间的数学关系。
- 八种淘汰策略深度对比——不止看名字,要看算法实现、适用场景和副作用。
- 碎片从诊断到治理——
MEMORY STATS、MEMORY DOCTOR、active defrag、MEMORY PURGE。 - 容量规划五步法——从业务模型倒推 Redis 规格、maxmemory、安全水位和扩容阈值。
- 产线可用的 Java 内存监控组件和自动化治理脚本。
2. 项目设计
2.1 第一幕:淘汰策略——不是随便选一个 LRU
小胖:"淘汰策略我熟,满了就扔最久没用的,LRU 嘛。Redis 不是就那几个选项?allkeys-lru 一把梭。"
小白:"但我发现线上有个诡异现象——我们配的 volatile-lru,内存满之后新的写入直接报错 OOM command not allowed。日志里能看到 evicted_keys 是 0。"
大师:"因为你有一半 key 没设 TTL。volatile-* 策略只在设置了过期时间的 key 中淘汰。如果 60% 的 key 没有 TTL,Redis 只能在剩下的 40% 里找——'易失键集'用完了就无法淘汰,剩下的空间只能拒绝写入。"
淘汰策略四象限:
对所有 key 仅对设了 TTL 的 key
┌─────────────────┬──────────────────────┐
LRU │ allkeys-lru │ volatile-lru │
│(近似LRU淘汰) │(在volatile中近似LRU) │
├─────────────────┼──────────────────────┤
LFU │ allkeys-lfu │ volatile-lfu │
│(近似LFU淘汰) │(在volatile中近似LFU) │
├─────────────────┼──────────────────────┤
Random │ allkeys-random │ volatile-random │
│(随机淘汰) │(在volatile中随机淘汰) │
├─────────────────┼──────────────────────┤
TTL │ — │ volatile-ttl │
│ │(优先淘汰快过期的) │
└─────────────────┴──────────────────────┘
noeviction: 不淘汰→写入直接报错
技术映射:
allkeys-*适合全缓存场景(纯缓存,数据都可丢失)。volatile-*适合混合场景(部分数据不可丢,但要给它们设 TTL)。noeviction适合配置中心、分布式锁、计数器——写入不能被悄悄丢弃。- LRU 关注"最近访问时间";LFU 关注"访问频率"——热点稳定的场景用 LFU 更好。
2.2 第二幕:LRU vs LFU——不是一个只看时间一个看次数这么简单
小胖:"LRU 就是最近没用过的踢出去,LFU 就是用得少的踢出去。这不挺简单?"
大师:"别忘了一个关键差别——LRU 只看'最近有没有被访问',LFU 看'历史上被访问得多不多'。这个差别在冷热交替场景下会被放大。"
小白:"比如一个新商品突然爆火?"
大师:"对。假设缓存在电商大促前预热了 5000 个商品,每个商品在预热脚本里都被写入了一次。如果用的是 LRU,这 5000 个商品刚被写入,LRU 时钟很新,短时间内不会被淘汰——即使它们从来没被真实用户访问过。如果用的是 LFU,这 5000 个商品写入时 counter 只有 1,投票数很低——当真正热门商品的 counter 涨到上百时,这些预热商品很快就会被淘汰。"
场景对比: 电商预热 5000 个 SKU,实际只有 200 个是爆款
allkeys-lru:
预热 → 5000 个 key 的 LRU 时钟被刷新
大促 → 200 个爆款被频繁访问,时钟持续刷新
→ 4800 个冷门 SKU 的时钟也很"新"
→ 内存满时:冷门 SKU 很难被淘汰(因为时钟不旧)
→ 反而可能淘汰其他真正更旧的数据
allkeys-lfu:
预热 → 5000 个 key 的 LFU counter 初始值 ≈ 5
大促 → 200 个爆款 counter 快速增长到 50-255
→ 4800 个冷门 SKU counter 保持在 5
→ 内存满时:冷门 SKU 优先被淘汰
→ 爆款被保护
结论: LFU 更适合热点明显的场景;LRU 更适合冷热交替频繁的场景
技术映射:LRU 的"时间局部性"假设在批量预热场景下会失效。LFU 的"频率"指标更能反映真实的业务热度,但 counter 衰减需要时间——不适合冷热快速切换的秒杀场景。
小胖追问:"maxmemory-samples 是干什么的?默认 5,调大调小有什么影响?"
大师:"Redis 的 LRU/LFU 都是近似算法,不是精确的全局排序。每次淘汰时,它随机取 maxmemory-samples 个 key,在这 N 个里面找一个最差的淘汰。sample 越大越接近精确 LRU/LFU,但 CPU 开销也更大。Redis 作者建议 10——这是精度和性能的平衡点。如果实例 key 数量非常大且淘汰频繁,可以提高 sample 来减少'误淘汰好 key'的概率。"
2.3 第三幕:碎片——Redis 没偷吃内存,是 jemalloc 的锅
小胖:"used_memory 2GB,used_memory_rss 3.2GB——这 1.2GB 的碎片是 Redis 偷吃的吗?"
大师:"不是偷吃,是分配器留的'坑'。jemalloc 把内存分成不同大小的 slab class,比如 8B、16B、32B...8KB。当你删了一个 4KB 的大 string,又写入一个 512B 的小 string——这个 512B 可能没法放进原来 4KB 的空洞里(太小了),jemalloc 只能分配一个新的 512B slab。原来的 4KB 空洞就变成了碎片。"
小白:"所以碎片率高的根因是——不同大小的对象混在一起,释放后形成的空洞没法被不同大小的新对象利用?"
大师:"精准。三种典型场景会导致碎片飙升:
- 大小混合:大量不同大小的 key 频繁创建和删除——每个 slab class 都有碎片。
- 大 key 删除:删除一个 100MB 的 String 后,释放的 100MB 拆成很多个小块,短时间内难以复用。
- AOF rewrite / BGSAVE 期间:fork 子进程期间父进程大量写入,COW 机制复制内存页——这些页在父进程侧变成碎片。"
碎片成因可视化:
jemalloc 分配的内存页(4KB 页):
写入前:
[AAAA][BBBBBBBB][CC][DDDDDDDDDD][EEEE]
每个对象分配在不同页中
删除 B 和 D:
[AAAA][________][CC][__________][EEEE]
产生了 8B 和 10B 的空洞
写入新对象 F (大小 20B):
[AAAA][________][CC][__________][EEEE][FF...]
F 20B 放不进任何空洞 → 分配新页 → 碎片产生了!
技术映射:碎片率 mem_fragmentation_ratio = used_memory_rss / used_memory。小于 1 说明部分数据在 swap 里(危险);1.0-1.2 健康;1.2-1.5 关注;大于 1.5 需要治理。
2.4 第四幕:容量规划——从业务模型到 maxmemory 的数学
小胖:"10 万商品,每个缓存 2KB——那我配 200MB 内存不就够了吗?"
小白:"你漏掉的东西太多了——Redis 内部对象开销、字典结构开销、过期字典、复制缓冲区、客户端缓冲区。而且你还要留 fork 空间和碎片余量。"
大师:"容量规划要从业务侧到 Redis 侧逐层计算,不是简单乘法。我给你们一套公式。"
容量规划公式:
第一步: 业务数据净大小
B = key_count × (avg_key_size + avg_value_size)
第二步: Redis 对象开销
O = key_count × overhead_per_key
其中 overhead_per_key 取决于数据类型:
- String (小): ~60-80 bytes/key (dictEntry + robj + sds)
- Hash/ZSet (大): 每个 field/member 额外开销 40-60 bytes
- 过期字典: 每个有 TTL 的 key 额外 ~16 bytes
第三步: 实例内存需求
M = (B + O) / target_usage_ratio
其中 target_usage_ratio 建议 0.6-0.7
第四步: 安全余量
Safety = M × (1 + frag_ratio_buffer + fork_buffer)
- frag_ratio_buffer: 0.1-0.2(碎片余量)
- fork_buffer: 0.5 × (B + O)(COW 最坏情况)
第五步: 物理/容器内存需求
Total = max(M / target_usage_ratio, Safety)
2.5 第五幕:大 key 治理——不是快慢问题,是内存炸弹
小胖:"大 key 不就是慢吗?跟内存有什么关系?"
大师:"关系大了。一个大 String key 1GB,如果配置了 lazyfree-lazy-eviction,淘汰时用 UNLINK 异步释放——这是对的。但如果配置错了,用 DEL 同步释放——主线程会卡 1-2 秒。更严重的是,大 key 删除后释放的内存会在 jemalloc 里形成大量碎片,导致 RSS 不降反升。删除大 key 是碎片化的第一诱因。"
小白:"那怎么治理大 key?删也不行,不删也不行。"
大师:"三个方向:一是预防——业务侧避免大 key,比如 Hash 超过 5000 field 就拆分,String 超过 10KB 就压缩或换对象存储。二是检测——redis-cli --bigkeys、MEMORY USAGE、SCAN 定期巡检。三是治理——拆分、压缩、迁移到更适合的存储,删除时用 UNLINK。"
3. 项目实战
3.1 环境准备:搭建内存治理实验环境
# 创建 Docker 网络
docker network create redis-mem-lab
# 启动一个 128MB 限制的 Redis 实例(用于淘汰实验)
docker run --name redis-mem-1 --network redis-mem-lab -p 6390:6379 -d redis:8.6 \
redis-server \
--maxmemory 128mb \
--maxmemory-policy allkeys-lfu \
--maxmemory-samples 10 \
--save "" \
--appendonly no \
--lazyfree-lazy-eviction yes \
--lazyfree-lazy-expire yes
# 启动第二个实例(用于碎片实验,不做内存限制)
docker run --name redis-mem-2 --network redis-mem-lab -p 6391:6379 -d redis:8.6 \
redis-server \
--maxmemory 512mb \
--maxmemory-policy allkeys-lru \
--activedefrag yes \
--active-defrag-ignore-bytes 50mb \
--active-defrag-threshold-lower 10 \
--active-defrag-threshold-upper 100 \
--save "" \
--appendonly no
# 验证
docker exec redis-mem-1 redis-cli PING
docker exec redis-mem-1 redis-cli CONFIG GET maxmemory
docker exec redis-mem-1 redis-cli INFO memory | head -30
3.2 实战一:八种淘汰策略对比实验
# 进入容器
docker exec -it redis-mem-1 redis-cli
# 清空旧数据
FLUSHALL
# 查看当前策略
CONFIG GET maxmemory-policy
# 预期: allkeys-lfu
# ========== 实验 1: allkeys-lru ==========
CONFIG SET maxmemory-policy allkeys-lru
# 写入大量数据直到触发淘汰(128MB 限制,每个 key 约 500 bytes)
# 使用 redis-cli 批量写入
在另一个终端批量写入:
# 在容器内批量写入
for i in $(seq 1 300000); do
docker exec redis-mem-1 redis-cli SET "cache:product:$i" "$(printf '=%.0s' $(seq 1 300))" EX 3600 > /dev/null 2>&1
done
# 观察淘汰情况
docker exec redis-mem-1 redis-cli INFO stats | grep evicted_keys
docker exec redis-mem-1 redis-cli DBSIZE
docker exec redis-mem-1 redis-cli INFO memory | grep -E "used_memory_human|maxmemory_human|mem_fragmentation_ratio"
# ========== 实验 2: volatile-lru(前提:部分 key 无 TTL)==========
docker exec redis-mem-1 redis-cli FLUSHALL
docker exec redis-mem-1 redis-cli CONFIG SET maxmemory-policy volatile-lru
# 写入 1000 个无 TTL 的 key("不可淘汰")
for i in $(seq 1 1000); do
docker exec redis-mem-1 redis-cli SET "perm:config:$i" "important-value-$i" > /dev/null 2>&1
done
# 继续写入有 TTL 的缓存 key,直到填满
for i in $(seq 1 300000); do
docker exec redis-mem-1 redis-cli SET "cache:temp:$i" "$(printf '=%.0s' $(seq 1 300))" EX 60 > /dev/null 2>&1
done
# 观察:当带 TTL 的 key 被淘汰完后,后续写入应该报错
docker exec redis-mem-1 redis-cli SET "cache:new:1" "hello" EX 60
# 预期: (error) OOM command not allowed
docker exec redis-mem-1 redis-cli GET "perm:config:100"
# 预期: "important-value-100"(无 TTL 的 key 未被淘汰)
docker exec redis-mem-1 redis-cli INFO stats | grep evicted_keys
# 预期: 只淘汰了带 TTL 的 key
# 关键观察:evicted_keys 数量 ÷ 总写入量,确认淘汰范围限制在 volatile key 内
# ========== 实验 3: noeviction ==========
docker exec redis-mem-1 redis-cli FLUSHALL
docker exec redis-mem-1 redis-cli CONFIG SET maxmemory-policy noeviction
# 写入直到内存满
for i in $(seq 1 300000); do
result=$(docker exec redis-mem-1 redis-cli SET "data:$i" "$(printf '=%.0s' $(seq 1 300))" 2>&1)
if echo "$result" | grep -q "OOM"; then
echo "OOM at key $i"
break
fi
done > /dev/null 2>&1
docker exec redis-mem-1 redis-cli INFO stats | grep evicted_keys
# 预期: 0(noeviction 不淘汰任何 key)
# ========== 实验 4: volatile-ttl ==========
docker exec redis-mem-1 redis-cli FLUSHALL
docker exec redis-mem-1 redis-cli CONFIG SET maxmemory-policy volatile-ttl
# 写入不同 TTL 的 key
for i in $(seq 1 50000); do
ttl=$(( (RANDOM % 300) + 60 )) # 60-360 秒随机 TTL
docker exec redis-mem-1 redis-cli SET "test:$i" "$(printf '=%.0s' $(seq 1 256))" EX $ttl > /dev/null 2>&1
done
# 再继续写入短 TTL 的 key
for i in $(seq 50001 100000); do
docker exec redis-mem-1 redis-cli SET "test:$i" "$(printf '=%.0s' $(seq 1 256))" EX 10 > /dev/null 2>&1
done
# 等待 10 秒后,短 TTL key 自然会过期
sleep 15
# 再写入大量数据触发淘汰
for i in $(seq 100001 300000); do
docker exec redis-mem-1 redis-cli SET "test:$i" "$(printf '=%.0s' $(seq 1 256))" EX 3600 > /dev/null 2>&1
done
# volatile-ttl 应该优先淘汰 TTL 剩下较短的 key
docker exec redis-mem-1 redis-cli INFO stats | grep evicted_keys
3.3 实战二:容量模型计算脚本
#!/bin/bash
# redis-capacity-calc.sh —— Redis 容量规划计算器
echo "======================================"
echo " Redis 容量规划计算器"
echo "======================================"
echo ""
# 输入参数
read -p "预计 key 数量: " KEY_COUNT
read -p "平均 key name 长度 (bytes): " AVG_KEY_SIZE
read -p "平均 value 大小 (bytes): " AVG_VAL_SIZE
read -p "key 数据类型 (string/hash/zset/list/set): " DATA_TYPE
read -p "target maxmemory 使用率 (0.6-0.7): " TARGET_USAGE
read -p "碎片率预估 (1.0-1.5, 保守取 1.3): " FRAG_RATIO
# 默认值
TARGET_USAGE=${TARGET_USAGE:-0.7}
FRAG_RATIO=${FRAG_RATIO:-1.3}
# 计算业务数据净大小
NET_DATA=$((KEY_COUNT * (AVG_KEY_SIZE + AVG_VAL_SIZE)))
NET_DATA_MB=$(echo "scale=2; $NET_DATA / 1048576" | bc)
echo ""
echo "--- 结果 ---"
echo "业务数据净大小: ${NET_DATA_MB} MB"
# Redis 开销估算
case $DATA_TYPE in
string)
OVERHEAD_PER_KEY=72 # dictEntry(24) + robj(16) + sds len/hdr
;;
hash)
# 假设平均 10 fields
OVERHEAD_PER_KEY=200
;;
zset)
OVERHEAD_PER_KEY=250
;;
list)
OVERHEAD_PER_KEY=120
;;
set)
OVERHEAD_PER_KEY=150
;;
*)
OVERHEAD_PER_KEY=100
;;
esac
OVERHEAD_TOTAL=$((KEY_COUNT * OVERHEAD_PER_KEY))
OVERHEAD_MB=$(echo "scale=2; $OVERHEAD_TOTAL / 1048576" | bc)
echo "Redis 内部开销: ${OVERHEAD_MB} MB (${OVERHEAD_PER_KEY} bytes/key)"
# maxmemory 需求
NEEDED_MEM=$(( (NET_DATA + OVERHEAD_TOTAL) ))
MAXMEM_MB=$(echo "scale=2; $NEEDED_MEM / 1048576 / $TARGET_USAGE" | bc)
echo "建议 maxmemory: ${MAXMEM_MB} MB (使用率 ${TARGET_USAGE})"
# 物理内存需求(含碎片)
PHYSICAL_MEM_MB=$(echo "scale=2; $MAXMEM_MB * $FRAG_RATIO" | bc)
echo "建议物理/容器内存: ${PHYSICAL_MEM_MB} MB (碎片率 ${FRAG_RATIO})"
# fork 安全余量
FORK_BUFFER_MB=$(echo "scale=2; ($NEEDED_MEM / 1048576) * 0.5" | bc)
TOTAL_SAFE_MB=$(echo "scale=2; $PHYSICAL_MEM_MB + $FORK_BUFFER_MB" | bc)
echo "含 fork 安全余量的总内存: ${TOTAL_SAFE_MB} MB"
echo ""
echo "注意: 如果使用 AOF rewrite 或 BGSAVE, 需要额外的 COW 内存"
3.4 实战三:碎片诊断与治理
# ========== 碎片诊断 ==========
docker exec redis-mem-2 redis-cli
# 查看碎片概况
INFO memory | grep -E "used_memory_human|used_memory_rss_human|mem_fragmentation"
# 详细内存分析
MEMORY STATS
# 关注:
# peak.allocated —— 历史分配峰值
# allocator_frag_ratio —— 分配器内部碎片
# allocator_rss_ratio —— RSS 层面碎片
# 智能诊断
MEMORY DOCTOR
# 会输出具体的建议,如:
# "High allocator fragmentation..."
# "High RSS overhead..."
# "Big replica buffers..."
# ========== 制造碎片 ==========
# 写入大量不同大小的 key
for i in $(seq 1 10000); do
size=$(( (RANDOM % 4000) + 20 ))
docker exec redis-mem-2 redis-cli SET "frag:key:$i" "$(printf '=%.0s' $(seq 1 $size))" > /dev/null 2>&1
done
# 随机删除一半
for i in $(seq 1 2 10000); do
docker exec redis-mem-2 redis-cli DEL "frag:key:$i" > /dev/null 2>&1
done
# 再次写入不同大小的 key
for i in $(seq 1 5000); do
size=$(( (RANDOM % 2000) + 500 ))
docker exec redis-mem-2 redis-cli SET "frag:new:$i" "$(printf '=%.0s' $(seq 1 $size))" > /dev/null 2>&1
done
# 观察碎片率变化
docker exec redis-mem-2 redis-cli INFO memory | grep -E "used_memory_human|used_memory_rss_human|mem_fragmentation"
# ========== 碎片治理 ==========
# 1. 查看 active defrag 状态
docker exec redis-mem-2 redis-cli INFO stats | grep defrag
# active_defrag_running —— 是否正在整理
# active_defrag_key_hits —— 整理的 key 数量
# active_defrag_key_misses —— 跳过的 key 数量
# 2. 触发主动碎片整理
docker exec redis-mem-2 redis-cli CONFIG SET activedefrag yes
# 3. 调整 active defrag 参数(更积极)
docker exec redis-mem-2 redis-cli CONFIG SET active-defrag-threshold-lower 5
docker exec redis-mem-2 redis-cli CONFIG SET active-defrag-threshold-upper 100
docker exec redis-mem-2 redis-cli CONFIG SET active-defrag-cycle-min 25
docker exec redis-mem-2 redis-cli CONFIG SET active-defrag-cycle-max 75
# 4. 观察整理过程(会消耗 CPU)
watch -n 2 'docker exec redis-mem-2 redis-cli INFO stats | grep defrag'
# 5. 使用 MEMORY PURGE(触发 jemalloc 归还内存给 OS)
docker exec redis-mem-2 redis-cli MEMORY PURGE
# 6. 验证碎片率改善
docker exec redis-mem-2 redis-cli INFO memory | grep mem_fragmentation
3.5 实战四:大 key 检测与治理
# ========== 制造大 key ==========
# 制造一个 50MB 的 Hash
for i in $(seq 1 500000); do
docker exec redis-mem-2 redis-cli HSET "big:hash:userprofiles" "user:$i" "$(printf '=%.0s' $(seq 1 100))" > /dev/null 2>&1
done
# 制造一个大 List
for i in $(seq 1 100000); do
docker exec redis-mem-2 redis-cli RPUSH "big:list:events" "$(printf '=%.0s' $(seq 1 200))" > /dev/null 2>&1
done
# ========== 大 key 检测 ==========
# 方法 1: --bigkeys(采样扫描,推荐日常)
docker exec redis-mem-2 redis-cli --bigkeys
# 输出示例:
# Biggest string found: "xxx" has 5120 bytes
# Biggest hash found: "big:hash:userprofiles" has 500000 fields
# Biggest list found: "big:list:events" has 100000 items
# 方法 2: 精确查看单个 key 的内存
docker exec redis-mem-2 redis-cli MEMORY USAGE "big:hash:userprofiles"
# 输出: 精确字节数
# 方法 3: SCAN + MEMORY USAGE 批量巡检(生产可用)
docker exec redis-mem-2 redis-cli --scan --pattern "big:*" | head -20 | \
while read key; do
size=$(docker exec redis-mem-2 redis-cli MEMORY USAGE "$key")
echo "$key: $size bytes"
done
# ========== 大 key 治理方案 ==========
# 方案 1: 拆分 Hash(如果 field 太多)
# 把 user:1-100000 拆到 10 个 Hash 里
for i in $(seq 1 100); do
bucket=$((i % 10))
val=$(docker exec redis-mem-2 redis-cli HGET "big:hash:userprofiles" "user:$i")
docker exec redis-mem-2 redis-cli HSET "big:hash:shard:$bucket" "user:$i" "$val" > /dev/null 2>&1
done
# 方案 2: 异步删除大 key(UNLINK)
docker exec redis-mem-2 redis-cli UNLINK "big:hash:userprofiles"
# 注意: 用 UNLINK 而不是 DEL!DEL 会阻塞主线程
# 观察后台删除进度:
docker exec redis-mem-2 redis-cli INFO stats | grep lazyfree
# 方案 3: 分批删除大 Hash(渐进式)
# 用 HSCAN + HDEL 分批删除
cursor=0
while true; do
result=$(docker exec redis-mem-2 redis-cli HSCAN "big:hash:userprofiles" $cursor COUNT 1000)
cursor=$(echo "$result" | head -1)
fields=$(echo "$result" | tail -n +2 | sed 's/^[0-9]*) //' | tr ' ' '\n' | sed -n '1~2p')
if [ -n "$fields" ]; then
echo "$fields" | xargs -I {} docker exec redis-mem-2 redis-cli HDEL "big:hash:userprofiles" "{}" > /dev/null 2>&1
fi
if [ "$cursor" = "0" ]; then break; fi
sleep 0.01 # 每批之间休息,避免 CPU 飙升
done
3.6 实战五:Java 内存监控和自动治理
@Component
@Slf4j
public class RedisMemoryMonitor {
private final StringRedisTemplate redisTemplate;
private final MeterRegistry meterRegistry;
public RedisMemoryMonitor(StringRedisTemplate redisTemplate,
MeterRegistry meterRegistry) {
this.redisTemplate = redisTemplate;
this.meterRegistry = meterRegistry;
}
@Scheduled(fixedRate = 30000) // 每 30 秒采集
public void collectMemoryMetrics() {
RedisConnection conn = null;
try {
conn = redisTemplate.getConnectionFactory().getConnection();
Properties info = conn.info("memory");
Properties stats = conn.info("stats");
Properties repl = conn.info("replication");
// 核心指标采集
double usedMemory = parseBytes(info.getProperty("used_memory"));
double usedMemoryRss = parseBytes(info.getProperty("used_memory_rss"));
double maxmemory = parseBytes(info.getProperty("maxmemory", "0"));
double fragRatio = parseDouble(info.getProperty("mem_fragmentation_ratio"));
long evictedKeys = parseLong(stats.getProperty("evicted_keys"));
long keyspaceHits = parseLong(stats.getProperty("keyspace_hits"));
long keyspaceMisses = parseLong(stats.getProperty("keyspace_misses"));
// 注册到 Micrometer
gauge("redis.memory.used_bytes", usedMemory);
gauge("redis.memory.rss_bytes", usedMemoryRss);
gauge("redis.memory.max_bytes", maxmemory);
gauge("redis.memory.frag_ratio", fragRatio);
gauge("redis.memory.usage_percent",
maxmemory > 0 ? usedMemory / maxmemory * 100 : 0);
gauge("redis.keys.evicted_total", evictedKeys);
// 命中率
long totalOps = keyspaceHits + keyspaceMisses;
if (totalOps > 0) {
gauge("redis.cache.hit_rate",
(double) keyspaceHits / totalOps * 100);
}
// 淘汰速率(相比上次的增量)
gauge("redis.keys.evicted_rate",
calculateRate(evictedKeys, "lastEvictedKeys"));
// 告警判断
checkAlerts(usedMemory, maxmemory, fragRatio, evictedKeys);
} catch (Exception e) {
log.error("Redis memory metric collection failed", e);
gauge("redis.monitor.error", 1);
}
}
private void checkAlerts(double usedMemory, double maxmemory,
double fragRatio, long evictedKeys) {
// 内存使用率 > 85%
if (maxmemory > 0 && usedMemory / maxmemory > 0.85) {
log.warn("[Redis-P1] 内存使用率 {:.1f}% > 85%阈值",
usedMemory / maxmemory * 100);
meterRegistry.counter("redis.alert.memory_high").increment();
}
// 碎片率 > 1.5
if (fragRatio > 1.5) {
log.warn("[Redis-P1] 内存碎片率 {:.2f} > 1.5阈值", fragRatio);
meterRegistry.counter("redis.alert.frag_high").increment();
}
// 碎片率 > 2.0
if (fragRatio > 2.0) {
log.error("[Redis-P0] 内存碎片率 {:.2f} > 2.0, 需要立即处理", fragRatio);
meterRegistry.counter("redis.alert.frag_critical").increment();
}
// 最近 5 分钟有淘汰
if (evictedKeys > 0) {
log.warn("[Redis-P2] 检测到 key 淘汰, evicted_keys={}", evictedKeys);
meterRegistry.counter("redis.alert.eviction").increment();
}
}
private double parseBytes(String value) {
if (value == null) return 0;
return Double.parseDouble(value);
}
private double parseDouble(String value) {
if (value == null) return 0;
return Double.parseDouble(value);
}
private long parseLong(String value) {
if (value == null) return 0;
return Long.parseLong(value);
}
private double calculateRate(long current, String lastKey) {
// 简化实现:用原子变量或外部存储
return 0;
}
private void gauge(String name, double value) {
meterRegistry.gauge(name, value);
}
}
3.7 实战六:自动碎片整理调度
@Component
@Slf4j
public class AutoDefragScheduler {
private final StringRedisTemplate redisTemplate;
private static final double DEFRAG_THRESHOLD = 1.5;
private static final double DEFRAG_CRITICAL = 2.0;
/**
* 在业务低峰期(凌晨 3 点)检查并执行碎片整理
*/
@Scheduled(cron = "0 0 3 * * *")
public void scheduledDefrag() {
log.info("开始凌晨碎片巡检...");
try {
RedisConnection conn =
redisTemplate.getConnectionFactory().getConnection();
// 先检查碎片率
Properties memory = conn.info("memory");
double fragRatio = Double.parseDouble(
memory.getProperty("mem_fragmentation_ratio"));
log.info("当前碎片率: {}", fragRatio);
if (fragRatio >= DEFRAG_CRITICAL) {
// 碎片严重 —— 执行 MEMORY PURGE
log.warn("碎片严重 ({}), 执行 MEMORY PURGE", fragRatio);
conn.execute("MEMORY", "PURGE".getBytes());
// 再次检查
memory = conn.info("memory");
fragRatio = Double.parseDouble(
memory.getProperty("mem_fragmentation_ratio"));
log.info("PURGE 后碎片率: {}", fragRatio);
} else if (fragRatio >= DEFRAG_THRESHOLD) {
// 碎片偏高 —— 临时提升 active defrag 积极性
log.info("碎片偏高 ({}), 启用积极碎片整理", fragRatio);
conn.execute("CONFIG", "SET".getBytes(),
"active-defrag-threshold-lower".getBytes(), "5".getBytes());
conn.execute("CONFIG", "SET".getBytes(),
"active-defrag-cycle-min".getBytes(), "25".getBytes());
conn.execute("CONFIG", "SET".getBytes(),
"active-defrag-cycle-max".getBytes(), "75".getBytes());
// 等待 30 分钟后恢复默认
Thread.sleep(30 * 60 * 1000);
conn.execute("CONFIG", "SET".getBytes(),
"active-defrag-threshold-lower".getBytes(), "10".getBytes());
conn.execute("CONFIG", "SET".getBytes(),
"active-defrag-cycle-min".getBytes(), "1".getBytes());
conn.execute("CONFIG", "SET".getBytes(),
"active-defrag-cycle-max".getBytes(), "25".getBytes());
log.info("碎片整理参数已恢复默认");
} else {
log.info("碎片率正常, 无需处理");
}
} catch (Exception e) {
log.error("碎片巡检异常", e);
}
}
/**
* 在内存使用率过高时触发预警
*/
@Scheduled(fixedRate = 60000)
public void checkMemoryPressure() {
try {
RedisConnection conn =
redisTemplate.getConnectionFactory().getConnection();
Properties memory = conn.info("memory");
double usedMemory = Double.parseDouble(
memory.getProperty("used_memory"));
double maxmemory = Double.parseDouble(
memory.getProperty("maxmemory", "0"));
if (maxmemory > 0) {
double usage = usedMemory / maxmemory;
if (usage > 0.90) {
log.error("[P0] Redis 内存使用率 {:.1f}%, 需立即扩容",
usage * 100);
// TODO: 触发自动扩容或告警
} else if (usage > 0.80) {
log.warn("[P1] Redis 内存使用率 {:.1f}%, 建议评估扩容",
usage * 100);
} else if (usage > 0.70) {
log.info("[P2] Redis 内存使用率 {:.1f}%, 关注趋势",
usage * 100);
}
}
} catch (Exception e) {
log.error("内存压力检查异常", e);
}
}
}
3.8 实战七:容量巡检与趋势预测
#!/bin/bash
# redis-capacity-check.sh —— 每日内存巡检脚本
HOST="127.0.0.1"
PORT="6379"
ALERT_MEMORY_USAGE=0.80
ALERT_FRAG_RATIO=1.5
echo "========================================="
echo " Redis 内存健康检查 $(date +%Y-%m-%d\ %H:%M)"
echo "========================================="
# 1. 获取内存指标
USED_MEMORY=$(redis-cli -h $HOST -p $PORT INFO memory | grep "used_memory:" | cut -d: -f2 | tr -d '\r')
USED_MEMORY_H=$(redis-cli -h $HOST -p $PORT INFO memory | grep "used_memory_human:" | cut -d: -f2 | tr -d '\r')
USED_RSS=$(redis-cli -h $HOST -p $PORT INFO memory | grep "used_memory_rss:" | cut -d: -f2 | tr -d '\r')
MAXMEMORY=$(redis-cli -h $HOST -p $PORT CONFIG GET maxmemory | tail -1 | tr -d '\r')
FRAG=$(redis-cli -h $HOST -p $PORT INFO memory | grep "mem_fragmentation_ratio:" | cut -d: -f2 | tr -d '\r')
EVICTED=$(redis-cli -h $HOST -p $PORT INFO stats | grep "evicted_keys:" | cut -d: -f2 | tr -d '\r')
HITS=$(redis-cli -h $HOST -p $PORT INFO stats | grep "keyspace_hits:" | cut -d: -f2 | tr -d '\r')
MISSES=$(redis-cli -h $HOST -p $PORT INFO stats | grep "keyspace_misses:" | cut -d: -f2 | tr -d '\r')
DBSIZE=$(redis-cli -h $HOST -p $PORT DBSIZE | tr -d '\r')
# 2. 计算衍生指标
MEM_USAGE_PCT=$(echo "scale=2; $USED_MEMORY / $MAXMEMORY * 100" | bc)
HIT_RATE=$(echo "scale=2; $HITS / ($HITS + $MISSES) * 100" | bc)
# 3. 输出报告
echo ""
echo "[内存]"
echo " used_memory: ${USED_MEMORY_H}"
echo " used_memory_rss: $(echo "scale=2; $USED_RSS / 1048576" | bc) MB"
echo " maxmemory: $(echo "scale=2; $MAXMEMORY / 1048576" | bc) MB"
echo " 使用率: ${MEM_USAGE_PCT}%"
echo " 碎片率: ${FRAG}"
echo " key 数量: ${DBSIZE}"
echo ""
echo "[缓存]"
echo " hits: ${HITS}"
echo " misses: ${MISSES}"
echo " 命中率: ${HIT_RATE}%"
echo " 淘汰数: ${EVICTED}"
# 4. 告警判断
echo ""
echo "[告警]"
ALERTS=0
if (( $(echo "$MEM_USAGE_PCT > $ALERT_MEMORY_USAGE * 100" | bc -l) )); then
echo " [!] 内存使用率 ${MEM_USAGE_PCT}% > ${ALERT_MEMORY_USAGE}*100% (阈值)"
ALERTS=$((ALERTS + 1))
fi
if (( $(echo "$FRAG > $ALERT_FRAG_RATIO" | bc -l) )); then
echo " [!] 碎片率 ${FRAG} > ${ALERT_FRAG_RATIO} (阈值)"
ALERTS=$((ALERTS + 1))
fi
if [ "$EVICTED" != "0" ]; then
echo " [!] 检测到 key 淘汰: ${EVICTED} 次"
ALERTS=$((ALERTS + 1))
fi
if [ "$ALERTS" -eq 0 ]; then
echo " 无告警, 运行正常"
else
echo " 共 ${ALERTS} 条告警"
fi
3.9 实战八:Java 大 key 批量扫描
@Component
@Slf4j
public class BigKeyScanner {
private final StringRedisTemplate redisTemplate;
private static final long BIG_KEY_THRESHOLD_BYTES = 50 * 1024; // 50KB
private static final long BIG_HASH_FIELDS = 5000; // 5000 fields
private static final long BIG_LIST_LEN = 5000; // 5000 items
private static final int SCAN_BATCH = 100;
@Data
@AllArgsConstructor
public static class BigKeyReport {
private String key;
private String type;
private long size;
private long memoryBytes;
}
public List<BigKeyReport> scanBigKeys(String pattern) {
List<BigKeyReport> reports = new ArrayList<>();
RedisConnection conn = null;
try {
conn = redisTemplate.getConnectionFactory().getConnection();
ScanOptions options = ScanOptions.scanOptions()
.match(pattern)
.count(SCAN_BATCH)
.build();
Cursor<byte[]> cursor = conn.scan(options);
while (cursor.hasNext()) {
byte[] keyBytes = cursor.next();
String key = new String(keyBytes, StandardCharsets.UTF_8);
// 使用 MEMORY USAGE 获取精确内存
Long memoryBytes = null;
try {
Object result = conn.execute("MEMORY",
"USAGE".getBytes(), keyBytes);
if (result instanceof Long) {
memoryBytes = (Long) result;
}
} catch (Exception e) {
// MEMORY USAGE 可能不可用
}
// 用 TYPE + STRLEN/HLEN/LLEN 判断大小
String type = new String(conn.type(keyBytes),
StandardCharsets.UTF_8);
long size = 0;
switch (type) {
case "string":
size = conn.strLen(keyBytes);
break;
case "hash":
size = conn.hLen(keyBytes);
break;
case "list":
size = conn.lLen(keyBytes);
break;
case "set":
size = conn.sCard(keyBytes);
break;
case "zset":
size = conn.zCard(keyBytes);
break;
}
boolean isBig = false;
if (memoryBytes != null && memoryBytes > BIG_KEY_THRESHOLD_BYTES) {
isBig = true;
}
if ("hash".equals(type) && size > BIG_HASH_FIELDS) {
isBig = true;
}
if ("list".equals(type) && size > BIG_LIST_LEN) {
isBig = true;
}
if (isBig) {
reports.add(new BigKeyReport(key, type, size,
memoryBytes != null ? memoryBytes : 0));
log.warn("[大key] key={}, type={}, size={}, memory={}bytes",
key, type, size, memoryBytes);
}
// 每批之间休息,避免阻塞
if (cursor.getCursorId() % (SCAN_BATCH * 10) == 0) {
Thread.sleep(10);
}
}
} catch (Exception e) {
log.error("大 key 扫描异常", e);
}
return reports;
}
@Scheduled(cron = "0 0 2 * * *") // 每天凌晨 2 点执行
public void scheduledScan() {
log.info("开始每日大 key 巡检...");
List<BigKeyReport> reports = scanBigKeys("*");
if (!reports.isEmpty()) {
log.warn("发现 {} 个大 key", reports.size());
for (BigKeyReport r : reports) {
log.warn(" [{}] key={} size={} memory={}bytes",
r.getType(), r.getKey(), r.getSize(), r.getMemoryBytes());
}
} else {
log.info("本次巡检未发现大 key");
}
}
}
3.10 实战九:key 生命周期管理
@Service
public class KeyLifecycleManager {
private final StringRedisTemplate redis;
private static final int DEFAULT_TTL_SECONDS = 3600;
private static final int JITTER_MAX_SECONDS = 600;
/**
* 写入缓存并设置带抖动的 TTL
*/
public void setWithJitter(String key, String value, int baseTtlSeconds) {
int jitter = ThreadLocalRandom.current().nextInt(
Math.min(JITTER_MAX_SECONDS, baseTtlSeconds / 5));
int ttl = baseTtlSeconds + jitter;
redis.opsForValue().set(key, value, Duration.ofSeconds(ttl));
}
/**
* 写入关键数据(不可淘汰的数据需要持久化兜底)
*/
public void setCritical(String key, String value) {
// 关键数据不给 TTL —— 防止 volatile-* 策略误淘汰
redis.opsForValue().set(key, value);
// 同时在数据库写入副本
// dbRepository.save(key, value);
log.info("关键数据写入: key={}, 已同步持久化", key);
}
/**
* 按数据类型推荐 TTL 范围
*/
public int recommendTtl(KeyCategory category) {
switch (category) {
case PRODUCT_DETAIL:
return 600 + ThreadLocalRandom.current().nextInt(300); // 10-15min
case USER_SESSION:
return 1800 + ThreadLocalRandom.current().nextInt(600); // 30-40min
case HOT_RANK:
return 60 + ThreadLocalRandom.current().nextInt(30); // 1-1.5min
case COUNT_CACHE:
return 300 + ThreadLocalRandom.current().nextInt(60); // 5-6min
case CONFIG:
return -1; // 不过期
default:
return DEFAULT_TTL_SECONDS +
ThreadLocalRandom.current().nextInt(JITTER_MAX_SECONDS);
}
}
public enum KeyCategory {
PRODUCT_DETAIL, USER_SESSION, HOT_RANK, COUNT_CACHE, CONFIG
}
}
3.11 实战十:生产常见内存故障排查 SOP
#!/bin/bash
# redis-memory-troubleshoot.sh —— 内存问题排查 SOP
echo "=== Redis 内存故障排查 SOP ==="
echo "执行时间: $(date)"
echo ""
HOST="${1:-127.0.0.1}"
PORT="${2:-6379}"
# 第一层: 确认内存状态
echo "[第1层] 内存概览"
redis-cli -h $HOST -p $PORT INFO memory | grep -E \
"used_memory_human|used_memory_rss_human|maxmemory_human|mem_fragmentation_ratio|maxmemory_policy"
echo ""
# 第二层: 确认是否在淘汰
echo "[第2层] 淘汰状态"
EVICTED=$(redis-cli -h $HOST -p $PORT INFO stats | grep "evicted_keys:" | cut -d: -f2)
echo "evicted_keys: $EVICTED"
if [ "$EVICTED" -gt 0 ]; then
echo " → 正在淘汰 key, 检查策略: $(redis-cli -h $HOST -p $PORT CONFIG GET maxmemory-policy | tail -1)"
echo " → 命中率: $(redis-cli -h $HOST -p $PORT INFO stats | grep keyspace)"
fi
echo ""
# 第三层: 诊断碎片
echo "[第3层] 碎片诊断"
FRAG=$(redis-cli -h $HOST -p $PORT INFO memory | grep "mem_fragmentation_ratio:" | cut -d: -f2)
echo "碎片率: $FRAG"
if (( $(echo "$FRAG > 1.5" | bc -l) )); then
echo " → 碎片率高, 建议查看 MEMORY DOCTOR:"
redis-cli -h $HOST -p $PORT MEMORY DOCTOR 2>/dev/null
fi
echo ""
# 第四层: 查找内存大户
echo "[第4层] 内存消耗 TOP 分析"
redis-cli -h $HOST -p $PORT --bigkeys -i 0.1 2>&1 | head -30
echo ""
# 第五层: 客户端缓冲区检查
echo "[第5层] 客户端缓冲区"
redis-cli -h $HOST -p $PORT CLIENT LIST 2>/dev/null | \
awk -F'[ =]' '{
for(i=1;i<=NF;i++) {
if($i=="omem" && $(i+1)>1048576) print "大输出缓冲区: addr="$2" omem="$(i+1)
}
}'
echo ""
# 第六层: 复制缓冲区
echo "[第6层] 复制状态"
redis-cli -h $HOST -p $PORT INFO replication | grep -E \
"role|connected_slaves|master_repl_offset|repl_backlog"
echo ""
echo "=== 排查完成 ==="
echo "建议优先级: 淘汰→碎片→大key→缓冲区→复制. 请按顺序修复."
4. 项目总结
4.1 淘汰策略速查表
| 策略 | 淘汰范围 | 淘汰依据 | 适用场景 | 风险 |
|---|---|---|---|---|
noeviction |
无 | — | 配置中心、分布式锁 | 内存满即不可写 |
allkeys-lru |
所有 key | 近似 LRU | 全缓存、冷热交替频繁 | 刚写入的热数据可能被淘汰 |
allkeys-lfu |
所有 key | 近似 LFU | 热点稳定、内容/商品缓存 | 冷热切换响应慢 |
allkeys-random |
所有 key | 随机 | 所有 key 等价值 | 可能淘汰热 key |
volatile-lru |
有 TTL 的 key | 近似 LRU | 混合数据、部分不可丢 | 无 TTL 的 key 不参与淘汰 |
volatile-lfu |
有 TTL 的 key | 近似 LFU | 缓存+永久混合 | 同上 |
volatile-ttl |
有 TTL 的 key | 快过期优先 | 短期缓存 | 长 TTL key 可能常驻 |
volatile-random |
有 TTL 的 key | 随机 | 临时数据 | 可能淘汰快要被访问的 key |
4.2 内存配置速查
| 配置项 | 建议值 | 说明 |
|---|---|---|
maxmemory |
物理内存 × 0.6-0.7 | 留出 fork 和碎片空间 |
maxmemory-policy |
allkeys-lfu | 通用热点缓存 |
maxmemory-samples |
10 | 精度和性能平衡 |
activedefrag |
yes | 生产建议开启 |
active-defrag-ignore-bytes |
100mb | 碎片小于此值不整理 |
active-defrag-threshold-lower |
10 | 碎片率 > 1.1 开始整理 |
active-defrag-threshold-upper |
100 | 持续整理上限 |
active-defrag-cycle-min |
1 | 最小 CPU 占用 1% |
active-defrag-cycle-max |
25 | 最大 CPU 占用 25% |
lazyfree-lazy-eviction |
yes | 异步淘汰,避免阻塞 |
lazyfree-lazy-expire |
yes | 异步过期删除 |
lazyfree-lazy-server-del |
yes | 异步服务端删除 |
4.3 容量规划五步法
| 步骤 | 输入 | 操作 | 输出 |
|---|---|---|---|
| 1. 业务建模 | key 数量、key/value 大小、数据类型 | 计算净数据 | 业务数据量 (GB) |
| 2. 开销估算 | 数据类型、TTL 比例 | 加 dict/robj/sds 开销 | Redis 总数据量 |
| 3. 安全水位 | target 使用率 (0.7) | 除以使用率 | 建议 maxmemory |
| 4. 余量预留 | 碎片率、fork 比例 | 乘以安全系数 | 物理/容器内存 |
| 5. 扩容阈值 | 业务增长率 | 确定扩容触发条件 | 扩容时间点和规模 |
4.4 生产事故案例
| 事故 | 现象 | 根因 | 教训 |
|---|---|---|---|
| OOM Kill | used_memory 35GB, RSS 51GB, OOM killed | 碎片率持续 1.47 + AOF rewrite COW | maxmemory 不是物理内存限制,RSS 才是 |
| 写入全失败 | 新写入全部 OOM | volatile-lru 但 60% key 无 TTL | 淘汰策略必须和 key TTL 匹配 |
| 延迟抖动 | P99 偶尔 500ms | 大 key 删除用 DEL,主线程阻塞 | 删除用 UNLINK 或分批 |
| 内存漏涨 | used_memory 每天涨 5%, 不降 | 客户端输出缓冲区未限制 | 设置 client-output-buffer-limit |
| 扩容失败 | 扩容后 OOM Kill | maxmemory 贴容器 limit,没留 fork 空间 | 容器内存 limit > maxmemory + fork 预估 |
4.5 思考题
-
设计题:一个 Redis 实例同时存放商品详情缓存(可丢失)和用户会话 token(不可丢失)。你会选什么淘汰策略?如果必须使用一个实例,如何用 key 前缀 + TTL + 监控保障两类数据的安全?
-
排障题:
used_memory显示 10GB,used_memory_rss显示 22GB,mem_fragmentation_ratio= 2.2。但MEMORY STATS显示allocator_frag_ratio= 1.05。碎片在哪里?可能是什么导致的?如何修复? -
规划题:预计 2000 万个商品 key,每个 Hash 有 20 个 field(avg key 40B, field 8B, value 200B)。计划使用率 70%,碎片率 1.3。需要多大的 maxmemory 和物理内存?
上一章思考题答案提示(第25章):
第1题(hash tag 热点风险):如果所有活动相关操作全部使用
{activity:202604},该 hash tag 的所有 key 都在同一槽位,如果该活动是超级大促,这个槽位会成为整个集群的瓶颈。更优方案:① 按活动维度做 hash tag 但只用于必须原子操作的 key(如库存+限购),读操作不绑定 hash tag;② 使用{activity:202604:0},{activity:202604:1}等分片 Tag 增加分散度,牺牲跨分片原子性;③ 如果确实有热点活动,单独为该活动部署专用小集群。第2题(缓解手段):① 设置
maxmemory-policy allkeys-lfu让冷数据自动淘汰;② 检查是否有大 key,拆分或删除;③ 缩短低价值数据的 TTL;④ 如果使用集群,对热点槽位做 rebalance;⑤ 在应用层对热点 key 增加本地短缓存 Caffeine。
延伸阅读与资源
Redis 8 实战精讲:从 CRUD 到源码,构建高可用缓存系统
Java 工程师进阶:从 JVM 生产排障到OpenJDK原理
Nacos 3.x 注册配置中心实战修炼:从入门到源码扩展
Elasticsearch从入门到进阶的实战之旅
MySQL Server 9从入门到进阶的实战之旅
RabbitMQ从入门到进阶的实战之旅:从单机到大促高可用架构
Celery 入门到进阶之路:从异步任务到自研调度平台
LangGraph 生产级实战进阶:从零到生产级Agent工作流开发
Dify 从入门到源码:LLM 应用平台实战修炼
从零到生产级:FastAPI 异步高并发、源码与 SRE 实战
实战SQLAlchemy 2.0: 从 CRUD 到生产级架构
从零打造企业级 AI 助手:LangChain RAG、Agent 与生产实战
后端工程师 AI 转型课:Ollama 私有化大模型从入门到生产
MongoDB 实战进阶与内核修炼
NumPy 从入门到生产落地:全链路实战指南(科学计算/向量化/性能调优)
Milvus向量数据库实战修炼:从 0 到 1 精通向量检索与生产落地
Python 3实战精进:从脚本到高并发订单引擎
python入门:Rquests从菜鸟脚本到企业级SDK的网络实战圣经

微信公众号: 架构师日常笔记 欢迎关注!
浙公网安备 33010602011771号