从 01 开始
2023-06-05
目录

发布确认

# 90.发布确认

发布确认可以帮我们解决消息持久化时，可能会丢失的问题

# 原理

生产者可以将信道设置成 confirm 模式，一旦信道进入 confirm 模式，所有在该信道上面发布的消息都将会被指派一个唯一的 ID（从 1 开始），一旦消息被投递到所有匹配的队列之后，broker 就会发送一个确认给生产者（包含消息的唯一 ID），这就使得生产者知道消息已经正确到达目的队列了，如果消息和队列是可持久化的，那么确认消息会在将消息写入磁盘之后发出，broker 回传给生产者的确认消息中 delivery-tag 域包含了确认消息的序列号，此外 broker 也可以设置 basic.ack 的 multiple 域，表示到这个序列号之前的所有消息都已经得到了处理。

一句话：生产者发送消息后，等 MQ 持久化完成，就会和生产者说一声，这就叫发布确认

confirm 模式最大的好处在于他是异步的，一旦发布一条消息，生产者应用程序就可以在等信道返回确认的同时继续发送下一条消息，当消息最终得到确认之后，生产者应用便可以通过回调方法来处理该确认消息，如果 RabbitMQ 因为自身内部错误导致消息丢失，就会发送一条 nack 消息，生产者应用程序同样可以在回调方法中处理该 nack 消息。

# 开启发布确认的方法

发布确认默认是没有开启的，如果要开启需要调用方法 confirmSelect，每当你要想使用发布确认，都需要在 channel 上调用该方法

public static void publishMessageBatcg() throws Exception{
    Channel channel = RabbitMQUtils.getChannel();
    String queueName = UUID.randomUUID().toString();
    channel.queueDeclare(queueName, true, false, false, null);
    channel.confirmSelect();

    long begin = System.currentTimeMillis();

    // 批量确认的消息个数（不一定要1000个发完后再确认，可以每发100个就确认一次）
    int batchSize = 100;

    // 批量发消息
    for (int i = 1; i < message_count + 1; i++) {
        String message = String.valueOf(i);
        channel.basicPublish("", queueName, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
        if(i % batchSize == 0){
            channel.waitForConfirms();
        }
    }


    long end = System.currentTimeMillis();
    System.out.println("发布" + message_count + "个单独确认消息,耗时" + (end - begin) + "ms");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 单个确认发布

这是一种简单的确认方式，它是一种同步确认发布的方式，也就是发布一个消息之后只有它被确认发布，后续的消息才能继续发布，waitForConfirmsOrDie(long) 这个方法只有在消息被确认的时候才返回，如果在指定时间范围内这个消息没有被确认那么它将抛出异常。

这种确认方式有一个最大的缺点就是：发布速度特别的慢，因为如果没有确认发布的消息就会阻塞所有后续消息的发布，这种方式最多提供每秒不超过数百条发布消息的吞吐量，当然对于某些应用程序来说这可能已经足够了

我们可以写个测试方法来观察：

package com.peterjxl.rabbitmq.demo5;

import com.peterjxl.rabbitmq.util.RabbitMQUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;
import java.util.UUID;

public class ConfirmMessage {

    //批量发送消息的个数
    public static final int message_count = 1000;

    public static void main(String[] args) throws Exception{
        publishMessageIndividually();      //发布1000个单独确认消息,耗时650ms

    }

    public static void publishMessageIndividually() throws Exception{
        Channel channel = RabbitMQUtils.getChannel();
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName, true, false, false, null);
        channel.confirmSelect();


        long begin = System.currentTimeMillis();

        // 批量发消息
        for (int i = 0; i < message_count; i++) {
            String message = String.valueOf(i);
            channel.basicPublish("", queueName, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
            boolean flag = channel.waitForConfirms();
            if (flag) {
                System.out.println("消息发送成功");
            }
        }

        long end = System.currentTimeMillis();
        System.out.println("发布" + message_count + "个单独确认消息,耗时" + (end - begin) + "ms");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

‍ 运行结果：

发布1000个单独确认消息,耗时650ms
1

# 批量确认发布

上面那种方式非常慢，与单个等待确认消息相比，先发布一批消息然后一起确认可以极大地提高吞吐量，当然这种方式的缺点就是: 当发生故障导致发布出现问题时，不知道是哪个消息出现问题了，我们必须将整个批处理保存在内存中，以记录重要的信息而后重新发布消息。当然这种方案仍然是同步的，也一样阻塞消息的发布。

public static void publishMessageBatcg() throws Exception{
    Channel channel = RabbitMQUtils.getChannel();
    String queueName = UUID.randomUUID().toString();
    channel.queueDeclare(queueName, true, false, false, null);
    channel.confirmSelect();

    long begin = System.currentTimeMillis();

    // 批量确认的消息个数（不一定要1000个发完后再确认，可以每发100个就确认一次）
    int batchSize = 100;

    // 批量发消息
    for (int i = 1; i < message_count + 1; i++) {
        String message = String.valueOf(i);
        channel.basicPublish("", queueName, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
        if(i % batchSize == 0){
            channel.waitForConfirms();
        }
    }


    long end = System.currentTimeMillis();
    System.out.println("发布" + message_count + "个单独确认消息,耗时" + (end - begin) + "ms");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

‍ 运行结果：

发布1000个单独确认消息,耗时48ms
1

可以看到节省了很多时间。

# 异步确认发布

异步确认虽然编程逻辑比上两个要复杂，但是性价比最高，无论是可靠性还是效率都没得说，他是利用回调函数来达到消息可靠性传递的，这个中间件也是通过函数回调来保证是否投递成功：

‍

  1. 首先生产者会发送消息
  2. 然后信道会收到消息，将其放到一个类似 map 集合的地方，key 是消息序号，value 是消息内容。通过编号，就可以知道哪些消息发送成功了，哪些发送失败了
  3. 当 MQ 收到后，就会向信道发送成功的响应（通过回调）
  4. 如果没收到，也会发送失败的响应
  5. 生产者只需负责一直发送消息即可，不用管是否成功。然后 MQ 会返回成功和失败的响应给到生产者。

下面就让我们来详细讲解异步确认是怎么实现的

首先定义信道、记录时间、发送消息等代码是一样的，我们可以 copy 一份：（注意我们这里就不持久化了，方便测试）

public static void publishMessageAsync() throws Exception{
    Channel channel = RabbitMQUtils.getChannel();
    String queueName = UUID.randomUUID().toString();
    channel.queueDeclare(queueName, true, false, false, null);
    channel.confirmSelect();
    long begin = System.currentTimeMillis();

    for (int i = 0; i < message_count; i++) {
        String message = String.valueOf(i);
        channel.basicPublish("", queueName, null, message.getBytes());
   }

    long end = System.currentTimeMillis();
    System.out.println("发布" + message_count + "个异步确认消消息,耗时" + (end - begin) + "ms");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

‍ 那么如何实现异步确认呢？我们可以使用监听器。我们在发送消息之前，就开始监听，然后就可以监听到哪些消息发送成功了，哪些失败了。我们使用 channel.addConfirmListener() 方法来监听，该方法有 2 个重载：

void addConfirmListener(ConfirmListener var1);
ConfirmListener addConfirmListener(ConfirmCallback var1, ConfirmCallback var2);
1
2

‍ 参数说明：

  • 第一个方法，只监听成功收到的消息
  • 第二个方法，即监听成功，也监听失败的消息 ‍ 为此，我们定义两个回调函数，并设置这两个回调：
// 消息确认成功的回调函数
ConfirmCallback ackCallback = (deliveryTag, multiple) -> {
    System.out.println("确认的消息:" + deliveryTag);
};

// 消息确认失败的回调函数
ConfirmCallback nackCallback = (deliveryTag, multiple) -> {
    System.out.println("未确认的消息:" + deliveryTag);  
};

channel.addConfirmListener(ackCallback,nackCallback);   // 异步确认
1
2
3
4
5
6
7
8
9
10
11

然后我们测试下：可以看到只用了 27ms，并且发完后有很多的消息被响应了

# 如何处理异步未确认消息

最好的解决的解决方案就是把未确认的消息放到一个基于内存的能被发布线程访问的队列，比如说用 ConcurrentLinkedQueue，这个队列在 confirm callbacks 与发布线程之间进行消息的传递。

步骤如下：

  1. 在发送消息的时候，记录消息到 ConcurrentLinkedQueue
  2. 在确认消息的时候，删除 ConcurrentLinkedQueue 对应的记录
  3. 剩下的就是未确认的消息 ‍ 我们先定义该容器：
/**
 * 线程安全有序的一个哈希表，适用于高并发的情况下
 * 1.轻松的将序号与消息进行关联
 * 2.轻松批量删除条目 只要给到序列号
 * 3.支持高并发（多线程）
 * 4.此处的map不需要设置容量，底层采用跳表实现
 */
ConcurrentSkipListMap<Long, String> outstandingConfirms = new ConcurrentSkipListMap<>(); //outstanding:未解决的
1
2
3
4
5
6
7
8

‍ 在发送消息的时候，记录消息

for (int i = 0; i < message_count; i++) {
    String message = String.valueOf(i);
    channel.basicPublish("", queueName, null, message.getBytes());

    // 1:此处记录下所有要发送的消息，消息的总和
    outstandingConfirms.put(channel.getNextPublishSeqNo(), message);    // getNextPublishSeqNo()：获取下一条消息的序号
}
1
2
3
4
5
6
7

然后我们在确认消息的时候，删除已经确认的：

// 消息确认成功的回调函数
ConfirmCallback ackCallback = (deliveryTag, multiple) -> {

    System.out.println("确认的消息:" + deliveryTag);
    // 2：删除已确认的消息，剩下的就是未确认的消息
    // 判断是否批量，是则删除全部，不是则逐个删除
    if (multiple) {
        // 返回的是小于等于当前序号的未确认消息，因为是跳表，所以可以直接删除
        ConcurrentNavigableMap<Long, String> confirmed = 
                        outstandingConfirms.headMap(deliveryTag);
        confirmed.clear();
    } else {
        outstandingConfirms.remove(deliveryTag);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

‍ 最后打印未确认的：

 // 消息确认失败的回调函数
ConfirmCallback nackCallback = (deliveryTag, multiple) -> {
    // 3.打印未确认的消息
    String message = outstandingConfirms.get(deliveryTag);
    System.out.println("未确认的消息:" + message + " ,序号: " + deliveryTag);
};
1
2
3
4
5
6

‍ 然后我们运行，不过由于我们目前没有发送失败的消息，因此看不到有打印未确认的 ‍

# 以上 3 种发布确认速度对比

单独发布消息：同步等待确认，简单，但吞吐量非常有限。

批量发布消息：批量同步等待确认，简单，合理的吞吐量，一旦出现问题但很难推断出是那条消息出现了问题

异步处理：最佳性能和资源使用，在出现错误的情况下可以很好地控制，但是实现起来稍微难些 ‍

# 源码

本项目已将源码上传到 Gitee (opens new window) 或 GitHub (opens new window) 上。并且创建了分支 demo5，读者可以通过切换分支来查看本文的示例代码 ‍

上次更新: 2025/5/17 12:26:09
RabbitMQ 持久化和预取值
交换机

← 交换机→

最近更新
01
新闻合订本 2025-10
10-31
02
2025 年 10 月记
10-30
03
用 AI 批量优化思源笔记排版
10-15
更多文章>
Theme by Vdoing | Copyright © 2022-2025 | 粤 ICP 备 2022067627 号 -1 | 粤公网安备 44011302003646 号 | 点击查看十年之约