消息队列 / 系统课时

异步 Confirm 怎样跟踪消息

异步 Confirm 怎样跟踪消息

异步 Confirm 允许发布线程持续发送,不必在每条或每批消息后停下来等待。真正的难点是把稍后到达的 ACK、NACK 与原始消息重新对应起来,因此需要用发布序号维护“未确认消息集合”,并正确处理一次确认多个序号的情况。

学习目标

  • 理解发布序号、未确认集合与 Confirm 回调之间的对应关系
  • 用线程安全的有序映射处理单条和 multiple=true 的 ACK、NACK
  • 避免在 Confirm 回调线程中直接执行重发等耗时 Channel 操作

异步 Confirm 的核心模型

Channel 开启 Confirm 后,每次发布都会对应一个单调递增的发布序号。发送前先读取 getNextPublishSeqNo(),把“序号 → 原始消息”放入未确认集合,再执行 basicPublish。Broker 稍后返回 ACK 或 NACK,回调根据序号删除对应记录;若是 NACK,则把消息转交给重试路径。RabbitMQ Java 教程明确给出了这种“序号关联 + Confirm Listener”的实现思路。([RabbitMQ][1])

异步 Confirm 通过发布序号关联 ACK、NACK 与原始消息

用发布序号关联消息

下面的完整示例使用 ConcurrentSkipListMap 保存未确认消息。它既支持按单个序号删除,也能在 multiple=true 时高效取得“小于等于某个序号”的连续范围。CountDownLatch 只用于演示等待所有 Confirm 事件结束,不会阻塞实际发布循环。

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.AbstractMap;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;

public class AsyncConfirmDemo {
    private static final int MESSAGE_COUNT = 20;

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

        ConcurrentNavigableMap<Long, String> outstanding =
                new ConcurrentSkipListMap<>();
        ConcurrentLinkedQueue<String> retryQueue =
                new ConcurrentLinkedQueue<>();
        CountDownLatch confirmEvents = new CountDownLatch(MESSAGE_COUNT);

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

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

            ConfirmCallback ackCallback = (sequenceNumber, multiple) -> {
                int handled = removeConfirmed(
                        outstanding, sequenceNumber, multiple, ignored -> {}
                );
                countDown(confirmEvents, handled);
            };

            ConfirmCallback nackCallback = (sequenceNumber, multiple) -> {
                int handled = removeConfirmed(
                        outstanding, sequenceNumber, multiple, retryQueue::add
                );
                countDown(confirmEvents, handled);
            };

            channel.addConfirmListener(ackCallback, nackCallback);

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

                // 必须在 publish 前建立关联,避免 Confirm 到达后找不到原消息。
                outstanding.put(sequenceNumber, body);
                channel.basicPublish(
                        "",
                        queue,
                        null,
                        body.getBytes(StandardCharsets.UTF_8)
                );
            }

            boolean completed = confirmEvents.await(5, TimeUnit.SECONDS);
            System.out.printf(
                    "completed=%s, outstanding=%d, retry=%d%n",
                    completed,
                    outstanding.size(),
                    retryQueue.size()
            );
        }
    }

    private static int removeConfirmed(
            ConcurrentNavigableMap<Long, String> outstanding,
            long sequenceNumber,
            boolean multiple,
            Consumer<String> onRemoved) {

        List<Map.Entry<Long, String>> candidates = new ArrayList<>();

        if (multiple) {
            candidates.addAll(
                    outstanding.headMap(sequenceNumber, true).entrySet()
            );
        } else {
            String body = outstanding.get(sequenceNumber);
            if (body != null) {
                candidates.add(
                        new AbstractMap.SimpleImmutableEntry<>(
                                sequenceNumber, body
                        )
                );
            }
        }

        int removed = 0;
        for (Map.Entry<Long, String> entry : candidates) {
            if (outstanding.remove(entry.getKey(), entry.getValue())) {
                onRemoved.accept(entry.getValue());
                removed++;
            }
        }
        return removed;
    }

    private static void countDown(CountDownLatch latch, int count) {
        for (int i = 0; i < count; i++) {
            latch.countDown();
        }
    }
}

预期输出

text
completed=true, outstanding=0, retry=0

上面的输出表示 20 条消息都收到了 Confirm 事件且没有 NACK。若 Broker 返回 NACK,retry 会大于 0;若 5 秒内仍有消息未收到 Confirm,则 completed 可能为 false,并且 outstanding 仍保留未完成记录。实际网络与 Broker 状态不同,结果可能不同。

正确处理 multiple 标志

Confirm 回调同时提供 sequenceNumber 与 multiple。当 multiple=false 时,只处理该序号;当 multiple=true 时,表示这个序号以及之前尚未确认的序号可以一起处理。因此未确认集合最好同时具备线程安全和按序号范围删除能力。RabbitMQ 官方教程也明确说明了 multiple=true 的“当前序号及其之前序号”语义。([RabbitMQ][1])

发送线程和 Confirm 回调线程会并发访问这份集合,所以普通 TreeMap 或 HashMap 不是合适选择。示例使用 ConcurrentSkipListMap,既避免并发修改问题,又能通过 headMap(sequenceNumber, true) 取得需要批量清理的范围。

回调线程只做轻量工作

收到 NACK 后,不要直接在 Confirm 回调里再次调用同一个 Channel 执行重发。RabbitMQ 官方教程指出 Confirm 回调运行在客户端 I/O 线程中,不应在这里执行 Channel 操作;更稳妥的做法是把失败消息放入线程安全队列,再由独立发布线程读取并重试。([RabbitMQ][1])

生产环境还应为未确认集合设置上限或背压,否则 Broker 变慢、网络抖动时,发布线程仍持续写入会使集合不断增长。异步 Confirm 的优势来自“发送与确认解耦”,但可靠性取决于序号关联、并发清理、NACK 转交和未确认上限这几件事同时做对。

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

目录与阅读设置

阅读设置

17

记录一个想法

异步 Confirm 怎样跟踪消息

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

登录哪都通