1. 项目背景
1.1 从 List 到 Stream 的演进
前几章我们用 List 做了订单异步通知队列。List 做队列简单好用——RPUSH 生产者入队,BLPOP 消费者阻塞取任务。但随着业务复杂化,List 暴露出几个致命短板:
- 消息确认缺失:
BLPOP取走消息后立刻从队列删除。消费者处理到一半宕机——消息永久丢失,没有任何记录。 - 无消费进度:多个消费者无法知道"谁处理了哪条消息"、"哪些消息待处理"。
- 不支持消费组:一条消息只能被一个消费者拿走。如果需要"同一消息被多个业务方消费"(如订单事件既要通知积分系统又要通知仓库系统),List 做不到。
Redis 5.0 引入的 Stream 正是解决这些问题的数据结构。它提供了消费组(Consumer Group)、Pending List(已投递未确认)、消息确认(XACK)、消息认领(XCLAIM/XAUTOCLAIM)等机制,让 Redis 从一个"轻量队列"升级为"可靠消息流"。
1.2 Stream vs 其他消息方案
| 特性 | List | Pub/Sub | Stream | Kafka |
|---|---|---|---|---|
| 消息持久化 | 取走即删 | 不持久 | 支持 | 支持 |
| 消费确认 | 无 | 无 | XACK | commit offset |
| 消费组 | 无 | 无 | 支持 | 支持 |
| 消息回溯 | 不支持 | 不支持 | 支持(按 ID) | 支持 |
| 吞吐量 | 高 | 高 | 中等 | 极高 |
| 运维复杂度 | 低 | 低 | 中 | 高 |
1.3 本章目标
- 掌握 Stream 的核心命令体系:
XADD、XREAD、XREADGROUP、XACK、XPENDING、XCLAIM、XAUTOCLAIM。 - 实现订单事件流的完整闭环:生产→消费→确认→重试→死信。
- 理解消费组的工作原理和多消费者负载均衡。
- 设计消息幂等消费的通用模式。
2. 项目设计
2.1 第一幕:Stream 就是带账本的接力棒
小胖:"List 做队列不是挺好的吗?RPUSH 放进去,BLPOP 取出来。"
小白:"那如果消费者 BLPOP 取走消息后宕机了呢?消息已经从 List 里删了,没人知道这条消息没被处理。"
大师:"Stream 和 List 的差异,关键在多了一个'账本'——Pending List。消息投递给消费者后,不是立刻从 Stream 中删除,而是记在 Pending List 里。消费者处理成功后主动 XACK 确认,消息才从 Pending List 移除。如果超时没确认,其他消费者可以通过 XCLAIM 接手。"
Stream 消息生命周期:
XADD ──▶ Stream 中(消息存在)
│
▼
XREADGROUP ──▶ 投递给消费者,进入 Pending List
│
├── 消费者 XACK ──▶ 从 Pending List 移除 ✓
│
└── 消费者宕机(超时未 ACK)
│
▼
XAUTOCLAIM ──▶ 转给其他消费者,仍在 Pending List
小胖追问:"消费组有什么用?"
大师:"同一个消费组内的多个消费者是竞争消费——一条消息只会投递给组内的一个消费者。不同消费组之间独立消费——同一条消息可以同时投递给 order-db-group(负责落库)和 notify-group(负责发通知)。这就是消费组的核心价值——同一条 Stream,多个业务视角。"
Stream 消费组示意:
Stream: order-events
msg1 msg2 msg3 msg4 msg5 ...
┌──────────────────┐ ┌──────────────────┐
│ order-db-group │ │ notify-group │
│ ├─ consumer-1 │ │ ├─ consumer-1 │
│ └─ consumer-2 │ │ └─ consumer-2 │
│ (竞争消费) │ │ (竞争消费) │
│ 各自独立维护消费进度│ │ 各自独立维护消费进度│
└──────────────────┘ └──────────────────┘
2.2 第二幕:幂等——Stream 的底线要求
小白:"如果消费者处理成功了但 XACK 前宕机——消息还在 Pending List 里,会被 XAUTOCLAIM 转给另一个消费者重复处理。这就意味着同一条消息可能被处理多次。"
大师:"这正是 Stream 的核心设计理念——至少投递一次(at-least-once delivery)。它保证消息不会丢失,但不保证不重复。消除重复的责任在消费者。"
幂等消费的标准模式:
consume(message):
1. 提取业务唯一键(eventId/requestId)
2. 检查幂等表: 这个 eventId 已经处理过了吗?
├── 是 → XACK + 跳过
└── 否 → 继续
3. 执行业务操作
4. 记录幂等表(插入 eventId)
5. XACK 确认
技术映射:Stream 保障投递可靠性,业务方保障幂等性。两者的边界必须清晰——不要把幂等责任推给 Redis。
2.3 第三幕:消息流转全景
小胖:"Stream 的消息会越来越大吗?如果把所有历史订单事件都存下来,内存会爆炸吧?"
大师:"需要控制 Stream 的长度——用 MAXLEN 参数或 XTRIM 命令定期裁剪。但这里有一个重要认知——裁剪 Stream 不影响已经消费的消息。只要消费者正常 ACK 了,消息从 Pending List 移除后,即使被 Stream 裁剪也无所谓。"
# 发送消息时限制 Stream 最大长度(约 10000 条)
XADD mall:stream:order-events MAXLEN ~ 10000 * eventId evt-001 ...
# 定期裁剪
XTRIM mall:stream:order-events MAXLEN ~ 10000
注意 ~ 表示"大约"——Redis 可能保留稍多于 10000 条以提升性能。
3. 项目实战
3.1 环境准备
docker exec -it redis-lab redis-cli -a redis123
3.2 实战一:消息生产
# XADD: 向 Stream 追加消息,* 表示自动生成消息 ID
127.0.0.1:6379> XADD mall:stream:order-events * eventId evt-001 orderId 9001 userId 7 type ORDER_CREATED amount 299
"1714470000123-0" # Redis 自动生成的消息 ID (时间戳-序号)
127.0.0.1:6379> XADD mall:stream:order-events * eventId evt-002 orderId 9002 userId 8 type ORDER_PAID amount 129
"1714470000456-0"
# 查看 Stream 的长度
127.0.0.1:6379> XLEN mall:stream:order-events
(integer) 2
# 查看消息(从最早到最新)
127.0.0.1:6379> XRANGE mall:stream:order-events - +
1) 1) "1714470000123-0"
2) 1) "eventId" 2) "evt-001"
3) "orderId" 4) "9001"
5) "userId" 6) "7"
7) "type" 8) "ORDER_CREATED"
9) "amount" 10) "299"
# 反序查看(最新到最早)
127.0.0.1:6379> XREVRANGE mall:stream:order-events + - COUNT 5
# 查看 Stream 信息
127.0.0.1:6379> XINFO STREAM mall:stream:order-events
3.3 实战二:消费组创建与消费
# 创建消费组(从最早的消息开始消费: 0)
127.0.0.1:6379> XGROUP CREATE mall:stream:order-events order-db-group 0 MKSTREAM
OK
# 第二个消费组(订单通知)
127.0.0.1:6379> XGROUP CREATE mall:stream:order-events notify-group 0 MKSTREAM
OK
# 消费者读取新消息: > 表示只读从未消费过的消息
127.0.0.1:6379> XREADGROUP GROUP order-db-group consumer-1 COUNT 10 BLOCK 2000 STREAMS mall:stream:order-events >
1) 1) "mall:stream:order-events"
2) 1) 1) "1714470000123-0"
2) 1) "eventId" 2) "evt-001" ...
# 处理成功后确认
127.0.0.1:6379> XACK mall:stream:order-events order-db-group 1714470000123-0
(integer) 1
# 查看消费组信息
127.0.0.1:6379> XINFO GROUPS mall:stream:order-events
127.0.0.1:6379> XINFO CONSUMERS mall:stream:order-events order-db-group
3.4 实战三:Pending List 管理
# 查看 Pending List(已投递但未确认的消息)
127.0.0.1:6379> XPENDING mall:stream:order-events order-db-group
1) (integer) 1 # Pending 消息总数
2) "1714470000456-0" # 最小消息 ID
3) "1714470000456-0" # 最大消息 ID
4) 1) 1) "consumer-1" # 每个消费者的 Pending 统计
2) "1"
# 查看 Pending 详情
127.0.0.1:6379> XPENDING mall:stream:order-events order-db-group - + 10
1) 1) "1714470000456-0" # 消息 ID
2) "consumer-1" # 被投递给了哪个消费者
3) (integer) 45000 # 空闲了 45 秒(从投递到现在)
4) (integer) 1 # 投递次数
3.5 实战四:XAUTOCLAIM 自动认领超时消息
# consumer-1 挂了,消息空闲超过 60 秒
# consumer-2 自动认领这些消息
127.0.0.1:6379> XAUTOCLAIM mall:stream:order-events order-db-group consumer-2 60000 0-0 COUNT 10
1) "0-0" # 新的起始 ID
2) 1) 1) "1714470000456-0" # 认领的消息
2) 1) "eventId" 2) "evt-002" ...
# consumer-2 现在负责处理这条消息
3.6 实战五:死信队列
@Component
public class StreamDeadLetterHandler {
private static final String STREAM_KEY = "mall:stream:order-events";
private static final String DEAD_LETTER_KEY = "mall:stream:order-deadletter";
private static final int MAX_RETRY = 3;
public void processMessage(MapRecord<String, String, String> msg) {
String eventId = msg.getValue().get("eventId");
int retryCount = Integer.parseInt(msg.getValue().getOrDefault("retryCount", "0"));
try {
// 幂等检查
if (isProcessed(eventId)) {
ack(msg);
return;
}
// 执行实际业务
doBusinessLogic(msg);
// 标记已处理 + ACK
markProcessed(eventId);
ack(msg);
} catch (TemporaryException e) {
// 临时错误(网络超时等)→ 不 ACK,等待重试
if (retryCount >= MAX_RETRY) {
// 超过重试次数 → 放入死信队列
deadLetter(msg, e.getMessage(), retryCount);
ack(msg); // 从 Pending 移除
}
log.warn("消息处理临时失败, 待重试: eventId={}, retry={}", eventId, retryCount + 1);
} catch (PermanentException e) {
// 永久错误(数据格式错误等)→ 直接进死信
deadLetter(msg, e.getMessage(), retryCount);
ack(msg);
}
}
private void deadLetter(MapRecord<String, String, String> msg, String reason, int retryCount) {
Map<String, String> dlBody = new HashMap<>(msg.getValue());
dlBody.put("reason", reason);
dlBody.put("retryCount", String.valueOf(retryCount));
dlBody.put("originalStream", STREAM_KEY);
dlBody.put("deadAt", String.valueOf(System.currentTimeMillis()));
redis.opsForStream().add(DEAD_LETTER_KEY, dlBody);
log.error("消息进入死信队列: eventId={}, reason={}", msg.getValue().get("eventId"), reason);
// 告警通知运维/开发
alertService.send("Stream 死信: " + msg.getValue().get("eventId"));
}
private void ack(MapRecord<String, String, String> msg) {
redis.opsForStream().acknowledge(STREAM_KEY, "order-db-group", msg.getId());
}
}
3.7 实战六:多消费者负载均衡
@Component
public class StreamConsumerGroup {
// 同一个 group 内的多个实例会自动负载均衡
@PostConstruct
public void startConsumers() {
// 启动 3 个消费者线程(生产中可以跨 JVM 实例)
for (int i = 0; i < 3; i++) {
String consumerName = "worker-" + i;
new Thread(() -> consumeLoop(consumerName)).start();
}
}
private void consumeLoop(String consumerName) {
while (true) {
try {
List<MapRecord<String, String, String>> messages = redis.opsForStream()
.read(Consumer.from("order-db-group", consumerName),
StreamReadOptions.empty().count(5).block(Duration.ofSeconds(2)),
StreamOffset.create("mall:stream:order-events", ReadOffset.lastConsumed()));
for (MapRecord<String, String, String> msg : messages) {
processMessage(msg);
}
// 认领 Pending 超时消息
claimTimeoutMessages(consumerName);
} catch (Exception e) {
log.error("消费者 {} 异常", consumerName, e);
safeSleep(1000);
}
}
}
}
3.8 实战七:Stream 长度管理
# 方法 1: XADD 时指定 MAXLEN
127.0.0.1:6379> XADD mall:stream:order-events MAXLEN ~ 10000 * eventId evt-003 ...
# 方法 2: XTRIM 独立裁剪
127.0.0.1:6379> XTRIM mall:stream:order-events MAXLEN ~ 10000
(integer) 0 # 返回被裁剪的消息数
# 方法 3: XADD + MINID(保留比指定 ID 更新的消息)
127.0.0.1:6379> XADD mall:stream:order-events MINID ~ 1714470000000-0 * eventId evt-004 ...
# 查看 Stream 内存占用
127.0.0.1:6379> MEMORY USAGE mall:stream:order-events
3.9 实战八:Stream 与 List 队列的迁移指南
从 List 迁移到 Stream 时,需要注意兼容性:
// 如果系统同时存在 List 和 Stream 消费者(灰度迁移阶段)
@Component
public class DualQueueConsumer {
private static final String LIST_KEY = "mall:queue:order:notice";
private static final String STREAM_KEY = "mall:stream:order-events";
private static final String GROUP = "order-db-group";
private static final String CONSUMER = "migration-worker";
// 同时消费 List(旧)和 Stream(新)
@Scheduled(fixedDelay = 100)
public void consumeBoth() {
// 1. 消费 Stream(新方案)
List<MapRecord<String, String, String>> streamMsgs = redis.opsForStream()
.read(Consumer.from(GROUP, CONSUMER),
StreamReadOptions.empty().count(10).block(Duration.ofMillis(500)),
StreamOffset.create(STREAM_KEY, ReadOffset.lastConsumed()));
for (MapRecord<String, String, String> msg : streamMsgs) {
processWithRetry(msg);
}
// 2. 消费 List(旧方案,待完全迁移后移除)
String listMsg = redis.opsForList().rightPop(LIST_KEY, Duration.ofSeconds(1));
if (listMsg != null) {
log.debug("从 List 消费(旧方案): {}", listMsg);
processListMessage(listMsg);
}
// 3. 认领超时 Pending(只有 Stream 需要)
claimTimeoutMessages(CONSUMER);
}
}
3.10 实战九:Stream 消费者健康检查
@Component
public class StreamHealthCheck {
// 定期检查消费者健康状态
@Scheduled(fixedDelay = 30000)
public void checkConsumerHealth() {
// 1. 检查各消费组的 Pending 数量
List<Object> groups = redis.opsForStream().groups(STREAM_KEY);
for (Object groupInfo : groups) {
String groupName = extractGroupName(groupInfo);
PendingMessagesSummary pending = redis.opsForStream()
.pending(STREAM_KEY, groupName);
long pendingCount = pending.getTotalPendingMessages();
String minIdleTime = extractMinIdleTime(pending);
// 告警条件
if (pendingCount > 1000) {
alerts.send(String.format("Stream 积压告警: stream=%s, group=%s, pending=%d",
STREAM_KEY, groupName, pendingCount));
}
}
// 2. 检查死信队列长度
Long dlLen = redis.opsForStream().size("mall:stream:order-deadletter");
if (dlLen != null && dlLen > 10) {
alerts.send("死信队列积压: " + dlLen + " 条待处理");
}
// 3. 检查各消费者是否存活(最近是否有 ACK 记录)
// 通过 XPENDING 的信息判断消费者是否长时间没有处理消息
}
}
3.11 实战十:Stream vs Kafka——选型决策指南
| 维度 | Redis Stream | Kafka |
|---|---|---|
| 吞吐量 | 10万/秒(中等) | 百万/秒(高) |
| 消息持久化 | RDB/AOF 持久化 | 磁盘顺序写,天然持久 |
| 消息回溯 | 按 ID 或时间范围 | 按 offset 或时间戳 |
| 运维复杂度 | 低(已有 Redis) | 中-高(需要 ZooKeeper/KRaft) |
| 生态工具 | 较少 | 丰富(Kafka Connect、KSQL) |
| 最大消息保留 | 内存限制(需裁剪) | 磁盘大小限制(可长期保留) |
| 适合规模 | 中小规模(<10万消息/秒) | 大规模(>10万消息/秒) |
选型决策:
你的需求是?
├── 中小团队、已有 Redis、不想引入新中间件 → Redis Stream
├── 需要长期保留消息(天/月级别) → Kafka
├── 需要复杂流处理(聚合/窗口/join) → Kafka Streams / Flink
├── 轻量异步任务(通知/发券/发短信) → Redis Stream
└── 企业级数据总线/事件溯源 → Kafka
4.3 Stream 生产运维要点
| 运维项 | 检查方法 | 告警阈值 |
|---|---|---|
| Stream 积压 | XLEN |
> 10000 条告警 |
| Pending 堆积 | XPENDING |
> 1000 条告警 |
| 消费者掉线 | XINFO CONSUMERS 看 idle 时间 |
> 120s 告警 |
| 死信队列 | XLEN 死信 key |
> 10 条告警 |
| 内存占用 | MEMORY USAGE |
单个 Stream > 100MB |
| 消费者吞吐 | 业务打点 | 低于 50 msg/s 告警 |
// Stream 运维监控
@Component
public class StreamMetricsCollector {
@Scheduled(fixedDelay = 30000)
public void collect() {
// Stream 大小
Long len = redis.opsForStream().size(STREAM_KEY);
metricsCollector.gauge("redis.stream.xlen", len);
// Pending 数量
StreamInfo.XInfoGroups groups = redis.opsForStream().groups(STREAM_KEY);
for (StreamInfo.XInfoGroup group : groups) {
PendingMessagesSummary pending = redis.opsForStream()
.pending(STREAM_KEY, group.groupName());
metricsCollector.gauge("redis.stream.pending." + group.groupName(),
pending.getTotalPendingMessages());
}
}
}
4.4 Stream 故障场景与恢复
| 故障 | 诊断 | 恢复 |
|---|---|---|
| 消费者宕机 | XINFO CONSUMERS 查看 idle 时间 |
XAUTOCLAIM 自动认领 |
| 消息积压 | XLEN 持续增长 |
增加消费者实例,增大 COUNT |
| Pending 堆积 | XPENDING 数量大 |
检查消费者处理逻辑是否变慢 |
| 死信堆积 | 死信队列长度增长 | 人工审查 + 批量重放或丢弃 |
| Stream 内存过大 | MEMORY USAGE 超 100MB |
XTRIM MAXLEN 裁剪历史 |
4.5 从 List 到 Stream 的升级路径
阶段 1: List 队列(第 5 章)
→ RPUSH / BLPOP
→ 适合: 轻量通知、最新日志
阶段 2: List + 重试 + 死信(第 5 章进阶)
→ 手动失败队列、重试次数
→ 适合: 可容忍少量丢失的异步任务
阶段 3: Stream 单消费组(本章)
→ XADD / XREADGROUP / XACK / XAUTOCLAIM
→ 适合: 需要确认和重试的可靠消息
阶段 4: Stream 多消费组(本章进阶)
→ 同一 Stream 多个独立 Group
→ 适合: 一条消息多个业务方消费
阶段 5: Stream + 专业队列桥接
→ Redis Stream → Kafka Connect → Kafka
→ 适合: 跨系统事件总线
5. Stream 完整实验脚本
#!/bin/bash
# stream_lab.sh - Stream 完整实验
REDIS="redis-cli -a redis123"
STREAM="mall:stream:lab"
GROUP="lab-group"
echo "=== 1. 创建 Stream 和消费组 ==="
$REDIS XGROUP CREATE $STREAM $GROUP 0 MKSTREAM 2>/dev/null
echo "Stream 初始化完成"
echo "=== 2. 生产 10 条消息 ==="
for i in $(seq 1 10); do
$REDIS XADD $STREAM "*" eventId "evt-00$i" data "message-$i"
done
echo "已生产 10 条消息"
echo "=== 3. 消费者 1 读取 5 条(不 ACK) ==="
$REDIS XREADGROUP GROUP $GROUP c1 COUNT 5 STREAMS $STREAM >
echo "消费者 1 读取了 5 条"
echo "=== 4. 查看 Pending ==="
$REDIS XPENDING $STREAM $GROUP
echo "=== 5. 消费者 1 ACK 前 3 条 ==="
# 获取前 3 条消息 ID 并 ACK (这里简化,实际需要记录 ID)
MSG_IDS=$($REDIS XPENDING $STREAM $GROUP - + 5 | head -3 | awk -F'"' '{print $2}')
for id in $MSG_IDS; do
$REDIS XACK $STREAM $GROUP "$id"
done
echo "已 ACK 3 条"
echo "=== 6. 消费者 2 认领超时消息 ==="
$REDIS XAUTOCLAIM $STREAM $GROUP c2 100 0-0 COUNT 5
echo "消费者 2 认领了超时 Pending 消息"
echo "=== 7. 模拟死信 ==="
$REDIS XADD "mall:stream:lab:deadletter" "*" source "$STREAM" reason "测试死信"
echo "死信已写入"
echo "=== 8. 裁剪 Stream ==="
$REDIS XTRIM $STREAM MAXLEN ~ 5
echo "Stream 已裁剪为约 5 条"
echo "=== 实验完成 ==="
$REDIS XINFO STREAM $STREAM
$REDIS XINFO GROUPS $STREAM
5.1 Stream vs List vs Pub/Sub 终极对比
| 特性 | List | Pub/Sub | Stream |
|---|---|---|---|
| 消息持久化 | 取走即删 | 不持久 | 支持持久化 |
| 消息确认 | 无 | 无 | XACK |
| 消费组 | 无 | 无 | 支持 |
| 消息回溯 | 不支持 | 不支持 | 按 ID/时间 |
| 消息广播 | 不支持 | 支持 | 多消费组 |
| 消费者离线 | 消息堆积 | 消息丢失 | 消息保留 |
| 学习成本 | 低 | 低 | 中 |
| Redis 版本 | 1.0+ | 2.0+ | 5.0+ |
5.2 Stream 消费者开发检查清单
□ 消费者启动时是否创建了消费组?(XGROUP CREATE ... MKSTREAM)
□ 消费者读取时使用 > 读新消息吗?(不是 0 或 $)
□ 处理成功后是否 XACK 了?
□ 处理失败时是否不 ACK(让消息留在 Pending)?
□ 是否有 XAUTOCLAIM 认领超时 Pending 消息的逻辑?
□ 消费者是否实现了幂等(eventId/requestId + 幂等表)?
□ 永久失败的消息是否写入了死信队列?
□ Stream 是否有 MAXLEN 限制避免内存无限增长?
□ 是否有监控 Stream 积压(XLEN)和 Pending 的告警?
□ 消费者数量是否与消息吞吐量匹配(不够就加实例)?
本章核心认知:Stream 把 Redis 从"缓存工具"扩展为"轻量消息平台"。它不像 Kafka 那样追求极致吞吐,但在中小规模事件驱动架构中,用同一个 Redis 实例就能同时承担缓存、计数、排行榜和消息流——运维成本极低。选择 Stream 不是因为"Kafka 不好",而是因为"够用就是最好的"。
4. 项目总结
4.1 Stream 核心命令速查
| 命令 | 用途 | 关键参数 |
|---|---|---|
XADD key * field value... |
追加消息 | MAXLEN ~ N 限制长度 |
XREAD COUNT N BLOCK ms STREAMS key id |
读取消息(非消费组) | $ 只读新消息, 0 从头读 |
XREADGROUP GROUP g c ... STREAMS key > |
消费组读 | > 新消息, id 读 Pending |
XACK key group id... |
确认消息 | |
XPENDING key group |
查看 Pending | |
XCLAIM key group c min-idle id... |
认领 Pending | |
XAUTOCLAIM key group c min-idle start COUNT N |
自动认领 | |
XGROUP CREATE key group id |
创建消费组 | MKSTREAM 自动创建 Stream |
XLEN key |
Stream 长度 | |
XTRIM key MAXLEN ~ N |
裁剪 Stream | |
XRANGE key start end |
范围查询 | - + 查全部 |
XDEL key id |
删除消息 | |
XINFO STREAM key |
Stream 信息 | |
XINFO GROUPS key |
消费组列表 |
4.2 消息可靠性保障清单
| 保障项 | 如何实现 |
|---|---|
| 消息不丢失 | XADD 写入 RDB/AOF 持久化的 Stream |
| 消费失败可发现 | XPENDING 查看未确认消息 |
| 消费者宕机可恢复 | XAUTOCLAIM 转移超时 Pending |
| 不会重复处理 | 消费者实现幂等(eventId+幂等表) |
| 永久失败不阻塞 | 死信队列 + 告警 |
| Stream 不会无限增长 | MAXLEN/XTRIM 定期裁剪 |
4.3 思考题
-
设计题:如果订单事件需要同时被"订单落库服务"、"积分发放服务"和"短信通知服务"三个独立业务消费,应该用一个消费组还是三个消费组?请说明理由并画出架构图。
-
容量题:一个 Stream 每秒写入 1000 条消息,每条消息约 200 字节,保留最近 1 小时的数据。请估算 Stream 的大概内存占用,并设计裁剪策略。
(答案提示将在下一章末尾给出。)
上一章思考题答案提示(第19章):
第1题(先到先得模式):不需要预热库存到 Redis——可以用数据库的库存字段+乐观锁(version 字段),配合 Redis 的限流(INCR 控制进入数据库的并发数)。但 DB 仍会是瓶颈——更优方案仍是用 Redis 做库存缓存,只是不需要"抢完即止"的紧迫感。
第2题(Lua 脚本宕机):AOF 只会记录执行完成的命令。如果 Lua 脚本执行到一半 Redis 宕机,AOF 不会记录该脚本的任何操作——因为脚本"要么全部执行、要么全部不执行"的原子性保证了。但有个微妙情况——如果脚本中
DECR执行了,返回结果给客户端了,但 Redis 在写入 AOF 前宕机——客户端认为成功了,恢复后库存却没扣。生产上需要通过数据库的最终状态(卖出订单数)来对账 Redis 库存。
延伸阅读与资源
Redis 8 实战精讲:从 CRUD 到源码,构建高可用缓存系统
Java 工程师进阶:从 JVM 生产排障到OpenJDK原理
MySQL Server 9从入门到进阶的实战之旅
Nacos 3.x 注册配置中心实战修炼:从入门到源码扩展
Elasticsearch从入门到进阶的实战之旅
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号