消息队列 / 系统课时

发布者确认

发布者确认

Publisher Confirm 用来解决“消息发出去以后,发布者怎样知道 RabbitMQ 是否真正接管了它”。开启确认模式后,Broker 会按发布序号返回 ack 或 nack;应用可以逐条等待、按批等待,或异步处理确认结果,在可靠性与吞吐量之间选择合适的策略。

学习目标

  • 启用 Publisher Confirm,并正确理解 ack、nack 与发布序号
  • 掌握单条确认、批量确认和异步确认三种处理方式
  • 理解确认机制与路由成功、消费者确认之间的边界

Confirm 确认的是发布端到 Broker 的责任交接

发布者在 Channel 上启用 confirm 模式后,每次 basic.publish 都会获得一个单调递增的发布序号。Broker 处理完成后返回确认:ack 表示该发布已被接受,nack 表示 Broker 无法完成处理。确认只属于当前 Channel,序号也必须按 Channel 分开追踪。

multiple=true 时,一个确认可以覆盖“序号小于等于当前值”的一批未确认消息,因此异步实现通常使用按序号排序的待确认集合,而不是为每条消息建立独立线程。

Publisher Confirm 三种处理策略与确认时序

一个程序演示三种确认策略

下面示例使用 RabbitMQ Java Client。项目需要已经引入 com.rabbitmq:amqp-client;代码本身包含完整入口,并假设本机 RabbitMQ 使用默认连接参数。队列声明为持久队列,消息也使用持久属性,这样确认结果与持久化语义可以一起验证。

java
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 正常并且本机连接参数可用时,三种策略都会收到成功确认。

预期输出

text
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 与幂等机制完成消费侧闭环。

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

目录与阅读设置

阅读设置

17

记录一个想法

发布者确认

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

登录哪都通