消息队列 / 系统课时
发布者确认
发布者确认
Publisher Confirm 用来解决“消息发出去以后,发布者怎样知道 RabbitMQ 是否真正接管了它”。开启确认模式后,Broker 会按发布序号返回 ack 或 nack;应用可以逐条等待、按批等待,或异步处理确认结果,在可靠性与吞吐量之间选择合适的策略。
学习目标
- 启用 Publisher Confirm,并正确理解
ack、nack与发布序号 - 掌握单条确认、批量确认和异步确认三种处理方式
- 理解确认机制与路由成功、消费者确认之间的边界
Confirm 确认的是发布端到 Broker 的责任交接
发布者在 Channel 上启用 confirm 模式后,每次 basic.publish 都会获得一个单调递增的发布序号。Broker 处理完成后返回确认:ack 表示该发布已被接受,nack 表示 Broker 无法完成处理。确认只属于当前 Channel,序号也必须按 Channel 分开追踪。
multiple=true 时,一个确认可以覆盖“序号小于等于当前值”的一批未确认消息,因此异步实现通常使用按序号排序的待确认集合,而不是为每条消息建立独立线程。

一个程序演示三种确认策略
下面示例使用 RabbitMQ Java Client。项目需要已经引入 com.rabbitmq:amqp-client;代码本身包含完整入口,并假设本机 RabbitMQ 使用默认连接参数。队列声明为持久队列,消息也使用持久属性,这样确认结果与持久化语义可以一起验证。
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
import java.nio.charset.StandardCharsets;
import java.util.NavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.atomic.AtomicInteger;
public class PublisherConfirmDemo {
private static final String QUEUE = "confirm.demo";
public static void main(String[] args) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
try (Connection connection = factory.newConnection()) {
publishOneByOne(connection);
publishInBatch(connection);
publishAsync(connection);
}
}
private static void publishOneByOne(Connection connection) throws Exception {
try (Channel channel = connection.createChannel()) {
channel.queueDeclare(QUEUE, true, false, false, null);
channel.confirmSelect();
for (int i = 1; i <= 3; i++) {
publish(channel, "single-" + i);
// 每发一条就阻塞等待确认,语义最直观但吞吐最低。
channel.waitForConfirmsOrDie(5_000);
System.out.println("single ack: " + i);
}
}
}
private static void publishInBatch(Connection connection) throws Exception {
try (Channel channel = connection.createChannel()) {
channel.queueDeclare(QUEUE, true, false, false, null);
channel.confirmSelect();
for (int i = 1; i <= 10; i++) {
publish(channel, "batch-" + i);
}
channel.waitForConfirmsOrDie(5_000);
System.out.println("batch ack: 10 messages");
}
}
private static void publishAsync(Connection connection) throws Exception {
try (Channel channel = connection.createChannel()) {
channel.queueDeclare(QUEUE, true, false, false, null);
channel.confirmSelect();
NavigableMap<Long, String> outstanding =
new ConcurrentSkipListMap<>();
AtomicInteger nacks = new AtomicInteger();
channel.addConfirmListener(
(sequence, multiple) ->
removeConfirmed(outstanding, sequence, multiple),
(sequence, multiple) -> {
nacks.incrementAndGet();
System.err.println(
"nack: sequence=" + sequence
+ ", multiple=" + multiple
);
removeConfirmed(outstanding, sequence, multiple);
}
);
for (int i = 1; i <= 10; i++) {
String body = "async-" + i;
long sequence = channel.getNextPublishSeqNo();
outstanding.put(sequence, body);
publish(channel, body);
}
long deadline = System.nanoTime() + 5_000_000_000L;
while (!outstanding.isEmpty() && System.nanoTime() < deadline) {
Thread.sleep(10);
}
if (!outstanding.isEmpty()) {
throw new IllegalStateException(
"confirm timeout, pending=" + outstanding.size()
);
}
if (nacks.get() > 0) {
throw new IllegalStateException(
"broker nacked " + nacks.get() + " publish(es)"
);
}
System.out.println("async ack: 10 messages");
}
}
private static void publish(Channel channel, String body) throws Exception {
channel.basicPublish(
"",
QUEUE,
MessageProperties.PERSISTENT_TEXT_PLAIN,
body.getBytes(StandardCharsets.UTF_8)
);
}
private static void removeConfirmed(
NavigableMap<Long, String> outstanding,
long sequence,
boolean multiple
) {
if (multiple) {
outstanding.headMap(sequence, true).clear();
} else {
outstanding.remove(sequence);
}
}
}在已经配置好 RabbitMQ Java Client 依赖的项目中运行 PublisherConfirmDemo。Broker 正常并且本机连接参数可用时,三种策略都会收到成功确认。
预期输出
single ack: 1
single ack: 2
single ack: 3
batch ack: 10 messages
async ack: 10 messages异步确认的具体 ack 到达时刻不可预测,因此示例只在全部未确认序号被移除后打印最终结果;如果发生 nack 或超时,则程序直接失败,而不是把失败消息当作成功。
三种策略怎么选
单条确认每发布一条就等待一次,最容易实现和定位失败,但网络往返会直接限制吞吐量,适合低频、强可读性的控制类消息。批量确认先连续发送一组消息,再等待整批确认,吞吐明显更好,但一旦批次失败,应用往往需要重发整个批次,必须接受可能产生重复消息。
异步确认让发布线程持续发送,由回调根据发布序号清理待确认集合,通常能获得最高吞吐,也最适合生产环境的高并发发布。代价是必须维护未确认消息、超时、nack、Channel 关闭以及重试策略;重试还要假设“原消息可能其实已经成功”,所以消费者端必须具备幂等能力。
| 策略 | 发布线程是否等待 | 吞吐 | 失败定位 |
|---|---|---|---|
| 单条确认 | 每条等待 | 低 | 最直接 |
| 批量确认 | 每批等待 | 中到高 | 常以批次为单位处理 |
| 异步确认 | 不同步等待 | 高 | 需按序号自行追踪 |
不要把 Confirm 当成消费成功回执
Publisher Confirm 只覆盖 Publisher 到 RabbitMQ 的发布阶段。消息是否成功路由还要看 Exchange、Binding 和 Queue;如果必须发现“没有任何队列接收”的情况,应结合 mandatory 发布与 basic.return 处理。消息进入队列以后,消费者是否处理成功则要靠 Consumer Ack、重试、死信和业务幂等保证。
可靠发布的判断顺序应当是:先用持久化定义消息和队列的保存语义,再用 Publisher Confirm 判断 Broker 是否接管发布,必要时用 mandatory 检查不可路由消息,最后由 Consumer Ack 与幂等机制完成消费侧闭环。