深入理解RabbitMQ Work Queues模型及其高效应用

Takumilovexu

已于 2024-10-09 13:46:04 修改

阅读量1.1k

点赞数 5

CC 4.0 BY-SA版权

分类专栏： MQ 文章标签： java-rabbitmq rabbitmq java

于 2024-08-02 09:25:23 首次发布

本文链接：https://blog.youkuaiyun.com/Takumilove/article/details/140863669

MQ 专栏收录该内容

21 篇文章

订阅专栏

文章目录

在实际的系统开发中，消息的生产速度有时会大于消费速度，导致消息堆积，系统压力增大。为了解决这种问题，RabbitMQ 提供了 Work Queues（工作队列）模型，允许多个消费者共同消费同一个队列中的消息，进而提高消息处理效率。本文将通过模拟场景，介绍如何使用 Work Queues 模型，并展示如何优化消息分发和处理速度。

1. Work Queues模型简介

在 Work Queues 模型中，多个消费者绑定到同一个队列中进行消息消费，但每条消息只会被一个消费者处理，这样可以通过增加消费者来提高处理能力，从而减轻消息堆积的压力。

2. 场景模拟

我们将通过一个简单的场景来模拟 Work Queues 模型：假设一个生产者不停地向队列发送消息，而多个消费者同时消费这些消息。

2.1 消息发送

在 publisher 服务中，我们通过一个循环发送大量消息来模拟消息堆积。每20毫秒发送一条消息，相当于每秒发送50条。以下是在 SpringAmqpTest 类中添加的测试方法：

@Test
public void testWorkQueue() throws InterruptedException {
    // 队列名称
    String queueName = "work.queue";
    // 消息内容
    String message = "hello, message_";
    for (int i = 0; i < 50; i++) {
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);  // 模拟高频率的消息发送
    }
}

在该方法中，我们模拟了高频率的消息发送，并将消息发送到名为 work.queue 的队列中。

2.2 消息接收

为了模拟多个消费者同时消费一个队列中的消息，我们在 consumer 服务中编写了两个消息监听器，它们分别代表两个消费者：

@RabbitListener(queues = "work.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
    System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(20);  // 模拟快速消费
}

@RabbitListener(queues = "work.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
    System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(200);  // 模拟较慢的消费速度
}

消费者1：每条消息的处理时间为20毫秒，模拟较快的消息处理能力。
消费者2：每条消息的处理时间为200毫秒，模拟较慢的处理能力。

通过这些代码，我们模拟了不同处理能力的消费者在同一个队列中消费消息的场景。

3. 测试效果

当你运行生产者的 testWorkQueue 方法时，消费者会同时开始接收消息。输出结果类似如下：

消费者1接收到消息：【hello, message_0】21:06:00.869555300
消费者2........接收到消息：【hello, message_1】21:06:00.884518
...
消费者1接收到消息：【hello, message_48】21:06:01.920702500
消费者2........接收到消息：【hello, message_49】21:06:05.723106700

可以观察到：

消费者1处理消息的速度较快，处理了更多的消息。
消费者2由于处理较慢，导致消息处理的时间更长。

问题：当前的消息处理是平均分配的，没有考虑到消费者的处理能力，这可能会导致资源浪费。

4. 优化：能者多劳

为了解决消息平均分配的问题，我们可以通过设置 prefetch 参数来让处理能力强的消费者多处理一些消息，而处理较慢的消费者则少处理消息。prefetch 参数控制的是消费者每次从队列中取多少条消息。将 consumer 服务的 application.yml 文件修改如下：

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只取一条消息，处理完后再获取下一条

通过设置 prefetch=1，我们可以确保消费者在处理完当前消息之前不会接收新的消息，从而避免一个消费者处理过多消息而另一个闲置。

再次测试

通过上述配置，再次运行测试，观察输出结果：

消费者1接收到消息：【hello, message_0】21:12:51.659664200
消费者2........接收到消息：【hello, message_1】21:12:51.680610
...
消费者2........接收到消息：【hello, message_49】21:12:52.746299900

现在，消费者1由于处理能力较强，处理了更多的消息，而消费者2则处理了较少的消息。最终的结果显示，两者的消息处理负载更加均衡，总耗时也有所减少。