RabbitMQ 的工作模式——Work Queues 工作队列模式

已于 2022-05-26 20:47:22 修改
阅读量724 收藏 3
点赞数
分类专栏： rabbitmq 文章标签： rabbitmq 分布式 java
于 2022-05-23 21:18:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingd1234/article/details/124934929
版权

一、轮询分发消息

1.1 模式说明

在这里插入图片描述
Work Queues：与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。
应用场景：对于任务过重或任务较多情况，使用工作队列可以提高任务处理的速度。

1.2 代码

ProducerWorkQueues

public class ProducerWorkQueues {
    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();
        // 创建队列Queue
        /*
        * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                                 Map<String, Object> arguments)
        *   queue:队列的名称
        *   durable：设置是否持久化。为 true 则设置队列为持久化。持久化的队列会存盘，在服务器重启的时候可以保证不丢失相关信息。
        *   exclusive：设置是否排他。为 true 则设置队列为排他的。有两层含义：
        *           1.是否独占，只能有一个消费者监听这队列
        *           2.当 Connection 关闭时是否删除队列
        *   autoDelete：设置是否自动删除。为 true 则设置队列为自动删除。
        *   arguments：设置队列的其他一些参数
        *
        * */
        channel.queueDeclare("work_queues", true, false, false, null);
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String message = scanner.next();
            // 发送消息
            /*
             * basicPublish(String exchange, String routingKey, boolean mandatory, BasicProperties props, byte[] body)
             *   exchange：交换器的名称，指明消息需要发送到哪个交换器中。如果设置为空字符串，则消息会被发送到 RabbitMQ 默认的交换器中。
             *   routingKey：路由键，交换器根据路由键将消息存储到相应的队列之中。如果使用默认交换器，RoutingKey 需要跟队列名保持一致。
             *   props：消息的基本属性集
             *   body：消息体（payload），真正需要发送的消息
             * */
            channel.basicPublish("", "work_queues", null, message.getBytes());
            System.out.println("消息发送成功：" + message);
        }
        // 释放资源
        channel.close();
        connection.close();
    }
}

ConsumerWorkQueues1

public class ConsumerWorkQueues1 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = RabbitMqUtil.getChannel();
        channel.queueDeclare("work_queues", true, false, false, null);
        System.out.println("消费者启动等待消费消息................");
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){

            /*
            * consumerTag：消费者标签，用来区分多个消费者
            * envelope：获取一些信息，交换器，路由key等等
            * properties：配置信息
            * body：消息
            * */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者接收到的消息:" + new String(body));
            }
        };
        /*
        * basicConsume(String queue, boolean autoAck, Consumer callback)
        *   queue：队列名称
        *   autoAck：设置是否自动确认。建议设置成false，即不自动确认
        *   callback：设置消费者的回调函数。用来处理 RabbitMQ 推送过来的消息，比如
        *           DefaultConsumer，使用时需要客户端重写其中的方法
        *
        * */
        channel.basicConsume("work_queues", true, consumer);

    }
}

ConsumerWorkQueues2

public class ConsumerWorkQueues1 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = RabbitMqUtil.getChannel();
        channel.queueDeclare("work_queues", true, false, false, null);
        System.out.println("消费者启动等待消费消息................");
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){

            /*
            * consumerTag：消费者标签，用来区分多个消费者
            * envelope：获取一些信息，交换器，路由key等等
            * properties：配置信息
            * body：消息
            * */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者接收到的消息:" + new String(body));
            }
        };
        /*
        * basicConsume(String queue, boolean autoAck, Consumer callback)
        *   queue：队列名称
        *   autoAck：设置是否自动确认。建议设置成false，即不自动确认
        *   callback：设置消费者的回调函数。用来处理 RabbitMQ 推送过来的消息，比如
        *           DefaultConsumer，使用时需要客户端重写其中的方法
        *
        * */
        channel.basicConsume("work_queues", true, consumer);

    }
}

先运行两个消费者，然后再运行生产者，运行结果如下：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.3 总结

1、在一个队列中，如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。消费者之间按照有序的一个接收一次消息。
2、Work Queues：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即可。

二、消息应答

2.1 概念

消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成了部分突然挂掉了，会发生什么情况呢？RabbitMQ 一旦向消费者传递了一条消息，便立即将该消息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息，以及后续发送给该消费者的消息。

为了保证消息在发送过程中不丢失，RabbitMQ 引入了消息应答机制，消息应答就是：消费者在接收到消息并且处理该消息之后，告诉 RabbitMQ 它已经处理了，RabbitMQ 可以把该消息删除了。

2.2 自动应答

消息发送后立即被认为已经传送成功，这种模式需要在高吞吐量和数据传输安全性方面做权衡，因为这种模式如果消息在接收到之前，消费者那边出现连接或者 channel 关闭，那么消息就丢失了，当然另一方面，这种模式消费者那边可以传递过载的消息，没有对传递的消息数据进行限制，当然这样有可能使得消费者这边由于接收太多还来不及处理的消息，导致这些消息的积压，最终是的内存耗尽，最终这些消费者线程被操作系统杀死，所以这种模式仅适用在消费者可以高效并以某种速率能够处理这些消息的情况下使用。

消费者在订阅队列时，可以指定 autoAck 参数，当 autoAck 等于 false 时，RabbitMQ 会等待消费者显示地恢复确认信号后才从内存（或者磁盘）中移去消息（实质上是先打上删除标记，之后再删除）。当 autoAck 等于 true 时，RabbitMQ 会自动把发送出去的消息置为确认，然后从内存（或磁盘）中删除，而不管消费者是否真正地消费到了这些消息。

采用消息应答机制后，只要设置 autoAck 参数为 false，消费者就有足够的时间处理消息（任务），不用担心处理消息过程中消费者进程挂掉后消息丢失的问题，因为 RabbitMQ 会一直等待持有消息知道消费者显式调用 Basic.Ack 命令为止。

当 autoAck 参数置为 false，对于 RabbitMQ 服务端而言，队列中的消息分成了两个部分：一部分是等待投递给消费者的消息；一部分是已经投递给消费者，但是还没有收到消费者确认信号的消息。如果 RabbitMQ 一直没有收到消费者的确认信号，并且消费此消息的消费者已经断开连接，则 RabbitMQ 会安排该消息重新进入队列，等待投递给下一个消费者，当然也有可能还是原来的那个消费者。

RabbitMQ 不会为未确认的消息设置过期时间，它判断此消息是否需要重新投递给消费者的唯一依据是消费该消息的消费者连接是否已经断开，这么设计的原因是 RabbitMQ 允许消费者消费一条消息的时间可以很久很久。

2.3 消息应答的方法

  • Channel.basicAck（用于肯定确认），RabbitMQ 已经知道该消息并且成功的处理消息，可以将其丢弃了
  • Channel.basicNack（用于否定确认）
  • Channel.basicReject（用于否定确认），与 Channel.basicNack 相比少一个参数。不处理该消息了直接拒绝，可以将其丢弃了。

2.4 Multiple 的解释

手动应答的好处是可以批量应答并且减少网络拥堵
在这里插入图片描述
multiple 的 true 和 false 代表不同的意思：

  • true 代表批量应答 channel 上未应答的消息，比如说 channel 上有传送 tag 的消息 5、6、7、8，当前 tag 是 8，那么此时 5~8 的这些还未应答的消息都会被确认收到消息应答。
  • false 同上面相比，只会应答 tag = 8 的消息，5、6、7这三个消息依然不会被确认收到消息应答
    在这里插入图片描述

2.5 消息自动重新入队

如果消费者由于某种原因失去连接（其通道已关闭，连接已关闭或 TCP 连接丢失），导致消息未发送 ACK 确认，RabbitMQ 将连接到消息未完全处理，并将对其重新排队。如果此时其他消费者可以处理，它将很快重新分发给另一个消费者。这样，即使某个消费者偶尔死亡，也可以确保不会丢失任何消息。
在这里插入图片描述

2.6 消息手动应答代码

2.6.1 手动确认消息

默认消息用的是自动应答，所以我们要想实现消息消费过程中不丢失，需要把自动应答改为手动应答。

生产者：ProducerWorkQueues2

public class ProducerWorkQueues2 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();
        // 创建队列Queue
        /*
        * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                                 Map<String, Object> arguments)
        *   queue:队列的名称
        *   durable：设置是否持久化。为 true 则设置队列为持久化。持久化的队列会存盘，在服务器重启的时候可以保证不丢失相关信息。
        *   exclusive：设置是否排他。为 true 则设置队列为排他的。有两层含义：
        *           1.是否独占，只能有一个消费者监听这队列
        *           2.当 Connection 关闭时是否删除队列
        *   autoDelete：设置是否自动删除。为 true 则设置队列为自动删除。
        *   arguments：设置队列的其他一些参数
        *
        * */
        channel.queueDeclare("work_queues", true, false, false, null);
        System.out.println("等待消息输入：");
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String message = scanner.next();
            // 发送消息
            /*
             * basicPublish(String exchange, String routingKey, boolean mandatory, BasicProperties props, byte[] body)
             *   exchange：交换器的名称，指明消息需要发送到哪个交换器中。如果设置为空字符串，则消息会被发送到 RabbitMQ 默认的交换器中。
             *   routingKey：路由键，交换器根据路由键将消息存储到相应的队列之中。如果使用默认交换器，RoutingKey 需要跟队列名保持一致。
             *   props：消息的基本属性集
             *   body：消息体（payload），真正需要发送的消息
             * */
            channel.basicPublish("", "work_queues", null, message.getBytes());
            System.out.println("消息发送成功：" + message);
        }
        // 释放资源
        channel.close();
        connection.close();
    }
}

消费者：WorkQueues1

public class WorkQueues1 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = RabbitMqUtil.getChannel();
        channel.queueDeclare("work_queues", true, false, false, null);
        System.out.println("消费者启动等待消费消息................处理时间较短");
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){

            /*
             * consumerTag：消费者标签，用来区分多个消费者
             * envelope：获取一些信息，交换器，路由key等等
             * properties：配置信息
             * body：消息
             * */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                SleepUtils.sleep(1);
                System.out.println("消费者接收到的消息:" + new String(body));
                /*
                * 确认应答
                * basicAck(long deliveryTag, boolean multiple)
                *   deliveryTag：消息编号，用于确认是哪条消息
                *   multiple：应答多个消息还是应答一个消息
                *       true：把当前消息和之前的消息一起应答
                *       false：只应答当前消息
                * */
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        /*
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         *   queue：队列名称
         *   autoAck：设置是否自动确认。建议设置成false，即不自动确认
         *   callback：设置消费者的回调函数。用来处理 RabbitMQ 推送过来的消息，比如
         *           DefaultConsumer，使用时需要客户端重写其中的方法
         *
         * */
        boolean autoAck = false;
        channel.basicConsume("work_queues", autoAck, consumer);

    }
}

消费者：WorkQueues2

public class WorkQueues2 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = RabbitMqUtil.getChannel();
        channel.queueDeclare("work_queues", true, false, false, null);
        System.out.println("C2消费者启动等待消费消息................处理时间较长");
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){

            /*
             * consumerTag：消费者标签，用来区分多个消费者
             * envelope：获取一些信息，交换器，路由key等等
             * properties：配置信息
             * body：消息
             * */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                SleepUtils.sleep(3000);
                System.out.println("消费者接收到的消息:" + new String(body));
                /*
                * 确认应答
                * basicAck(long deliveryTag, boolean multiple)
                *   deliveryTag：消息编号，用于确认是哪条消息
                *   multiple：应答多个消息还是应答一个消息
                *       true：把当前消息和之前的消息一起应答
                *       false：只应答当前消息
                * */
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        /*
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         *   queue：队列名称
         *   autoAck：设置是否自动确认。建议设置成false，即不自动确认
         *   callback：设置消费者的回调函数。用来处理 RabbitMQ 推送过来的消息，比如
         *           DefaultConsumer，使用时需要客户端重写其中的方法
         *
         * */
        boolean autoAck = false;
        channel.basicConsume("work_queues", autoAck, consumer);

    }
}

SleepUtils

public class SleepUtils {
    public static void sleep(int second){
        try {
            Thread.sleep(1000*second);
        } catch (InterruptedException _ignored) {
            Thread.currentThread().interrupt();
        }
    }
}

启动生产者和两个消费者，通过生产者发送两条消息
在这里插入图片描述
消息发送完毕后，将消费者 WorkQueue2 停止运行。
在这里插入图片描述
在这里插入图片描述
在生产者发送消息 bb，发出消息之后的把 C2 消费者停掉，按理说该 C2 来处理该消息，但是由于它处理时间较长，在还未处理完，也就是说 C2 还没有执行 ack 代码的时候，C2 被停掉了，此时会看到消息被 C1 接收到了，说明消息 bb 被重新入队，然后分配给能处理消息的 C1 处理了。

2.6.2 拒绝确认消息

2.6.2.1 basicNack 方法
public class WorkQueues2 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = RabbitMqUtil.getChannel();
        channel.queueDeclare("work_queues", true, false, false, null);
        System.out.println("消费者启动等待消费消息................处理时间较长");
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){

            /*
             * consumerTag：消费者标签，用来区分多个消费者
             * envelope：获取一些信息，交换器，路由key等等
             * properties：配置信息
             * body：消息
             * */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者接收到的消息:" + new String(body));
                /*
                * basicNack(long deliveryTag, boolean multiple, boolean requeue)
                *   deliveryTag：消息编号，用于确认是哪条消息
                *   multiple：应答多个消息还是应答一个消息
                *       true：把当前消息和之前的消息一起应答
                *       false：只应答当前消息
                *   requeue：是否重新入队
                *       true：消息重新入队
                *       false：丢弃消息或者进入到死信队列
                * */
                channel.basicNack(envelope.getDeliveryTag(), false, false);
            }
        };
        /*
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         *   queue：队列名称
         *   autoAck：设置是否自动确认。建议设置成false，即不自动确认
         *   callback：设置消费者的回调函数。用来处理 RabbitMQ 推送过来的消息，比如
         *           DefaultConsumer，使用时需要客户端重写其中的方法
         *
         * */
        boolean autoAck = false;
        channel.basicConsume("work_queues", autoAck, consumer);

    }
}
2.6.2.2 basicReject 方法
public class WorkQueues1 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = RabbitMqUtil.getChannel();
        channel.queueDeclare("work_queues", true, false, false, null);
        System.out.println("消费者启动等待消费消息................处理时间较短");
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){

            /*
             * consumerTag：消费者标签，用来区分多个消费者
             * envelope：获取一些信息，交换器，路由key等等
             * properties：配置信息
             * body：消息
             * */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                SleepUtils.sleep(1);
                System.out.println("消费者接收到的消息:" + new String(body));
                /*
                 * basicNack(long deliveryTag, boolean multiple, boolean requeue)
                 *   deliveryTag：消息编号，用于确认是哪条消息
                 *   requeue：是否重新入队
                 *       true：消息重新入队
                 *       false：丢弃消息或者进入到死信队列
                 * */
                channel.basicReject(envelope.getDeliveryTag(), false);
            }
        };
        /*
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         *   queue：队列名称
         *   autoAck：设置是否自动确认。建议设置成false，即不自动确认
         *   callback：设置消费者的回调函数。用来处理 RabbitMQ 推送过来的消息，比如
         *           DefaultConsumer，使用时需要客户端重写其中的方法
         *
         * */
        boolean autoAck = false;
        channel.basicConsume("work_queues", autoAck, consumer);

    }
}

Basic.Reject 命令一次只能拒绝一条消息，Basic.Nack 可以批量拒绝消息。

如果要求处理消息速度快，高吞吐量，使用自动应答。
如果对于数据安全性有要求，使用手动应答，可以保证消息不会丢失。

三、RabbitMQ 持久化

3.1 概念

默认情况下，RabbitMQ 退出或者由于某种原因崩溃时，它忽视队列和消息，除非告知它不要这样做。确保消息不会丢失需要做两件事：需要将队列话消息都标记为持久化。

3.2 队列实现持久化

之前我们创建的队列都是非持久化的，RabbitMQ 如果重启的话，该队列就会被删除掉，如果要队列实现持久化，需要在声明队列的时候把 durable 参数设置为持久化。
在这里插入图片描述
但是需要注意的就是，如果之前声明的队列不是持久化的，需要把原先队列先删除，或者重新创建一个持久化的队列，不然就会出现错误。
在这里插入图片描述
以下为控制台中持久化与非持久化的 UI 显示区：
非持久化：
在这里插入图片描述
持久化：
在这里插入图片描述

这个时候即使重启 RabbitMQ，队列也依然存在。

3.3 消息实现持久化

要想让消息实现持久化，需要在消息生产者修改代码，如下所示，添加属性 MessageProperties.PERSISTENT_TEXT_PLAIN，要想该属性起作用，需要先保证队列是持久化的。
在这里插入图片描述
将消息标记为持久化并不能完全保证不会丢失消息。当消息刚准备存储在磁盘的时候，此时 RabbitMQ 发生宕机，但是消息并未存储完，这就有可能造成消息丢失。因而，持久性保证并不强，但是对于简单任务队列而言，这已经绰绰有余了。如果需要更强有力的持久化策略，可以参考“发布确认”。

3.4 不公平分发

前面讲到，RabbitMQ 在分发消息时采用的是轮询分发机制，但是在某种场景下这种策略并不是很好，比方说有两个消费者在处理任务，其中消费者 1 处理任务的速度非常快，而消费者 2 处理速度却很慢，这个时候如果我们还是采用轮询分发的话，那么消费者 1 就会有很大一部分时间处于空闲状态，而消费者 2 则一直在干活。
为了避免这种情况，我们可以设置参数 channel.basicQos(1);
在这里插入图片描述
由于消息的发送是异步发送的，所以在任何时候，channel 上肯定不止只有一条消息，另外，来自消费者的手动确认本质上也是异步的。因此，这里就存在一个未确认的消息缓冲区，那么可以通过限制此缓冲区的大小，来避免缓冲区里面无限制的未确认消息的问题。这个时候就可以通过使用 basicQos 方法设置“预取计数：值来完成。该值定义通道上允许的未确认消息的最大数量。一旦数量达到配置的数量，RabbitMQ 将停止在通道上传递更多消息，除非至少有一个未处理的消息被确认。例如，假设在通道上有未确认的消息 5、6、7、8，并且通道的预取计数设置为 4，此时 RabbitMQ 将不会在该通道上再传递任何消息，除非至少有一个未应答的消息被 ack。比方说 tag = 6 的这条消息刚刚被确认 ack，RabbitMQ 将会感知到这个情况并在发送一条消息。消息应答和 QoS 预取值对用户吞吐量有重大影响。通常，增加预取将提高向消费者传递消息的速度。虽然自动应答传输消息速率是最佳的，但是，在这种情况下已传递但尚未处理的消息的数量也会增加，从而增加了消费者的 RAM 消耗（随机存取存储器），应该小心使用具有无限预处理的自动确认模式或手动确认模式，消费者消费了大量的消息如果没有确认的话，会导致消费者连接节点的内存消耗变大，所以找到合适的预取值是一个反复试验的过程，不同的负载改制取值也不同，100到300范围内的值通常可提供最佳的吞吐量，并且不会给消费者带来太大的风险。预取值为 1 是最保守的。当然这将使吞吐量变得很低，特别是消费者连接延迟很严重的情况下，特别是在消费者连接等待时间较长的环境中。对于大多数应用来说，稍微高一点的值将是最佳的。
在这里插入图片描述

生产者代码

public class ProducerWorkQueues2 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();
        // 创建队列Queue
        /*
        * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                                 Map<String, Object> arguments)
        *   queue:队列的名称
        *   durable：设置是否持久化。为 true 则设置队列为持久化。持久化的队列会存盘，在服务器重启的时候可以保证不丢失相关信息。
        *   exclusive：设置是否排他。为 true 则设置队列为排他的。有两层含义：
        *           1.是否独占，只能有一个消费者监听这队列
        *           2.当 Connection 关闭时是否删除队列
        *   autoDelete：设置是否自动删除。为 true 则设置队列为自动删除。
        *   arguments：设置队列的其他一些参数
        *
        * */
        channel.queueDeclare("work_queues", true, false, false, null);

        System.out.println("等待消息输入：");
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String message = scanner.next();
            // 发送消息
            /*
             * basicPublish(String exchange, String routingKey, boolean mandatory, BasicProperties props, byte[] body)
             *   exchange：交换器的名称，指明消息需要发送到哪个交换器中。如果设置为空字符串，则消息会被发送到 RabbitMQ 默认的交换器中。
             *   routingKey：路由键，交换器根据路由键将消息存储到相应的队列之中。如果使用默认交换器，RoutingKey 需要跟队列名保持一致。
             *   props：消息的基本属性集
             *   body：消息体（payload），真正需要发送的消息
             * */

            channel.basicPublish("", "work_queues", MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());

            System.out.println("消息发送成功：" + message);
        }

        // 释放资源
        channel.close();
        connection.close();
    }
}

消费者1 代码：

public class WorkQueues1 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = RabbitMqUtil.getChannel();
        channel.queueDeclare("work_queues", true, false, false, null);
        System.out.println("消费者启动等待消费消息................处理时间较短");
        // 设置预取值 该值定义的是通道上未确认消息的最大个数
        int prefetchCount = 3;
        channel.basicQos(prefetchCount);
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){

            /*
             * consumerTag：消费者标签，用来区分多个消费者
             * envelope：获取一些信息，交换器，路由key等等
             * properties：配置信息
             * body：消息
             * */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                SleepUtils.sleep(1);
                System.out.println("消费者接收到的消息:" + new String(body));
                /*
                * 确认应答
                * basicAck(long deliveryTag, boolean multiple)
                *   deliveryTag：消息编号，用于确认是哪条消息
                *   multiple：应答多个消息还是应答一个消息
                *       true：把当前消息和之前的消息一起应答
                *       false：只应答当前消息
                * */
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        /*
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         *   queue：队列名称
         *   autoAck：设置是否自动确认。建议设置成false，即不自动确认
         *   callback：设置消费者的回调函数。用来处理 RabbitMQ 推送过来的消息，比如
         *           DefaultConsumer，使用时需要客户端重写其中的方法
         *
         * */
        boolean autoAck = false;
        channel.basicConsume("work_queues", autoAck, consumer);

    }
}

消费者 2 代码

public class WorkQueues2 {
    public static void main(String[] args) throws IOException, TimeoutException {

        Channel channel = RabbitMqUtil.getChannel();
        channel.queueDeclare("work_queues", true, false, false, null);
        System.out.println("消费者启动等待消费消息................处理时间较长");
        // 设置预取值
        int prefetchCount = 2;
        channel.basicQos(prefetchCount);
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){

            /*
             * consumerTag：消费者标签，用来区分多个消费者
             * envelope：获取一些信息，交换器，路由key等等
             * properties：配置信息
             * body：消息
             * */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                SleepUtils.sleep(30);
                System.out.println("消费者接收到的消息:" + new String(body));
                /*
                * 确认应答
                * basicAck(long deliveryTag, boolean multiple)
                *   deliveryTag：消息编号，用于确认是哪条消息
                *   multiple：应答多个消息还是应答一个消息
                *       true：把当前消息和之前的消息一起应答
                *       false：只应答当前消息
                * */
                channel.basicAck(envelope.getDeliveryTag(), false);

            }
        };
        /*
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         *   queue：队列名称
         *   autoAck：设置是否自动确认。建议设置成false，即不自动确认
         *   callback：设置消费者的回调函数。用来处理 RabbitMQ 推送过来的消息，比如
         *           DefaultConsumer，使用时需要客户端重写其中的方法
         *
         * */
        boolean autoAck = false;
        channel.basicConsume("work_queues", autoAck, consumer);

    }
}

通过设置 Thread.sleep 的时间长短来模拟不同消费者的处理消息的速度。分别运行生产者以及两个消费者，通过生产者生产 7 条消息，来观察两个消费者消费消息的情况：
生产者：
在这里插入图片描述
消费者 1 由于处理速度较快，且 basicQoS 设置的值为 3，消费了 5 条消息
在这里插入图片描述

消费者 2 由于处理速度较慢，且 basicQoS 设置的值为 2 ，小于消费者 1 的预取值，只消费了 2 条消息
在这里插入图片描述

喵先森爱吃鱼
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
rabbitMQ工作队列共12页.pdf.zip
10-30
rabbitMQ工作队列共12页.pdf.zip
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
RabbitMQ在分布式系统中的应用
02-24
RabbitMQ提供了几种特性，牺牲了一点性能代价，提供了可靠性的保证。持久化当RabbitMQ退出时，默认会将消息和队列都清除，所以需要在第一次声明队列和发送消息时指定其持久化属性为true，这样RabbitMQ会将队列、消息和状态存到RabbitMQ本地的数据库，重启后会恢复。java: 注：当声明的队列已经存在时，尝试重新定义它的durable是不生效的。接收应答客户端接收消息的模式默认是自动应答，但是通过设置autoAck为false可以让客户端主动应答消息。当客户端拒绝此消息或者未应答便断开连接时，就会使得此消息重新入队（在版本2.7.0以前是到重新加入到队尾，2.7.0及以后是保留
RabbitMQ开发中文文档
07-25
RabbitMQ是一个消息服务器。从本质上讲，它接收生产者生产的消息，并发送给消费者。期间，它可以根据用户给定的规则来路由、缓存、持久化这些消息。此文为RabbitMQ的中文翻译文档
spring-rabbitmq-workqueue
05-08
Springrabbitmq 该应用程序是使用JHipster 5.0.0生成的，您可以在找到文档和帮助。 这是旨在作为微服务体系结构一部分的“微服务”应用程序，请参阅文档的页面以获取更多信息。 已使用配置此应用程序以进行服务发现和配置。 启动时，如果无法连接，它将拒绝启动。 发展 要在开发配置文件中启动您的应用程序，只需运行： ./gradlew 有关如何更多说明，请中 。 生产建筑 要优化生产的springrabbitmq应用程序，请运行： ./gradlew -Pprod clean bootWar 为确保一切正常，请运行： java -jar build/libs/*.war 有关更多详细信息，请参阅 。 测验 要启动应用程序的测试，请运行： ./gradlew test 有关更多信息，请参阅“。 使用Docker简化开发（可选） 您可以使用Docker来改善您的J
【RabbitMQ教程】Work queues 工作队列模式
qq_43783527的博客
10-09 942
将‘work queues工作队列模式’单独抽出来细讲，目的是借助这个模式好好讲一下rabbitmq的‘轮询分发’和‘公平分配’。
RabbitMQ 6种队列模式——Work queues工作队列
祝我飞黄腾达
03-22 842
上一篇博文，详细模拟了简单队列模式， 简单队列有个缺点，简单队列是一一对应的关系，即点对点，一个生产者对应一个消费者，按照这个逻辑，如果我们有一些比较耗时的任务，也就意味着需要大量的时间才能处理完毕，显然简单队列模式并不能满足我们的工作需求。 工作队列模式概念 一个消息生产者，一个交换器，一个消息队列，多个消费者。同样也称为点对点模式 当消息生产速度远大于消费速度时，消息队列就会爆满，从而导致服务器不可用，那么我们就要设置多个消费者，共同进行消费。 但是不同的消费者处理消息的快慢也不.
RabbitMQ（二）：Work Queues、循环分发、消息确认、持久化、公平分发
张维鹏的博客
04-29 2149
内容翻译自：RabbitMQ Tutorials Java版 RabbitMQ（一）：Hello World程序 RabbitMQ（二）：Work Queues、循环分发、消息确认、持久化、公平分发 RabbitMQ（三）：Exchange交换器--fanout RabbitMQ（四）：Exchange交换器--direct RabbitMQ（五）：Exchange交换器--topic ...
RabbitMQ消息模型之Work Queues
学而时习之，不亦说乎？温故而知新，可以为师矣！
11-29 488
，任务模型，也是官网给出的第二个模型，使用的交换机类型是直连direct，也是默认的交换机类型。当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。这里使用的生产者和消费者都是一样的，区别是消费者同时运行了两个进程。队列中的消息一旦消费，就会消失，因此任务是不会被重复执行的。可以看到，消息被轮训均匀分配给了两个消费者。Work Queues，也被称为（
RabbitMQ快速学习之WorkQueues模型、三种交换机、消息转换器（基于SpringBoot）
浩泽学编程的博客
11-29 1145
WorkQueues模型、Fanout交换机、Direct交换机、Topic交换机、基于SpringBoot注解声明队列和交换机、消息转换器。以上就是所有讲解。
第11周1-第04章节-Python3.5-RabbitMQ消息分发轮询.mp4
02-09
第11周1-第04章节-Python3.5-RabbitMQ消息分发轮询.mp4
linux中rabbitmq安装包
09-07
linux中rabbitmq安装包
rabbitMQ简单应用pattern1 Work queues 工作队列模式
07-10
Work Queues与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列 中的消息。 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
C#开发的RabbitMQ队列模式
03-25
C#开发的RabbitMQ队列模式，分为生产者和消费者两个程序，使用vs2019开发的，可以运行使用，在根据自己的需求加工即可，另外在本人另外的资源还提供主题订阅模式的，已经实现了定时读取mysql数据库数据转为json发送...
消息队列RabbitMQ入门与5种模式详解
01-27
RabbitMQ是开源的，实现了AMQP协议的，采用Erlang(面向并发编程语言)编写的，可复用的企业级消息系统； AMQP（高级消息队列协议）是一个异步消息传递所使用应用层协议规范，为面向消息中间件设计，基于此协议的...
【消息队列】RabbitMQ五种消息模式
最新发布
weixin_62513677的博客
04-30 1753
Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息，包含两部分，其中Spring-amqp是基础抽象，spring-rabbit是底层的默认实现。这是为了防止消息队列中的队列不存在，在进行消息队列初始化的时候不知道是先建立消费者，还是先建立生产者，所以都执行创建函数，但是创建的队列只有一个不会重复。发布者发送消息时，指定消息的RoutingKey，Exchange将消息路由到BindingKey与消息RoutingKey一致的队列。Work queue，工作队列。
【RabbitMQ 二】RabbitMQ基本组成、交换器类型、RabbitMQ生产消费消息流程、信道Channel、AMQP协议
日月既往，不可复追
04-29 476
RabbitMQ有一些基本的组成单元：消息生产者发送消息流程如下：消费者消费消息的流程如下：
谷粒商城实战(019 RabbitMQ-发送消息)
wang_book的博客
04-29 1181
MQ的三大特点：流量削峰、应用解耦、异步处理redis是数据缓存，mq是任务缓存AMQP的MODEL 第一种是队列的实现 后四种是订阅的实现网络间传输 万物皆流。
RabbitMQ通配符模式
记录知识点的博客
04-27 1220
RabbitMQ通配符模式
rabbitmq 工作模式
09-01
RabbitMQ提供了6种工作模式，包括简单模式、work queues、Publish/Subscribe发布与订阅模式、Routing路由模式、Topics主题模式、RPC远程调用模式（不太符合MQ）。这些模式分别具有不同的特点和使用场景。简单模式是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值