RabbitMQ基础入门（三）work消息模型

work消息模型称为 工作队列或者 竞争消费者模式。

在上一篇文章中，我们讲了简单消息模型，从一个队列中发送并接收消息。在这里，我们将创建一个工作队列，在多个工作者之间分配耗时任务。

工作队列，又称为任务队列。主要是想就是避免执行资源密集型任务时，必须等待它执行完成。相反，我们将稍后完成任务，将它封装为消息，并将其发送发到队列。在后台运行的工作进程将获取任务并最终执行作业。当运行许多消费者时，任务将在他们之间共享，但是一个消息只能被一个消费者获取。

为了避免消息堆积，我们可以：
①采用work queue，多个消费者监听同一个队列。
②接收到消息后，通过线程池，异步消费消息。

一、生产者代码

我们将循环发送100条消息。

package com.linqibin.rabbitmq.work;

import com.linqibin.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {
    public final static String QUEUE_NAME = "work_queue";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtils.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 循环发布任务
        for (int i = 0; i < 100; i++) {
            // 消息内容
            String message = "task .. " + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
        }
        // 关闭通道和连接
        channel.close();
        connection.close();
    }
}

二、消费者代码

本次我们将定义两个消费者，进行消费队列。

1. 轮询

消费者1将在每次收到消息后都睡眠1s，模拟消费耗时。我们将自动ack取消掉，改为手动确认。

package com.linqibin.rabbitmq.work;

import com.linqibin.rabbitmq.helloworld.Send;
import com.linqibin.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Receive {

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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        channel.queueDeclare(com.linqibin.rabbitmq.helloworld.Send.QUEUE_NAME, false, false, false, null);
        // 定义消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息,并且处理,这个方法类似监听事件, 如果有消息的时候, 会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [x] received : " + msg + "!");
                // 模拟消费耗时
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 手动确认
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };

        // 监听队列
        channel.basicConsume(Send.QUEUE_NAME, false, consumer);
    }
}

消费者2将直接读取消息。

package com.linqibin.rabbitmq.work;

import com.linqibin.rabbitmq.helloworld.Send;
import com.linqibin.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Receive2 {

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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        channel.queueDeclare(com.linqibin.rabbitmq.helloworld.Send.QUEUE_NAME, false, false, false, null);
        // 定义消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息,并且处理,这个方法类似监听事件, 如果有消息的时候, 会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [x] received : " + msg + "!");
                // 手动确认
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };

        // 监听队列
        channel.basicConsume(Send.QUEUE_NAME, false, consumer);
    }
}

接下来我们先启动两个消费者。

消费者1运行结果如下：

消费者2运行结果如下：

可以观察出，即使消费者1每次都睡眠了1s，和消费者2比起来，每次还是处理了同样多的消息。这显然是不合理的。

2. 公平（能者多劳）

我们可以从刚才轮询的方式中观察出不少问题，例如：

• 消费者1比消费者2的效率要低，一次任务的耗时较长
• 然而两人最终消费的消息数量是一样的
• 消费者2大量时间处于空闲状态，消费者1一直忙碌

现在的状态属于是把任务平均分配，正确的做法应该是消费越快的人，消费的越多。

我们可以使用basicQos方法和prefetchCount = 1设置。 这告诉RabbitMQ一次不要向工作人员发送多于一条消息。 或者换句话说，不要向工作人员发送新消息，直到它处理并确认了前一个消息。 相反，它会将其分派给不是仍然忙碌的下一个工作人员。

在1中的两个消费者分别添加上如下代码。

重新运行消费者。

消费者1只消费了一条消息。

剩余的消息全被消费者2消费了。

这就是能者多劳模式。