RabbitMQ的预取值以及发布确认的策略

RabbitMQ的预取值以及发布确认的策略

RabbitMQ的预取值

RabbitMQ的信道上肯定不止只有一个消息，因此这里就存在一个未确认的消息缓冲区，因此希望开发人员能限制此缓冲区的大小，以避免缓冲区里面无限制的未确认消息问题。这个时候就可以通过使用 channel.basicQos() 方法设置“预取计数”值来完成的。该值定义通道上允许的未确认消息的最大数量。。一旦数量达到配置的数量，RabbitMQ 将停止在通道上传递更多消息，除非至少有一个未处理的消息被确认

代码演示

• 消费者,开启手动确认，同时给两个消费者设置不同的预取值，一个为2另一个为5，让两个程序分别进行不同时间的休眠，一个休眠1秒，一个休眠10秒，但是休眠1s的程序预取值为2，休眠10s的消费者预取值为5，两个消费者除了预取值与休眠时间外全部相等，以下为其中一个的代码

public class Worker01 {

    //设置队列名称
    public static final String TASK_QUEUE_NAME = "ack_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 工厂IP，连接RabbitMQ队列(安装RabbitMQ机器的IP地址)
        factory.setHost("xxx.xxx.xxx.xxx");
        //用户名
        factory.setUsername("username");
        //密码
        factory.setPassword("password");
        // 创建连接
        Connection connection = factory.newConnection();
        // 获取信道
        Channel channel = connection.createChannel();

        System.out.println("C1等待接收消息处理，时间较短。。");

        // 推送的消息如何进行消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            // 沉睡1S
            try {
                Thread.sleep(1000 * 1);
            } catch (InterruptedException _ignored) {
                Thread.currentThread().interrupt();
            }
            System.out.println("接收到的消息：" + new String(message.getBody(),"UTF-8"));
            // 手动应答
            /**
             * 1. 消息的标记 tag
             * 2. 是否批量应答 false 不批量，true 批量
             */
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };
        // 取消消息时的回调
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println("消息消费被中断");
        };
        // 设置预取值为2
        channel.basicQos(2);
        //采用手动应答
        Boolean autoAck = false;
        channel.basicConsume(TASK_QUEUE_NAME,autoAck,deliverCallback,cancelCallback);
    }
}

• 生产者与普通生产者相同，但需要注意，开启生产者的发布确认 // 开启发布确认channel.confirmSelect();

public class Task {
    //设置队列名称
    public static final String TASK_QUEUE_NAME = "ack_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        =========与上述的获取信道的方式相同==========
        // 开启发布确认　
        channel.confirmSelect();

        /**
         * 生成一个队列
         *  1. 队列名称
         *  2. 队列中的消息是否需要持久话（磁盘），默认情况消息存储在内存中
         *  3. 该队列是否只供一个消费者进行消费，是否进行消息共享，true可以多个消费者消费，false只能一个消费者消费
         *  4. 是否自动删除，最后一个消费者断开连接后，该队列是否自动删除 true自动删除，false则相反
         *  5. 其他参数
         */
        Boolean durable = true ; // 需要队列持久化
        channel.queueDeclare(TASK_QUEUE_NAME,durable,false,false,null);

        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String message = scanner.next();
            // 设置生产者发送消息为持久化消息（要求保存在磁盘上），
            channel.basicPublish("",TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes("UTF-8"));
            System.out.println("生产者发出消息："+message);
        }
    }
}

结果

• work01的虽然处理消息较快，但是也只处理了五个，但是由于work02处理的消息较慢，所以队列中存在未确认的消息，消息维持在5条，work02每处理一个，未确认的消息就减一
  
  

发布确认的三种策略

发布确认默认是没有开启的，如果要开启需要调用方法 channel.confirmSelect();，生产者将信道设置成 confirm 模式，一旦信道进入 confirm 模式，所有在该信道上面发布的消息都将会被指派一个唯一的 ID(从 1 开始)，一旦消息被投递到所有匹配的队列之后，broker就会发送一个确认给生产者(包含消息的唯一 ID)，这就使得生产者知道消息已经正确到达目的队列了

单个发布确认

这是一种简单的确认方式，它是一种同步确认发布的方式，也就是发布一个消息之后只有它
被确认发布，后续的消息才能继续发布这种确认方式有一个最大的缺点就是:发布速度特别的慢，因为如果没有确认发布的消息就会阻塞所有后续消息的发布，这种方式最多提供每秒不超过数百条发布消息的吞吐量。通过channel.waitForConfirms();来判断消息是否被确认，以下为单个发布的方法

   // 单个确认
    public static void publicMessageIndividually() throws Exception {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 工厂IP，连接RabbitMQ队列
        factory.setHost("xxx.xxx.xxx.xxx");
        //用户名
        factory.setUsername("username");
        //密码
        factory.setPassword("password");

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

        //声明随机队列
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName, false, false, false, null);
        //开启发布确认
        channel.confirmSelect();
        // 开始时间
        long startTime = System.currentTimeMillis();

        // 批量发消息
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("", queueName, null, message.getBytes());
            //单个消息马上就进行发布确认
            boolean flag = channel.waitForConfirms();
            if (flag) {
                System.out.println("消息发送成功！");
            }
        }
        //结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("发布" + MESSAGE_COUNT + "条单独确认消息，耗时：" + (endTime - startTime) + "ms");
    }

批量发布确认

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

 // 批量确认发布
    public static void publishMessageBatch() throws Exception {
        ========上述获取信道的方法获取信道=========
        //声明随机队列
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName, false, false, false, null);
        //开启发布确认
        channel.confirmSelect();
        // 开始时间
        long startTime = System.currentTimeMillis();

        // 批量确认消息的大小
        int batchSize = 100;

        // 批量发消息
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("", queueName, null, message.getBytes());
            // 当达到100条消息的时候，批量确认一次
            if (i % batchSize == 0) {
                // 发布确认
                channel.waitForConfirms();
            }
        }

        //结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("发布" + MESSAGE_COUNT + "条批量确认消息，耗时：" + (endTime - startTime) + "ms");
    }

异步确认

异步确认虽然编程逻辑比上两个要复杂，但是性价比最高，无论是可靠性还是效率都没得说，
他是利用回调函数来达到消息可靠性传递的，这个中间件也是通过函数回调来保证是否投递成功，通过配置信道的 channel.addConfirmListener(ackCallback,nackCallback);方法来进行异步确认，该方法的两个参数第一个为成功确认的消息监听器，第二个为失败的消息监听器

//异步发布确认
    public static void publicMessageAsync() throws IOException, TimeoutException {
       ===========与上述的获取信道的方式相同============
        //声明随机队列
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName, false, false, false, null);
        //开启发布确认
        channel.confirmSelect();
        /**
         * 线程安全有序的哈希表，适用于高并发情况下
         *  1. 轻松将序号与消息进行关联
         *  2. 轻松批量删除条目 只要给到序号
         *  3. 指出高并发（多线程）
         */
        ConcurrentSkipListMap<Long,String> outstandingConfirm = new ConcurrentSkipListMap<>();

        // 开始时间
        long startTime = System.currentTimeMillis();

        //消息监听器 监听哪些消息成功 哪些消息失败
        // 监听成功消息
        ConfirmCallback ackCallback = (deliveryTag, multiple) -> {
            if(multiple){
                //2.删除已经确认的消息 剩下的就是未确认的消息
                ConcurrentNavigableMap<Long, String> confirmed =
                        outstandingConfirm.headMap(deliveryTag);
                confirmed.clear();
            }else {
                outstandingConfirm.remove(deliveryTag);
            }

            System.out.println("成功确认的消息：" + deliveryTag);
        };
        // 监听失败消息
        /**
         * 1. 消息的标识
         * 2. 是否为批量确认
         */
        ConfirmCallback nackCallback = (deliveryTag,multiple) -> {
            String message = outstandingConfirm.get(deliveryTag);
            System.out.println("未确认的消息：" + deliveryTag);
        };
        channel.addConfirmListener(ackCallback,nackCallback);

        for (int i=0;i<MESSAGE_COUNT;i++){
            String message = "消息"+i;
            channel.basicPublish("", queueName, null, message.getBytes());
           // 记录下要发送的所有消息 消息的总和
            outstandingConfirm.put(channel.getNextPublishSeqNo(),message);
        }

        //结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("发布" + MESSAGE_COUNT + "条异步发布确认消息，耗时：" + (endTime - startTime) + "ms");

    }

总结

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

尚硅谷B站RabbitMQ教程：尚硅谷RabbitMQ