消息队列 / 系统课时

Publisher Confirm 怎样工作

Publisher Confirm 怎样工作

Publisher Confirm 解决的是“消息写给 RabbitMQ 后,生产者怎样知道 Broker 是否真正接收了它”。开启 Confirm 模式后,Channel 会为发布分配序号,RabbitMQ 再用 ACK 或 NACK 异步反馈结果,生产者据此决定删除本地记录、重试或告警。

学习目标

  • 理解 Confirm 模式、发布序号与 ACK/NACK 的对应关系
  • 区分 Publisher Confirm 与消费者手动 ACK
  • 能用 Java 客户端监听确认并跟踪未确认消息

Confirm 的本质

Confirm 是 Channel 级别 的发布确认机制。生产者先调用 confirmSelect(),之后这个 Channel 上发布的消息都会进入确认流程。客户端可在发布前通过 getNextPublishSeqNo() 取得下一条消息的发布序号,RabbitMQ 随后用确认帧中的 deliveryTag 对这些序号进行确认。

ACK 表示 Broker 已经接受这次发布并完成该消息所需的 Broker 侧处理;NACK 表示 Broker 无法正常完成发布确认。这里的 ACK/NACK 与消费者调用 basicAck、basicNack 完全不同:前者是 Broker 对生产者的反馈,后者是消费者对 Broker 的消费结果反馈。

Publisher Confirm 的发布与确认时序

用异步 Confirm 跟踪未确认消息

下面示例在已加入 RabbitMQ Java Client 依赖的项目中运行。它使用服务端生成的临时队列,发送 3 条消息,并用线程安全的有序 Map 保存“尚未被确认”的发布序号。multiple=true 时,一次回调可能确认一批连续序号,因此需要批量移除并递减等待计数。

java
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.nio.charset.StandardCharsets;
import java.util.NavigableMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

public class PublisherConfirmDemo {
    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {

            String queue = channel.queueDeclare("", false, true, true, null).getQueue();
            channel.confirmSelect();

            int messageCount = 3;
            CountDownLatch latch = new CountDownLatch(messageCount);
            AtomicBoolean hasNack = new AtomicBoolean(false);
            ConcurrentNavigableMap<Long, String> outstanding =
                    new ConcurrentSkipListMap<>();

            ConfirmCallback ackCallback = (deliveryTag, multiple) -> {
                if (multiple) {
                    NavigableMap<Long, String> confirmed =
                            outstanding.headMap(deliveryTag, true);
                    int confirmedCount = confirmed.size();
                    confirmed.clear();
                    for (int i = 0; i < confirmedCount; i++) {
                        latch.countDown();
                    }
                } else if (outstanding.remove(deliveryTag) != null) {
                    latch.countDown();
                }
            };

            ConfirmCallback nackCallback = (deliveryTag, multiple) -> {
                hasNack.set(true);
                if (multiple) {
                    NavigableMap<Long, String> rejected =
                            outstanding.headMap(deliveryTag, true);
                    int rejectedCount = rejected.size();
                    rejected.clear();
                    for (int i = 0; i < rejectedCount; i++) {
                        latch.countDown();
                    }
                } else if (outstanding.remove(deliveryTag) != null) {
                    latch.countDown();
                }
            };

            channel.addConfirmListener(ackCallback, nackCallback);

            for (int i = 1; i <= messageCount; i++) {
                long sequenceNo = channel.getNextPublishSeqNo();
                String body = "message-" + i;

                // 先登记序号,再发布,避免确认回调先到而本地还没有记录。
                outstanding.put(sequenceNo, body);
                channel.basicPublish(
                        "",
                        queue,
                        null,
                        body.getBytes(StandardCharsets.UTF_8)
                );
            }

            if (!latch.await(5, TimeUnit.SECONDS)) {
                throw new IllegalStateException("等待 Publisher Confirm 超时");
            }

            System.out.println(
                    hasNack.get()
                            ? "至少一条消息收到 RabbitMQ NACK"
                            : "3 条消息均被 RabbitMQ ACK"
            );
        }
    }
}

预期输出

text
3 条消息均被 RabbitMQ ACK

如果 Broker 返回 NACK,程序会输出 NACK 分支;如果 5 秒内没有收齐确认,则抛出超时异常。确认回调是异步执行的,所以生产者不能假设 ACK 一定按“一条发布对应一次回调”的形式到达。

multiple 为什么重要

RabbitMQ 可以把多个连续发布压缩成一次确认。当 multiple=false 时,deliveryTag 只确认一个发布序号;当 multiple=true 时,表示该序号以及之前尚未确认的序号都一起被确认。高吞吐生产者通常因此维护一个按序号排序的待确认集合,而不是只保存“最后一条消息”。

生产者收到确认后做什么

可靠发布通常还需要本地状态配合。发送前把业务消息记录为“待确认”,收到 ACK 后再标记成功或删除;收到 NACK、超时或连接中断时,把消息转入重试或人工处理。这样 Confirm 才从一个协议反馈,变成可恢复的发布流程。

Publisher Confirm 的关键不是“每条消息都等一下”,而是让生产者拥有一个明确的 Broker 反馈通道。理解发布序号、deliveryTag 和 multiple 后,才能安全地实现批量或异步确认。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

Publisher Confirm 怎样工作

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通