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 内存,直接把进程推进了死亡线。

事后复盘暴露出五个治理盲区:

  1. 淘汰策略选的 volatile-lru,但 60% 的 key 没有设 TTL——内存满了只能写失败,根本淘汰不了。
  2. 碎片率持续 3 个月高于 1.4,团队只盯着 used_memory——没人看 RSS 和实际物理内存。
  3. maxmemory 贴容器 limit 配的,没留 fork 余量——BGSAVE 或 AOF rewrite 一触发就 OOM。
  4. 容量模型只有"QPS × 平均 value 大小",没算 dict 开销、过期字典、客户端缓冲区。
  5. 大 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 空洞就变成了碎片。"

小白:"所以碎片率高的根因是——不同大小的对象混在一起,释放后形成的空洞没法被不同大小的新对象利用?"

大师:"精准。三种典型场景会导致碎片飙升:

  1. 大小混合:大量不同大小的 key 频繁创建和删除——每个 slab class 都有碎片。
  2. 大 key 删除:删除一个 100MB 的 String 后,释放的 100MB 拆成很多个小块,短时间内难以复用。
  3. 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 思考题

  1. 设计题:一个 Redis 实例同时存放商品详情缓存(可丢失)和用户会话 token(不可丢失)。你会选什么淘汰策略?如果必须使用一个实例,如何用 key 前缀 + TTL + 监控保障两类数据的安全?

  2. 排障题:used_memory 显示 10GB,used_memory_rss 显示 22GB,mem_fragmentation_ratio = 2.2。但 MEMORY STATS 显示 allocator_frag_ratio = 1.05。碎片在哪里?可能是什么导致的?如何修复?

  3. 规划题:预计 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的网络实战圣经

posted on 2026-11-22 19:37  一天不进步,就是退步  阅读(6)  评论(0)    收藏  举报