1. 项目背景

1.1 从 List 到 Stream 的演进

前几章我们用 List 做了订单异步通知队列。List 做队列简单好用——RPUSH 生产者入队,BLPOP 消费者阻塞取任务。但随着业务复杂化,List 暴露出几个致命短板:

  1. 消息确认缺失:BLPOP 取走消息后立刻从队列删除。消费者处理到一半宕机——消息永久丢失,没有任何记录。
  2. 无消费进度:多个消费者无法知道"谁处理了哪条消息"、"哪些消息待处理"。
  3. 不支持消费组:一条消息只能被一个消费者拿走。如果需要"同一消息被多个业务方消费"(如订单事件既要通知积分系统又要通知仓库系统),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 思考题

  1. 设计题:如果订单事件需要同时被"订单落库服务"、"积分发放服务"和"短信通知服务"三个独立业务消费,应该用一个消费组还是三个消费组?请说明理由并画出架构图。

  2. 容量题:一个 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的网络实战圣经

posted on 2026-11-15 20:46  一天不进步,就是退步  阅读(7)  评论(0)    收藏  举报