消息丢了、重复消费了,MQ 这套账该怎么算

文章来源声明: 原文作者:珍猪吃饲料; 来源站点:掘金; 原文链接:https://juejin.cn/post/7709506192402710582; 本文基于上述来源整理/加工,觅优补充点评,仅供技术学习交流。版权归原作者所有。
觅优短评

文章把MQ可靠性拆成生产、存储、消费三段,并给出可落地的配置清单与幂等方案,适合后端架构评审和MQ接入时对照使用。

用 MQ 做异步解耦,最常被问的两个问题:
  • 消息会不会丢?
  • 会不会重复消费?

这两个问题的答案有点反直觉:消息一定会丢,也一定会重复。工程上要做的是"丢了能发现、重复了不坏事"。

这篇把消息从生产到消费的完整链路拆开,看每一环怎么保证不丢。

消息在哪些环节会丢

一条消息从生产者到消费者,要经过三个环节:

生产者 → Broker(存储)→ 消费者
  ①          ②            ③

三个环节都有可能丢:

环节丢失原因解决方案
① 生产网络抖动、Broker 挂了但生产端不知道同步发送 + 确认机制 + 重试
② 存储Broker 没落盘就宕机、主从没同步持久化 + 多副本 + 刷盘策略
③ 消费消费者拿到消息还没处理就挂了手动 ACK + 处理成功再确认

三个环节都堵上,才能说"不丢"。少一个都不行。

环节一:生产端

大部分人写生产端是这样的:

// 异步发送,发出去就不管了
rocketMQTemplate.asyncSend(topic, message, callback);

问题在于:如果 Broker 没收到,回调里的 onException 被吞了,消息就没了。

正确做法:

1. 同步发送,检查返回

SendResult result = producer.send(msg);
if (result.getSendStatus() != SendStatus.SEND_OK) {
    // 告警 + 重试
}

性能差一点,但可靠。金融类业务必须这样。

2. 异步发送,必须处理异常回调

producer.sendAsync(msg, new SendCallback() {
    @Override
    public void onSuccess(SendResult result) { }

    @Override
    public void onException(Throwable e) {
        log.error("send failed", e);
        // 重试 / 落库 / 告警
    }
});

3. 用事务消息,解决"本地事务成功但消息没发出去"

比如"创建订单 + 发消息",如果订单创建成功、消息发送失败,下游永远收不到。

RocketMQ 的事务消息:

// 1. 发送半消息(对消费者不可见)
// 2. 执行本地事务
// 3. 提交或回滚
rocketMQTemplate.sendMessageInTransaction("order-topic", msg, arg);

如果第三步没执行(比如进程挂了),Broker 会回查本地事务状态,决定提交还是丢弃。

环节二:Broker 存储

以 Kafka 为例,几个配置决定可靠性:

# 副本数(至少要 3)
default.replication.factor=3

# 至少 2 个副本确认才算成功
min.insync.replicas=2

# 生产端:所有 ISR 副本都确认
acks=all

Kafka 的 acks 有三个值:

acks含义可靠性
0发出去就不管最差
1Leader 写入成功就返回中等
all/-1所有 ISR 副本都写入才返回最高

配上 min.insync.replicas=2,即使 Leader 挂了,新 Leader 也一定包含这条消息。

RocketMQ 的不同在于刷盘策略:

策略说明可靠性
异步刷盘先写 page cache 就返回机器宕机会丢
同步刷盘落盘才返回不丢,但慢

还有主从同步方式:

  • 异步复制:主从之间异步同步,主挂了可能丢
  • 同步双写:主从都写入才返回,可靠性最高

我们的生产环境是同步刷盘 + 同步双写,性能降了约 30%,但核心业务这个代价值得付。

环节三:消费端

消费者最危险的是"自动提交 offset":

// 错误示范
props.put("enable.auto.commit", "true");   // 默认就是 true

问题在于:自动提交是按时间间隔提交的(默认 5 秒),跟"我处理成功了没有"完全无关。

场景:

  1. 消费者拉到消息
  2. 业务处理到一半
  3. 自动提交 offset(默认 5 秒一次)
  4. 进程崩溃
  5. 重启后从新 offset 开始——这条消息就丢了

正确做法:

props.put("enable.auto.commit", "false");

while (true) {
    ConsumerRecords<String, String> records = consumer.poll(100);

    for (ConsumerRecord<String, String> record : records) {
        try {
            handle(record.value());       // 业务处理
            consumer.commitSync(singleton(record));  // 处理成功才提交
        } catch (Exception e) {
            log.error("处理失败", e);
            // 不提交,交给重试或死信队列
        }
    }
}

先处理、后提交,这是"至少一次"语义的基本实现。

注意:如果处理完、提交前进程挂了,重启后会重复消费。这就是为什么"至少一次"必然带来"可能重复"。

重复消费怎么办

既然重复无法避免,就只能让消费逻辑幂等。

有三种常用方案:

1. 数据库唯一索引(最可靠)

INSERT INTO order_record (order_no, ...) VALUES (...);
-- order_no 上加唯一索引,重复插入直接报错

捕获 DuplicateKeyException 当作"已处理",直接 ACK。

2. 状态机

UPDATE orders SET status = 'PAID'
WHERE id = ? AND status = 'PENDING';

如果影响行数是 0,说明已经被处理过了。用"条件更新"实现幂等。

3. 去重表 / Redis 标记

String key = "msg:dedup:" + messageId;
Boolean first = redis.setIfAbsent(key, "1", 24, TimeUnit.HOURS);
if (!first) return;   // 已处理过

Redis 方案轻量,但要考虑"标记写入成功、业务还没执行"的中间态——可以用 SETNX + 业务在同一个事务里,或者接受极小概率的漏处理。

我的经验:能靠数据库唯一约束的,绝不用 Redis。数据库兜底最可靠。

顺序消息

有些业务严格要求顺序,比如"创建订单 → 支付 → 发货"。乱序会导致"发货消息先到,找不到订单"。

Kafka 保证分区内有序:

// 同一个订单 ID 必须发到同一个分区
producer.send(new ProducerRecord<>(topic, orderId, message));
// 用 orderId 作为 key,Kafka 会 hash 到固定分区

RocketMQ 用 MessageQueueSelector:

producer.send(msg, (queues, m, arg) -> {
    int index = Math.abs(arg.hashCode()) % queues.size();
    return queues.get(index);
}, orderId);

消费端要注意:顺序消息必须单线程消费,多线程并行就没有顺序可言了。

但顺序消费的吞吐量会大幅降低,所以只对真正需要的 topic 开启。

一个最终的可靠性配置清单

环节配置
生产同步发送 / 事务消息,重试 3 次,失败落库
Brokeracks=all,3 副本,同步刷盘
消费手动 ACK,先处理成功再提交
业务唯一索引或状态机保证幂等
兜底消息表 + 定时对账,死信队列告警

这张表贴在我们的架构评审模板里,新接入 MQ 的服务必须逐项确认。

最后

消息可靠性这件事,核心是理解"三个环节各自可能丢",然后逐个堵住。

不用追求 100% 不丢——成本太高,而且分布式系统不存在绝对可靠。工程上的标准是"可发现、可补偿、可重放":

  • 可发现:有对账、有监控
  • 可补偿:有重试、有死信
  • 可重放:消息可查、可从指定 offset 重新消费

做到这三条,就算丢了一条消息,也能在几小时内发现并修复。