【RabbitMQ】工作队列的“轮询分发”和“公平分发”：到底哪个公平点？（1）

工作队列（Work Queue）

为什么会出现工作队列：
simple队列是一一对应的，而且我们实际开发中，生产者发送的消息不可能只有一个消费者消费。
生产者发送消息是毫不费力的，而消费者一般是要跟业务相结合的，消费者接收的消息之后就需要有不同的消费方式

轮询分发（round-robin）

生产者

package com.springrabbitmq.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.springrabbitmq.util.RabbitMQConnectionUtil;

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

/**
 * @Title:
 * @author: fly
 * @date: 2020-3-10
 */
public class Send {

    private static final String QUEUE_NAME="test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //先连接
        Connection connection = RabbitMQConnectionUtil.getConnection();
        //获取channel
        Channel channel=connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        for (int i=0;i<50;i++){
            String msg="hello word queue:"+i;
            System.out.println("[MQ]Send");
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            Thread.sleep(i*20);
        }
        channel.close();
        connection.close();
    }
}

消费者C1

package com.springrabbitmq.work;

import com.rabbitmq.client.*;
import com.springrabbitmq.util.RabbitMQConnectionUtil;

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

/**
 * @Title:
 * @author: fly
 * @date: 2020-3-10
 */
public class Recv1 {
    private static final String QUEUE_NAME_RECV="test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection= RabbitMQConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME_RECV,false,false,false,null);
        //定义一个消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //一旦有消息就会触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"UTF-8");
                System.out.println("[1]work queue:"+msg);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1] Done");
                }
            }
        };
        boolean autoAck=true;
        channel.basicConsume(QUEUE_NAME_RECV,autoAck,defaultConsumer);
    }
}

消费者C2

package com.springrabbitmq.work;

import com.rabbitmq.client.*;
import com.springrabbitmq.util.RabbitMQConnectionUtil;

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

/**
 * @Title:
 * @author: fly
 * @date: 2020-3-10
 */
public class Recv2 {
    private static final String QUEUE_NAME_RECV="test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection= RabbitMQConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME_RECV,false,false,false,null);
        //定义一个消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //一旦有消息就会触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"UTF-8");
                System.out.println("[2]work queue:"+msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[2] Done");
                }
            }
        };
        boolean autoAck=true;
        channel.basicConsume(QUEUE_NAME_RECV,autoAck,defaultConsumer);
    }
}

C1消费者执行结果

C2消费者执行结果

1. autoAck=true：队列一旦有消息，消费者将自动消费消息；
2. 现象：消费者1和消费者2消费的消息量是一样的，不管谁忙谁闲
   消费者1：偶数
   消费者2：奇数
3. 总结：这里容易给人一种误解，因为C1和C2输出的速度不一致，会以为两者消费消息的时间是当下，就会以为这种分发方式才是公平的哈哈，不管谁忙谁闲，都一人一个msg。
   类比：小时候分零食不管哥哥吃的快还是弟弟吃的慢，两个人的梨都是一样的个数。因为在分梨时是不管谁快谁忙，按来分梨的人头分！！所以这里的人头就等于autoAck=true自动来消费消息的都一人一个msg。吃梨的速度就是System.out的间隔时间
4. 承上 ：把System.out的间隔时间当作处理业务，而实际业务中，消费者处理业务复杂的需要时间比较久的一方就会出现消息堆积（也就是弟弟吃撑了还没吃完，哥哥只能看着弟弟吃）
5. 启下 ：又为了公平，这时就要“谁拿了这个数据处理完相应的业务再来消费”（谁吃完了梨才能得到下一个），所以就应该手动回执autoAck=false，也就是下面的公平分发

公平分发（fair dipatch）

工作队列（Work Queue）的“轮询分发”和“公平分发”：公平吗？（2）