用 MQ 做异步解耦,最常被问的两个问题:
- 消息会不会丢?
- 会不会重复消费?
这两个问题的答案有点反直觉:消息一定会丢,也一定会重复。工程上要做的是"丢了能发现、重复了不坏事"。
这篇把消息从生产到消费的完整链路拆开,看每一环怎么保证不丢。
消息在哪些环节会丢
一条消息从生产者到消费者,要经过三个环节:
生产者 → Broker(存储)→ 消费者
① ② ③
三个环节都有可能丢:
| 环节 | 丢失原因 | 解决方案 |
|---|---|---|
| ① 生产 | 网络抖动、Broker 挂了但生产端不知道 | 同步发送 + 确认机制 + 重试 |
| ② 存储 | Broker 没落盘就宕机、主从没同步 | 持久化 + 多副本 + 刷盘策略 |
| ③ 消费 | 消费者拿到消息还没处理就挂了 | 手动 ACK + 处理成功再确认 |
三个环节都堵上,才能说"不丢"。少一个都不行。
环节一:生产端
大部分人写生产端是这样的:
java
// 异步发送,发出去就不管了
rocketMQTemplate.asyncSend(topic, message, callback);
问题在于:如果 Broker 没收到,回调里的 onException 被吞了,消息就没了。
正确做法:
1. 同步发送,检查返回
java
SendResult result = producer.send(msg);
if (result.getSendStatus() != SendStatus.SEND_OK) {
// 告警 + 重试
}
性能差一点,但可靠。金融类业务必须这样。
2. 异步发送,必须处理异常回调
java
producer.sendAsync(msg, new SendCallback() {
@Override
public void onSuccess(SendResult result) { }
@Override
public void onException(Throwable e) {
log.error("send failed", e);
// 重试 / 落库 / 告警
}
});
3. 用事务消息,解决"本地事务成功但消息没发出去"
比如"创建订单 + 发消息",如果订单创建成功、消息发送失败,下游永远收不到。
RocketMQ 的事务消息:
java
// 1. 发送半消息(对消费者不可见)
// 2. 执行本地事务
// 3. 提交或回滚
rocketMQTemplate.sendMessageInTransaction("order-topic", msg, arg);
如果第三步没执行(比如进程挂了),Broker 会回查本地事务状态,决定提交还是丢弃。
环节二:Broker 存储
以 Kafka 为例,几个配置决定可靠性:
properties
# 副本数(至少要 3)
default.replication.factor=3
# 至少 2 个副本确认才算成功
min.insync.replicas=2
# 生产端:所有 ISR 副本都确认
acks=all
Kafka 的 acks 有三个值:
| acks | 含义 | 可靠性 |
|---|---|---|
| 0 | 发出去就不管 | 最差 |
| 1 | Leader 写入成功就返回 | 中等 |
| all/-1 | 所有 ISR 副本都写入才返回 | 最高 |
配上 min.insync.replicas=2,即使 Leader 挂了,新 Leader 也一定包含这条消息。
RocketMQ 的不同在于刷盘策略:
| 策略 | 说明 | 可靠性 |
|---|---|---|
| 异步刷盘 | 先写 page cache 就返回 | 机器宕机会丢 |
| 同步刷盘 | 落盘才返回 | 不丢,但慢 |
还有主从同步方式:
- 异步复制:主从之间异步同步,主挂了可能丢
- 同步双写:主从都写入才返回,可靠性最高
我们的生产环境是同步刷盘 + 同步双写,性能降了约 30%,但核心业务这个代价值得付。
环节三:消费端
消费者最危险的是"自动提交 offset":
java
// 错误示范
props.put("enable.auto.commit", "true"); // 默认就是 true
问题在于:自动提交是按时间间隔提交的(默认 5 秒),跟"我处理成功了没有"完全无关。
场景:
- 消费者拉到消息
- 业务处理到一半
- 自动提交 offset(默认 5 秒一次)
- 进程崩溃
- 重启后从新 offset 开始------这条消息就丢了
正确做法:
java
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. 数据库唯一索引(最可靠)
sql
INSERT INTO order_record (order_no, ...) VALUES (...);
-- order_no 上加唯一索引,重复插入直接报错
捕获 DuplicateKeyException 当作"已处理",直接 ACK。
2. 状态机
sql
UPDATE orders SET status = 'PAID'
WHERE id = ? AND status = 'PENDING';
如果影响行数是 0,说明已经被处理过了。用"条件更新"实现幂等。
3. 去重表 / Redis 标记
java
String key = "msg:dedup:" + messageId;
Boolean first = redis.setIfAbsent(key, "1", 24, TimeUnit.HOURS);
if (!first) return; // 已处理过
Redis 方案轻量,但要考虑"标记写入成功、业务还没执行"的中间态------可以用 SETNX + 业务在同一个事务里,或者接受极小概率的漏处理。
我的经验:能靠数据库唯一约束的,绝不用 Redis。数据库兜底最可靠。
顺序消息
有些业务严格要求顺序,比如"创建订单 → 支付 → 发货"。乱序会导致"发货消息先到,找不到订单"。
Kafka 保证分区内有序:
java
// 同一个订单 ID 必须发到同一个分区
producer.send(new ProducerRecord<>(topic, orderId, message));
// 用 orderId 作为 key,Kafka 会 hash 到固定分区
RocketMQ 用 MessageQueueSelector:
java
producer.send(msg, (queues, m, arg) -> {
int index = Math.abs(arg.hashCode()) % queues.size();
return queues.get(index);
}, orderId);
消费端要注意:顺序消息必须单线程消费,多线程并行就没有顺序可言了。
但顺序消费的吞吐量会大幅降低,所以只对真正需要的 topic 开启。
一个最终的可靠性配置清单
| 环节 | 配置 |
|---|---|
| 生产 | 同步发送 / 事务消息,重试 3 次,失败落库 |
| Broker | acks=all,3 副本,同步刷盘 |
| 消费 | 手动 ACK,先处理成功再提交 |
| 业务 | 唯一索引或状态机保证幂等 |
| 兜底 | 消息表 + 定时对账,死信队列告警 |
这张表贴在我们的架构评审模板里,新接入 MQ 的服务必须逐项确认。
最后
消息可靠性这件事,核心是理解"三个环节各自可能丢",然后逐个堵住。
不用追求 100% 不丢------成本太高,而且分布式系统不存在绝对可靠。工程上的标准是"可发现、可补偿、可重放":
- 可发现:有对账、有监控
- 可补偿:有重试、有死信
- 可重放:消息可查、可从指定 offset 重新消费
做到这三条,就算丢了一条消息,也能在几小时内发现并修复。