投稿
  1. 极客之音首页
  2. 技术随笔

【尚硅谷 RabbitMQ】3、图文详解 发布确认confirm 原理及策略（开启，单个、批量、异步）

小半 • • 技术随笔 • 阅读 199

导读：本篇文章讲解 【尚硅谷 RabbitMQ】3、图文详解 发布确认confirm 原理及策略（开启，单个、批量、异步），希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

1、发布确认原理

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

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

2、发布确认策略

1）开启发布确认

发布确认默认是没有开启的，如果要开启，生产者需要调用通道channel的方法 confirmSelect

Channel channel = connection.createChannel();
// 开启发布确认
channel.confirmSelect();

2）单个 发布确认

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

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

package com.tuwer.rabbitmq.confirm;

import com.rabbitmq.client.Channel;
import com.tuwer.utils.RabbitMqUtils;

import java.io.IOException;

/**
 * @author 土味儿
 * Date 2022/3/25
 * @version 1.0
 */
public class Producer {
    public static void main(String[] args) {
        // 单个确认发布
        oneConfirm();
    }
    
    /**
     * 单个发布确认
     */
    public static void oneConfirm(){
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 获取通道
        Channel channel = mqUtils.getChannel("192.168.19.101", 5672, "admin", "admin", "/", "生产者(单个确认发布)");

        // 队列名称
        String queueName = "oneComfirmQueue";
        try {
            // 声明队列
            channel.queueDeclare(queueName, true, false, false, null);
            // 开启确认发布
            channel.confirmSelect();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 消息
        String message = "";
        // 消息数量
        int messageCount = 1000;
        try {
            // 开始时间
            long begin = System.currentTimeMillis();
            // 循环发送消息
            for (int i = 0; i < messageCount; i++) {
                message = (i + 1) + "";
                channel.basicPublish("", queueName, null, message.getBytes());
                // 等待确认
                boolean flag = channel.waitForConfirms();
                if (flag) {
                    System.out.println("消息" + message + " 已发送！");
                }
            }
            // 结束时间
            long end = System.currentTimeMillis();
            // 总耗时
            System.out.println("发布" + messageCount + "条信息总耗时" + (end - begin) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭
            mqUtils.close();
        }
    }
}

在这里插入图片描述

在这里插入图片描述

3）批量 发布确认

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

public class Producer {
    public static void main(String[] args) {
        // 单个确认发布
        //oneConfirm();
        // 批量确认发布
        batchConfirm();
    }

    /**
     * 批量发布确认
     */
    public static void batchConfirm() {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 获取通道
        Channel channel = mqUtils.getChannel("192.168.19.101", 5672, "admin", "admin", "/", "生产者(批量确认发布)");

        // 队列名称
        String queueName = "batchComfirmQueue";
        try {
            // 声明队列
            channel.queueDeclare(queueName, true, false, false, null);
            // 开启确认发布
            channel.confirmSelect();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 消息
        String message = "";
        // 消息数量
        int messageCount = 1000;
        // 批量确认消息数量
        int batchSize = 100;
        try {
            // 开始时间
            long begin = System.currentTimeMillis();
            // 循环发送消息
            for (int i = 0; i < messageCount; i++) {
                message = (i + 1) + "";
                channel.basicPublish("", queueName, null, message.getBytes());

                // 批量确认
                if (i % batchSize == 99) {
                    // 等待确认
                    boolean flag = channel.waitForConfirms();
                    if (flag) {
                        System.out.println((i + 1) + "条消息已发送！");
                    }
                }
            }
            // 结束时间
            long end = System.currentTimeMillis();
            // 总耗时
            System.out.println("发布" + messageCount + "条信息总耗时" + (end - begin) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭
            mqUtils.close();
        }
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

4）异步 发布确认

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

在这里插入图片描述

public class Producer {
    public static void main(String[] args) {
        // 单个确认发布
        //oneConfirm();
        // 批量确认发布
        //batchConfirm();
        // 异步确认发布
        asyncConfirm();
    }

    /**
     * 异步发布确认
     */
    public static void asyncConfirm() {
        // 工具类
        RabbitMqUtils mqUtils = new RabbitMqUtils();
        // 获取通道
        Channel channel = mqUtils.getChannel("192.168.19.101", 5672, "admin", "admin", "/", "生产者(异步确认发布)");

        // 队列名称
        String queueName = "asyncComfirmQueue";
        try {
            // 声明队列
            channel.queueDeclare(queueName, true, false, false, null);
            // 开启确认发布
            channel.confirmSelect();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 消息
        String message = "";
        // 消息数量
        int messageCount = 1000;

        // ----- 添加确认监听器 -----
        // 确认回调
        ConfirmCallback ackCallback = (deliveryTag, multiple) -> {
            System.out.println("消息" + deliveryTag + "已确认发布！" + multiple);
        };
        // 未确认回调
        ConfirmCallback nackCallback = (deliveryTag, multiple) -> {
            System.out.println("消息" + deliveryTag + "未确认发布！");
        };
        // 确认监听器
        channel.addConfirmListener(ackCallback, nackCallback);

        try {
            // 开始时间
            long begin = System.currentTimeMillis();
            // 循环发送消息
            for (int i = 0; i < messageCount; i++) {
                message = (i + 1) + "";
                channel.basicPublish("", queueName, null, message.getBytes());
            }
            // 结束时间
            long end = System.currentTimeMillis();
            // 总耗时
            System.out.println("【异步确认】发布" + messageCount + "条信息总耗时" + (end - begin) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭
            //mqUtils.close();
        }
    }
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

未确认信息处理

  • 新建 未确认消息Map (并发Map)，保存未确认的信息（因为消息的发送和确认是不同的线程，所以用并发Map）
  • 发送消息前，把该消息存入 未确认消息Map中
  • 确认回调时，从未确认消息Map中删除已确认的消息
  • 最后Map中剩下的就是未确认的消息
/**
* 异步发布确认
*/
public static void asyncConfirm() {
    // 工具类
    RabbitMqUtils mqUtils = new RabbitMqUtils();
    // 获取通道
    Channel channel = mqUtils.getChannel("192.168.19.101", 5672, "admin", "admin", "/", "生产者(异步确认发布)");

    // 队列名称
    String queueName = "asyncComfirmQueue";
    try {
        // 声明队列
        channel.queueDeclare(queueName, true, false, false, null);
        // 开启确认发布
        channel.confirmSelect();
    } catch (IOException e) {
        e.printStackTrace();
    }

    // 消息
    String message = "";
    // 消息数量
    int messageCount = 1000;

    // 保存未确认信息：因为发布线程和确认线程是不同的，所以用并发工具类
    ConcurrentSkipListMap<Long, String> noConfirmMap = new ConcurrentSkipListMap<>();

    // ----- 添加确认监听器 -----
    // 确认回调
    ConfirmCallback ackCallback = (deliveryTag, multiple) -> {
        if (multiple) {
            // 批量确认
            // 得到批量确认信息Map
            ConcurrentNavigableMap<Long, String> confirmMap = noConfirmMap.headMap(deliveryTag);
            // 清空已经确认的
            confirmMap.clear();
        } else {
            // 非批量确认
            // 删除当前确认的信息
            noConfirmMap.remove(deliveryTag);
        }
        System.out.println("消息" + deliveryTag + "已确认发布！" + multiple);
    };
    // 未确认回调
    ConfirmCallback nackCallback = (deliveryTag, multiple) -> {
        String m = noConfirmMap.get(deliveryTag);
        System.out.println("【未确认消息】" + deliveryTag + " : " + m);
    };
    // 确认监听器
    channel.addConfirmListener(ackCallback, nackCallback);

    try {
        // 开始时间
        long begin = System.currentTimeMillis();
        // 循环发送消息
        for (int i = 0; i < messageCount; i++) {
            message = (i + 1) + "";
            // 把下一条要发送的信息存入未确认Map中
            noConfirmMap.put(channel.getNextPublishSeqNo(), message);
            // 发送
            channel.basicPublish("", queueName, null, message.getBytes());
        }
        // 结束时间
        long end = System.currentTimeMillis();
        // 总耗时
        System.out.println("【异步确认】发布" + messageCount + "条信息总耗时" + (end - begin) + "ms");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 关闭
        //mqUtils.close();
    }
}

在这里插入图片描述

在这里插入图片描述

  • 确认回调方法优化
// 确认回调
ConfirmCallback ackCallback = (deliveryTag, multiple) -> {
    // 如果是批量确认，删除小于 deliveryTag 的值
    if (multiple) {
        // 批量确认
        // 得到批量确认信息Map（只能得到小于 deliveryTag 的值）
        ConcurrentNavigableMap<Long, String> confirmMap = noConfirmMap.headMap(deliveryTag);
        // 清空
        confirmMap.clear();
    }

    // 删除当前确认的信息（等于 deliveryTag 的值）
    noConfirmMap.remove(deliveryTag);

    System.out.println("消息" + deliveryTag + "已确认发布！" + multiple);	
};

在这里插入图片描述

如果收到最后一条消息的回调方法，就可以关闭连接；

  • 在确认回调和未确认回调中同时添加
  • 工具类中添加closeConnection()方法；回调方法中关闭通道的话会抛异常
// 如果收到最后一条消息的回调方法，就可以关闭连接
 if(deliveryTag == messageCount){
     mqUtils.closeConnection();
 }

/**
 * 关闭连接
 */
public void closeConnection(){
    if (connection != null && connection.isOpen()) {
        try {
            connection.close();
            System.out.println("连接关闭！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • 为什么不直接在未确认回调方法中添加呢？

直接在未确认回调方法 ConfirmCallback nackCallback 中，把未确认的信息添加到Map中，这样就不用把所有信息都加入，再一个个地删除确认的消息！这种思路是正确的，但方法行不通！因为Map中存的有key(消息编号)和value(消息内容)，但是回调方法中只能得到消息编号deliveryTag，得不到消息内容。

如果回调方法中可以得到消息的内容就可以，以后再深入探究！未确认的消息不是永远都不确认，如果重发之后，确认了，还是要在确认回调方法中删除的。

借用缓存处理未确认信息（实现原理）

在这里插入图片描述

5）速度对比

发布方式 特点
单独发布 同步等待确认，简单，但吞吐量非常有限
批量发布 批量同步等待确认，简单，合理的吞吐量，一旦出现问题，很难推断出是那条消息出现了问题。
异步处理 最佳性能和资源使用，在出现错误的情况下可以很好地控制，但是实现起来稍微难些

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/70404.html

赞 (0)
小半的头像小半
0 0

相关推荐

极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！