4.2.1 Redis · 6 大数据结构底层实现 + 高可用架构

从底层数据结构到生产级高可用,一篇文章打通 Redis 全栈。

1. 为什么这个专题重要

1.1 为什么 Redis 是缓存之王

Redis (Remote Dictionary Server) 诞生于 2009 年,由 Salvatore Sanfilippo (antirez) 开发。它不是单纯的缓存,从 2015 年 Redis 3.2 引入 GEO、2017 年 Redis 5.0 引入 Stream、2020 年 Redis 6.0 引入多线程 I/O,到 2022 年 Redis 7.0 引入 Functions,Redis 已经演化为「内存数据结构服务器 + 分布式协调中间件」。

美团 2020 年内部分布式 KV 中间件 Cellar (基于 RocksDB + 自研协议) 在缓存侧仍大量与 Redis 协同;阿里 Tair (Redis 模块版) 也在电商大促中承担持久化 KV 角色。但中小规模 90% 场景,Redis 是默认选择。

1.2 真实生产事故:雪崩 / 击穿 / 穿透

• 雪崩:某电商大促 0 点批量预热缓存,所有 Key 都设 24h 过期,次日 0 点全部失效,DB 被打挂 5 分钟。
• 击穿:微博明星热点新闻缓存 Key 突然失效,百万 QPS 同时打 DB,MySQL 响应超时触发雪崩。
• 穿透:爬虫持续请求不存在的商品 ID (-1 -> attack),绕过 Redis 直击 DB,DB CPU 飙到 100%。

这三个问题占 Redis 生产事故 80% 以上,本专题第 7 节逐个击破。

2. Redis 整体架构

2.1 单线程模型:为什么还这么快

Redis 4.x/5.x 主线程只有一个,处理命令请求;但 6.0+ 引入了 I/O 多线程辅助网络读写。很多人疑惑「单线程为何 QPS 还能到 10w+」,核心四点:

1. 内存操作:KV 操作都是 O(1)/O(logN),无磁盘 I/O。
2. 非阻塞 I/O:基于 Linux epoll 多路复用,单线程可处理数万连接。
3. 避免锁开销:单线程无须加锁,无上下文切换。
4. C 语言 + 紧凑数据结构:SDS / dict / zskiplist 都极致优化。

但单线程对慢命令极敏感:KEYS *、FLUSHDB、DEBUG SLEEP 30、超大 Key 的 DEL 会阻塞整个实例。

2.2 6.0 多线程 I/O + Reactor

flowchart TB
    subgraph IO["IO Threads (网络读写)"]
        T1["IO Thread 1"]
        T2["IO Thread 2"]
        TN["IO Thread N"]
    end
    Main["Main Thread (单)<br/>Reactor / epoll<br/>命令执行/响应写入"]
    IO --> Main
    style Main fill:#f9c,stroke:#333,stroke-width:2px

2.3 epoll 多路复用原理

flowchart LR
    A1["fd3 (conn-A)"]
    A2["fd5 (conn-B)"]
    A3["fd8 (conn-C)"]
    EP["epoll_wait()"]
    Q["事件就绪队列"]
    D["单线程 dispatch"]
    A1 --> EP
    A2 --> EP
    A3 --> EP
    EP --> Q --> D

epoll 用红黑树 + 双向链表实现 O(1) 的「增/删/就绪检测」,相比 select/poll 的 O(N) 全量扫描,在 10w+ 长连接下差距巨大。

2.4 ASCII 整体架构图

flowchart TB
    Client["Client (redis-cli / app)"]
    Server["Redis Server Process"]
    NetIO["network I/O layer<br/>(epoll + 多线程 6.0+)"]
    FHE["File Event Handler<br/>(单线程主循环)"]
    CmdDict["Command Dict<br/>(查表 O(1))"]
    DB["DB 0..15<br/>(16 个 DB)"]
    Engine["6 大数据结构存储引擎<br/>SDS / dict / quicklist /<br/>intset / zskiplist / Stream"]
    Client -- "TCP (RESP 协议)" --> Server
    Server --> NetIO --> FHE
    FHE --> CmdDict
    FHE --> DB
    CmdDict --> Engine
    DB --> Engine

2.5 Redis 7.0 新特性

3. 6 大数据结构底层实现

3.1 String → SDS (Simple Dynamic String)

C 原生 char* 的痛点:获取长度 O(N) / 二进制不安全 / 拼接可能溢出。SDS 解决一切:

+-----------------------------------------------------+
| struct sdshdr {                                      |
|   int len;          // 已用长度,O(1) 获取            |
|   int alloc;        // 总分配容量                    |
|   unsigned char flags; // SDS_TYPE_5/8/16/32/64      |
|   char buf[];       // 实际字节流 + '\0'            |
| };                                                   |
+-----------------------------------------------------+

Redis 7.0 进一步把 sdshdr 简化,flags 与 len 共用字节,内存更紧凑。

SDS 拼接示例 (Lua 中调用):

-- KEYS[1] = "user:1001:name", ARGV[1] = "Tom"
local key = KEYS[1]
local suffix = ARGV[1]
-- 模拟 SDS sdscat(): realloc + memcpy
return redis.call('SET', key, suffix)

# Python redis-py 操作 String
import redis
r = redis.Redis(host='localhost', port=6379, decode_responses=True)
r.set('counter', 0)
r.incr('counter')        # 原子自增,内部仍是 SDS
r.append('counter', 'x') # SDS sdscat 拼接
print(r.get('counter'))  # '1x'

3.2 List → quicklist (双向链表 + ziplist)

Redis 3.2 之前 List 是 adlist 双向链表;3.2 之后改为 quicklist,即「多个 ziplist 用双向指针串起来」。ziplist 是连续内存、长度有限,满了就分裂新 ziplist。Redis 7.0 用 listpack 替换 ziplist(listpack 不再保存上一节点长度,避免级联更新)。

flowchart LR
    Head((head)) -- ziplist A<br/>item1<br/>item2<br/>item3 --> ZA["ziplist A"]
    ZA <--> ZB["ziplist B"]
    ZB --> Tail((tail))
    style ZA fill:#e1f5ff
    style ZB fill:#e1f5ff

# List 实战:最新 10 条消息队列
r.lpush('msg:room1', 'hello', 'world')      # 左推
r.rpop('msg:room1')                         # 右弹 → 'world'
r.lrange('msg:room1', 0, 9)                 # 查最近 10 条
r.ltrim('msg:room1', 0, 9)                  # 保留 10 条,删更早的

3.3 Hash → dict (hash table) + 压缩底层

Hash 字段少时用 listpack(Redis 7.0)/ ziplist(老版本)省内存,字段超阈值后转为真正的 dict(基于哈希表 + 渐进式 rehash)。

flowchart LR
    HT0["ht[0]"]
    HT0 --> Table["┌───┬───┬───┬───┐<br/>│ A │ B │ C │ D │<br/>└───┴───┴───┴───┘"]
    Table -- "rehash 逐桶迁移" --> HT1["ht[1] (扩容中)<br/>(逐渐迁)"]
    style Table fill:#fff3cd
    style HT1 fill:#d4edda

• 字段数 ≤ hash-max-listpack-entries (默认 128) 且字段值 ≤ hash-max-listpack-value (默认 64B) 时,用 listpack。
• 否则升级为 dict,JDK HashMap 思路:桶 + 链表/红黑树。

# Hash 实战:用户对象
r.hset('user:1001', mapping={
    'name': 'Tom', 'age': 28, 'email': 'tom@example.com'
})
r.hget('user:1001', 'name')    # 'Tom'
r.hincrby('user:1001', 'age', 1)
r.hgetall('user:1001')          # 全字段

3.4 Set → intset + dict

• 元素全为整数且数量 ≤ set-max-intset-entries (默认 512) → intset(有序整数数组,二分查找 O(logN))。
• 否则用 dict:key=member, value=NULL。

# Set 实战:标签、共同关注
r.sadd('user:1001:tags', 'python', 'redis', 'k8s')
r.sismember('user:1001:tags', 'redis')     # True
r.sinter('user:1001:tags', 'user:1002:tags')  # 交集

3.5 Sorted Set (ZSet) → zskiplist + dict

ZSet 是 Redis 最有特色的结构,同时用:

• 跳跃表 zskiplist:按 score 排序,支持 ZRANGEBYSCORE 范围查询 O(logN)。
• dict:由 member 查 score,O(1)。

flowchart LR
    Head["head"] --> N1["1.0"]
    N1 -- level 1/2/3/4 索引路径 --> N5["5.0"]
    N1 --> N3["3.0"]
    N3 --> N5
    N5 --> N7["7.0"]
    N7 --> N9["9.0"]
    N9 --> N11["11.0"]
    style N1 fill:#fef3c7
    style N3 fill:#fef3c7
    style N5 fill:#bbf7d0
    style N7 fill:#fef3c7
    style N9 fill:#bbf7d0
    style N11 fill:#fef3c7

查 score=7.0:head→3.0(level 2 跳 4)→7.0。期望 O(logN),实测比红黑树简单。

# 排行榜实战
r.zadd('hot:posts', {'post:101': 95, 'post:102': 88, 'post:103': 99})
r.zrevrange('hot:posts', 0, 9, withscores=True)        # Top 10
r.zincrby('hot:posts', 5, 'post:101')                  # 点赞+5

3.6 Stream (Redis 5.0+ 消息流)

Stream 是 Redis 内置消息中间件,内部用 radix tree (rax) 存消息 ID,类似 Kafka 的 partition + consumer group。

flowchart TB
    subgraph Stream["stream:orders (radix tree / listpack)"]
        M1["1700000000001-0<br/>{user:1001, item:A, qty:1}"]
        M2["1700000000002-0<br/>{user:1002, item:B, qty:2}"]
        M3["1700000000003-0<br/>{user:1003, item:A, qty:1}"]
    end
    subgraph CG["consumer group: order_workers"]
        CA["consumer-A<br/>1700000000001-0 (ACK ✓)"]
        CB["consumer-B<br/>1700000000002-0 (ACK ✗ 待重试)"]
        CC["consumer-C<br/>1700000000003-0 (ACK ✓)"]
    end
    M1 --> CA
    M2 --> CB
    M3 --> CC

# Stream 生产/消费
mid = r.xadd('orders', {'user': 'u1', 'item': 'A'})
r.xgroup_create('orders', 'workers', id='0', mkstream=True)
msgs = r.xreadgroup('workers', 'consumer-A', {'orders': '>'}, count=10)
for _id, fields in msgs:
    r.xack('orders', 'workers', _id)

3.7 编码转换阈值与示意图

flowchart LR
    Trigger["↓ 触发条件<br/>(字段数 / 元素数 / 字节数)"]
    Small["small<br/>listpack / ziplist / intset"]
    Large["large<br/>dict / quicklist / zskiplist"]
    Down["数据量减少时可降级"]
    Trigger --> Small
    Small -- 升级 --> Large
    Large -- 降级 --> Down
    Down -.-> Small
    style Small fill:#dbeafe
    style Large fill:#fde68a

完整阈值可通过 CONFIG GET *-max-*-* 查看。

4. Redis 持久化详解

4.1 RDB (Redis Database)

• 把当前进程数据生成快照存盘,默认 dump.rdb。
• 触发:save/bgsave(BG 是 fork 子进程)/ 配置 save 900 1 等规则。
• 优点:文件紧凑、恢复快;缺点:可能丢最近数据。

4.2 AOF (Append Only File)

• 每次写命令追加到 AOF,fsync 策略:always/everysec(默认)/no。
• 文件 4.x 起每 32MB 触发 BGREWRITEAOF 压缩。

4.3 混合持久化 (RDB + AOF)

Redis 4.0+ 开启 aof-use-rdb-preamble yes:AOF 文件先写 RDB 快照部分,后接增量 AOF。恢复 = 先快 RDB 重建 + 增量补,兼顾速度与完整。

4.4 Fork 写时复制 (COW)

flowchart LR
    Parent["主进程 (服务读写)"]
    Fork{{"fork (OS)"}}
    Child["子进程<br/>(BGSAVE / RDB 落盘)"]
    Parent --> Fork --> Child
    Parent -- "写入已存在页<br/>↓ 触发 COW<br/>复制新页给子进程" --> COW["复制新页"]
    COW --> Child
    Child -- "读共享页 (只读)" --> Shared["共享只读页"]
    style COW fill:#fecaca

fork 由 OS 完成,父进程不阻塞;子进程写 RDB 时,父进程改动的页被 COW 复制,子进程看到的始终是 fork 时一刻的快照。

4.5 配置示例

# redis.conf (生产推荐)
save 900 1
save 300 10
save 60 10000
appendonly yes
appendfsync everysec
aof-use-rdb-preamble yes
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

4.6 持久化选型决策表

5. Redis 高可用三大架构

5.1 主从复制 (Replication)

flowchart TB
    M["master<br/>(写命令)"]
    R1["replica-1 (read-only)"]
    R2["replica-2 (read-only)"]
    R3["replica-3 (read-only)"]
    M --> R1
    M --> R2
    M --> R3
    style M fill:#fecaca
    style R1 fill:#d1fae5
    style R2 fill:#d1fae5
    style R3 fill:#d1fae5

• 全量同步:master 执行 BGSAVE 生成 RDB 发给 replica,同时把缓冲区外的写命令缓存在 replication buffer。
• 增量同步:replica offset 落后 → master 通过 backlog (默认 1MB) 重放增量。
• 心跳:replica 每 1s 发送 REPLCONF ACK <offset>。

# replica 配置
replicaof 10.0.0.1 6379
masterauth yourpassword
replica-serve-stale-data yes

5.2 Sentinel 哨兵 (Redis 2.8+)

主从没有自动故障转移,Sentinel 补上:多哨兵投票选举新 master。

flowchart TB
    subgraph Sentinels["Sentinel 集群 (奇数, ≥3) — RAFT-like 投票"]
        S1["S1"]
        S2["S2"]
        S3["S3"]
    end
    subgraph Redis["Redis 主从"]
        M["master"]
        R1["R1"]
        R2["R2"]
        R3["R3"]
    end
    Client["客户端 (订阅 sentinel)"]
    S1 --> M
    S2 --> M
    S3 --> M
    Client <--> Sentinels
    style M fill:#fecaca
    style S1 fill:#fef3c7
    style S2 fill:#fef3c7
    style S3 fill:#fef3c7

# sentinel.conf
sentinel monitor mymaster 10.0.0.1 6379 2   # 至少 2 票
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000

5.3 Cluster 集群 (Redis 3.0+)

数据按 16384 个槽 分片,每个 master 管一部分 slot,slave 负责 HA。

flowchart TB
    subgraph S0["slot 0-5460"]
        M1["M1"]
        S1a["S1a"]
        M1 --- S1a
    end
    subgraph S1["slot 5461-10922"]
        M2["M2"]
        S2a["S2a"]
        M2 --- S2a
    end
    subgraph S2["slot 10923-16383"]
        M3["M3"]
        S3a["S3a"]
        M3 --- S3a
    end
    Client["client"]
    Client -- "智能路由 (MOVED/ASK)" --> S0
    Client --> S1
    Client --> S2
    style M1 fill:#fecaca
    style M2 fill:#fecaca
    style M3 fill:#fecaca
    style S1a fill:#d1fae5
    style S2a fill:#d1fae5
    style S3a fill:#d1fae5

为什么是 16384 槽?Redis 官方给出的答案:CRC16 输出 16 bit,选 16384 = 2^14,既能让单实例几乎均匀分布,又能把 slot bitmap 用 2KB bitmap 装下发,避免大集群同步开销。

Cluster 部署 6 节点示例

# 3 master + 3 slave,端口 7000-7005
for p in 7000 7001 7002 7003 7004 7005; do
  mkdir -p /tmp/redis-cluster/$p
  cat > /tmp/redis-cluster/$p/redis.conf <<EOF
port $p
cluster-enabled yes
cluster-config-file nodes-$p.conf
cluster-node-timeout 5000
appendonly yes
EOF
  redis-server /tmp/redis-cluster/$p/redis.conf
done

# 一次性创建集群
redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 \
  127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 \
  --cluster-replicas 1

真实案例:从单点 → Cluster 支撑亿级 QPS

某电商搜索热词服务演进:

• 阶段 1 (单 Redis 16GB):QPS 5w,延迟 1ms 内,瓶颈在网络带宽。
• 阶段 2 (主从 + Sentinel):QPS 15w,读扩展到 3 副本。
• 阶段 3 (Cluster 12 master 24 slave):QPS 80w,延迟 P99 5ms。
• 阶段 4 (Cluster + Proxy + 本地缓存):QPS 200w+,P99 3ms。

5.4 三大架构对比速查

6. Redis 5 大应用场景实战

6.1 缓存 (String + Hash)

# Cache-Aside 经典模式
def get_user(uid: int):
    key = f'user:{uid}'
    cached = r.get(key)
    if cached:
        return json.loads(cached)
    user = db.query_user(uid)
    if user:
        # 随机过期,防雪崩
        ttl = 600 + random.randint(0, 300)
        r.setex(key, ttl, json.dumps(user))
    return user

6.2 分布式锁 (SETNX + RedLock)

import uuid, time

def acquire_lock(key, ttl=10):
    token = str(uuid.uuid4())
    # NX = 只在不存在时设, EX = 过期秒
    ok = r.set(key, token, nx=True, ex=ttl)
    return token if ok else None

def release_lock(key, token):
    # Lua 原子比较并删,避免误删别人的锁
    lua = """
    if redis.call('GET', KEYS[1]) == ARGV[1] then
        return redis.call('DEL', KEYS[1])
    else
        return 0
    end
    """
    return r.eval(lua, 1, key, token)

RedLock 多实例算法 (Redis 作者 antirez 提出)

# 在 ≥3 个独立 master 上加锁,过半成功才算获取
def redlock_acquire(resource, ttl=10000):
    locks = []
    for client in [r1, r2, r3]:
        ok = client.set(resource, uuid, nx=True, px=ttl)
        if ok:
            locks.append((client, uuid))
        if len(locks) >= 2:   # 过半
            return locks
        for c, _ in locks:
            c.delete(resource, uuid)
    return None

Redisson RLock 是 Java 生态最成熟的 RedLock 实现。

6.3 限流 (令牌桶 Lua)

-- 令牌桶限流:每秒 100 token,桶容量 1000
-- KEYS[1]=rate:user:1001, ARGV[1]=capacity, ARGV[2]=rate, ARGV[3]=now, ARGV[4]=cost
local key = KEYS[1]
local cap = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local cost = tonumber(ARGV[4])

local data = redis.call('HMGET', key, 'tokens', 'ts')
local tokens = tonumber(data[1]) or cap
local last_ts = tonumber(data[2]) or now

-- 补充 token
local delta = math.max(0, now - last_ts)
tokens = math.min(cap, tokens + delta * rate / 1000)
local allowed = 0
if tokens >= cost then
    tokens = tokens - cost
    allowed = 1
end
redis.call('HMSET', key, 'tokens', tokens, 'ts', now)
redis.call('PEXPIRE', key, 60000)
return allowed

def allow(user_id, cost=1):
    return r.eval(LUA_TOKEN_BUCKET, 1,
                  f'rate:user:{user_id}',
                  1000, 100, int(time.time()*1000), cost)

6.4 排行榜 (Sorted Set)

# 微博点赞 Top 100
r.zadd('weibo:post:8888:likes', {f'user:{u}': 1 for u in likers})
r.zincrby('weibo:post:8888:likes', 1, f'user:{1001}')    # 点 +1
# 取 Top 100 倒序
top = r.zrevrange('weibo:post:8888:likes', 0, 99, withscores=True)
# 取用户排名
rank = r.zrevrank('weibo:post:8888:likes', f'user:1001')

6.5 消息队列 (Stream + 消费者组)

PRODUCER:
m_id = r.xadd('stream:audit', {'action': 'login', 'uid': 1001})

GROUP:
r.xgroup_create('stream:audit', 'audit_workers', id='0', mkstream=True)

CONSUMER:
while True:
    msgs = r.xreadgroup('audit_workers', f'consumer-{id}',
                        {'stream:audit': '>'}, count=20, block=5000)
    for _id, data in msgs:
        process(data)
        r.xack('stream:audit', 'audit_workers', _id)

相比 Kafka/RabbitMQ,Redis Stream 提供轻量级 MQ 与 pub/sub 持久化能力,适合中小规模(百万/天级)。

7. Redis 三大经典问题与解决

7.1 缓存雪崩 (大量 Key 同时过期)

症状:某个时间点大量热点 Key 集中失效 → DB 流量瞬时飙升 → 服务雪崩。

修法 1:过期时间加随机抖动。

import random
ttl = 600 + random.randint(0, 120)   # 600 ± 120 秒
r.setex(key, ttl, value)

修法 2:多级缓存 (Redis + 本地 Caffeine)。 修法 3:Key 永不过期,后台异步刷新。

# 经典流程图
  request ──► L1 (Caffeine, TTL 10s)
                  miss
                    ↓
            L2 (Redis, TTL 600±120s)
                  miss
                    ↓
            DB (回写 Redis + Caffeine)

7.2 缓存击穿 (单热点 Key 失效被并发打)

症状:某热门商品详情缓存失效瞬间,数千并发同时打到 DB。

修法 1:分布式锁 + singleflight

import threading
_lock = threading.Lock()
_inflight = {}

def get_with_sf(uid):
    if uid in _inflight:
        return _inflight[uid]   # singleflight 去重
    with _lock:
        if uid in _inflight:
            return _inflight[uid]
        future = _inflight[uid] = load_from_db(uid)
        try:
            return future
        finally:
            _inflight.pop(uid, None)

修法 2:逻辑过期 + 后台异步刷新。

修法 3:分布式锁 (Redis SET NX)。

lock = acquire_lock(f'lock:user:{uid}', ttl=3)
if not lock:
    time.sleep(0.05); return get_with_sf(uid)
try:
    val = load_from_db(uid)
    r.setex(f'user:{uid}', 600, json.dumps(val))
    return val
finally:
    release_lock(f'lock:user:{uid}', lock)

7.3 缓存穿透 (查不存在的 Key)

症状:攻击/爬虫持续请求 DB 不存在的数据,绕过缓存。

修法 1:空值缓存

val = r.get(key)
if val is None:
    db_val = db.query(key)
    if db_val:
        r.setex(key, 600, json.dumps(db_val))
    else:
        r.setex(key, 60, '__NULL__')   # 短 TTL 缓存空值
    return db_val

修法 2:布隆过滤器 (Redisson BF)

bf = RedissonBloomFilter('user_bf')
if not bf.contains(uid):
    return None
return r.get(f'user:{uid}')

修法 3:入口风控 (限流 + WAF)。

8. Redis 性能优化

8.1 大 Key 治理

# 扫描大 Key (Redis 4.0+)
redis-cli --bigkeys

# 安全删除大 Key (异步)
redis-cli UNLINK huge:key      # 代替 DEL,后台回收内存
redis-cli -n 1 --bigkeys -i 1 # 每秒输出

# 编程扫描 SCAN 避免阻塞
def scan_big_keys(threshold_mb=10):
    cursor = 0
    while True:
        cursor, keys = r.scan(cursor=cursor, count=500)
        for k in keys:
            size = r.memory_usage(k)
            if size > threshold_mb * 1024 * 1024:
                print(f'BIG {k} = {size} bytes')
        if cursor == 0: break

8.2 热 Key 发现

# Redis 4.0+ 直接命令
redis-cli --hotkeys                  # 需要 maxmemory-policy
redis-cli --memkeys

# 进阶:用 monitor + 业务侧 LRU 抓包
redis-cli MONITOR | grep -E "GET|HSET" | sort | uniq -c | sort -rn

8.3 Pipeline 批量操作

# 一次往返发送 1000 命令
with r.pipeline(transaction=False) as pipe:
    for i in range(1000):
        pipe.set(f'k:{i}', i)
    pipe.execute()

Pipeline 不保证原子性,但显著降低 RTT 开销。

8.4 Lua 原子脚本

-- 库存预扣减原子脚本
local stock = tonumber(redis.call('GET', KEYS[1]))
if stock == nil or stock <= 0 then
    return -1
end
return redis.call('DECR', KEYS[1])

8.5 内存淘汰策略 (8 种)

# 推荐:缓存用 allkeys-lru,混合用 volatile-lru
CONFIG SET maxmemory 16gb
CONFIG SET maxmemory-policy allkeys-lru

8.6 内存碎片整理

CONFIG SET activedefrag yes
INFO memory | grep mem_fragmentation_ratio   # >1.5 考虑重启或开启自动整理

9. 实战案例深度剖析 (4 个)

案例 1:电商秒杀系统 Redis 实战

场景:双 11 大促 0 点秒杀 iPhone 15,库存 1000 台,预估 100 万 QPS。

方案:

1. 库存预扣:DECR seckill:stock:iphone15 原子预扣,返回 -1 表示售罄。
2. 分布式锁:SET seckill:user:1001 lock NX EX 10 防一人多单。
3. 异步下单:扣成功的请求 push 到 Stream:seckill:orders,消费者组异步落 DB + 支付。
4. Token 限流:7.3 节令牌桶 Lua,按用户 ID 限 1 QPS。
5. 大促预热:大促前 30min 把商品库存、商品详情批量预热到 Redis。

收益:QPS 从 5k 提升到 80w,DB 写入压力降低 99%。

案例 2:微博点赞排行榜

场景:微博热搜话题点赞,单帖点赞数 1 亿次/小时,要展示 Top 1000 与个人排名。

方案:

1. Sorted Set:ZADD post:8888:likes 1700000000 user:1001。
2. Top 1000:ZREVRANGE post:8888:likes 0 999 WITHSCORES → 1 次 O(logN+m)。
3. 个人排名:ZREVRANK post:8888:likes user:1001 → O(logN)。
4. 亿级优化:ZSet 按 segment 拆分,例如 post:8888:likes:shard-{0..99},合并查询用 ZUNIONSTORE。

案例 3:从单 Redis 到 Cluster 支撑亿级 QPS

真实演进 (美团技术博客摘要):

• 0→1:单 Redis 16GB,QPS 5w,单点故障导致 503。
• 1→10:主从 + Sentinel,QPS 15w,但写还是单 master。
• 10→100:Redis Cluster 12 master + 24 slave,slot 划分按业务前缀 cart:、order:,QPS 80w。
• 100→1000:Cluster + Codis Proxy + 本地 Caffeine 二级缓存 + Codis-Dashboard 自动化扩容,QPS 200w+。

关键经验:

• 永远别把所有业务塞一个 Redis。
• 大 Key 提前治理。
• 监控指标:connected_clients / used_memory / ops/sec / hit_rate / slowlog。

案例 4:Redis 7.0 Functions 实战

场景:每天凌晨把昨日订单按用户维度做聚合并写回。

# 函数定义:redis-cli FUNCTION LOAD
FUNCTION loadLuaOnRedis = "
#!lua name=orderAgg
redis.register_function('daily_agg', function(keys, args)
    local orders = redis.call('HGETALL', keys[1])
    local total = 0
    for i = 1, #orders, 2 do
        total = total + tonumber(orders[i+1])
    end
    redis.call('SET', keys[2], total, 'EX', 86400)
    return total
end)
"

优势 vs EVAL Lua:Functions 持久化到库文件,即使 Redis 重启也不丢,易于版本化部署;支持多库 + 调试元信息。

10. 选型决策树 + Redis vs Memcached 对比表 + 踩坑 6 个

10.1 选型决策 ASCII 框图

flowchart TD
    Q{"需要持久化 / 复杂数据结构?"}
    Q -- Yes --> R["Redis (默认选)"]
    Q -- No --> M{"数据 > 1TB / 极简?"}
    R --> S{"单机 <-> Cluster?"}
    S -- 单机 --> MS["主从 + Sentinel"]
    S -- Cluster --> CL["Cluster"]
    M -- Yes --> MC["Memcached + 一致性哈希"]
    M -- No --> R
    style R fill:#fecaca
    style MS fill:#d1fae5
    style CL fill:#d1fae5
    style MC fill:#dbeafe

10.2 选型四维对照表

10.3 选型口诀 (3 句)

1. 小数据多结构选 Redis,大数据极简单用 MC,大数据强一致上 TiKV。
2. 高可用先 Sentinel,水平扩展再 Cluster。
3. 大 Key 必拆,热 Key 必散,雪崩抖动必加随机 TTL。

10.4 踩坑 6 个 (症状+原因+修法+命令)

坑 1:大 Key 删除阻塞主线程

• 症状:DEL 一个 200MB 的 Hash 后,Redis 实例几十秒不响应。
• 原因:DEL 是 O(N) 同步回收,在主线程执行,期间所有命令排队。
• 修法:用 UNLINK 异步释放内存;或 SCAN + HSCAN 分批删。
• 命令:redis-cli UNLINK huge:hash:key,扫描 redis-cli --bigkeys。

坑 2:热 Key 单点瓶颈

• 症状:某热门商品详情 Key QPS 100w,单 Redis CPU 100%,响应暴涨。
• 原因:单 Key 串行处理,即使分片也只命中单 master。
• 修法:加本地缓存 (Caffeine / Ehcache) 一级;Key 拆分 product:detail:{id}:shard{0..N},读完后合并。
• 命令:用 redis-cli --hotkeys 识别,业务侧 monitor 抓 top key。

坑 3:缓存雪崩

• 症状:每日 0 点 DB 被打满,慢 SQL 暴增。
• 原因:同一批缓存设同样过期时间,集中失效。
• 修法:过期时间加随机抖动;多级缓存;后台异步刷新;熔断降级。
• 命令:ttl = base + random.randint(0, base*0.2)。

坑 4:缓存穿透

• 症状:DB QPS 跟 Redis QPS 接近,缓存形同虚设。
• 原因:请求的 Key 在 DB 中根本不存在,缓存永远 miss。
• 修法:空值短 TTL 缓存 + 布隆过滤器 + 入口风控。
• 命令:Redisson RBloomFilter.tryInit(100M, 0.01) + bf.contains()。

坑 5:分布式锁失效 (死锁)

• 症状:某 worker 崩溃后,锁永远不释放,业务卡死。
• 原因:用了 SETNX 但没设过期,或业务逻辑 BUG 跳过 DEL。
• 修法:必须 SET key val NX EX ttl;释放时用 Lua 比对 value 防误删;加 watchdog (Redisson 自动续期)。
• 命令:SET lock:order:1001 uuid NX PX 30000 + Lua del-if-equal。

坑 6:Redis 内存爆掉

• 症状:OOM command not allowed when used memory > 'maxmemory',部分写入失败。
• 原因:没设 maxmemory + 淘汰策略,数据无限增长;或有内存碎片 (mem_fragmentation_ratio > 1.5)。
• 修法:设 maxmemory + 选合适淘汰 (allkeys-lru 通用);开启 activedefrag;大 Key 治理。
• 命令:CONFIG SET maxmemory 16gb + CONFIG SET maxmemory-policy allkeys-lru。

附录 A:6 大数据结构速查表

附录 B:三大高可用架构速查表

附录 C:Redis 性能 Checklist 12 项

1. ✅ 设置 maxmemory + 淘汰策略 (推荐 allkeys-lru)
2. ✅ 开启 activedefrag yes 治理碎片
3. ✅ 定期跑 redis-cli --bigkeys 和 --hotkeys
4. ✅ 生产禁用 KEYS / FLUSHDB,改用 SCAN
5. ✅ 大 Key 删除用 UNLINK 而非 DEL
6. ✅ 网络往返密集场景启用 Pipeline 或 Lua
7. ✅ 关闭 save,只走 AOF 或者混合持久化
8. ✅ 慢查询监控 slowlog-log-slower-than 10000
9. ✅ 监控 connected_clients / used_memory / ops/sec
10. ✅ Cluster 规模 ≥ 6 节点 (3M3S),避免脑裂
11. ✅ 多级缓存 (Caffeine L1 + Redis L2)
12. ✅ 接入 Redis 7.0 用 Functions 替代裸 EVAL Lua

附录 D:雪崩/击穿/穿透 Checklist

调研依据 (参考文献)

1. Redis 官方文档 — https://redis.io/documentation
2. Redis 设计与实现 — 黄健宏 (机械工业出版社)
3. Redis 5 设计与源码分析 — 陈雷 (人民邮电出版社)
4. Redis 源码剖析 — 钱文品 (博客)
5. Redis Cluster 规范 — https://redis.io/docs/reference/cluster-spec
6. Redis Streams 文档 — https://redis.io/docs/data-types/streams
7. Redisson 官方 wiki — https://redisson.org/glossary
8. 美团 Redis 实践 (MTEG 系列博客)
9. 阿里 Redis 中间件 Tair 实践
10. 微博 Redis 优化实践 (InfoQ 公开分享)
11. Redis 7.0 新特性官方 release notes

自检报告