RabbitMQ——work queue

工作队列

包含一个生产者和多个消费者的MQ。生产者发送消息非常轻松，消费者和业务结合，需要花费时间。
下面介绍一种轮询方式的工作队列：

首先定义生产者：

public class Send {

    private static final String QUEUE_NAME = "work_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = RabbitConnection.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        for(int i = 0; i<50; i++){
            String message = "work+"+i;

            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            Thread.sleep(i*20);
        }
    }
}

生产50条消息，给下面的两个消费者进行食用：

消费者One（这里我们消费一条消息就sleep 1s）

public class ReceiveOne {
    private static final String QUEUE_NAME = "work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitConnection.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [ConsumerOne is] Received '" + message + "'");
            try {
                Thread.sleep(1000);   
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }
}

消费者Two （sleep 2s）

public class ReceiveTwo {

    private static final String QUEUE_NAME = "work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitConnection.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [ConsumerTwo is] Received '" + message + "'");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }
}

下面我们看两个控制台的输出：

ReceiveOne

ReceiveTwo

事实证明，设置两个不同的sleep时间，并没有影响两个消费者轮流消费，这种方式称之为轮询。

这样看起来不太合理，消费快的消费者理应多消费一些，所谓“能者多劳”，为了解决这个问题，下面我们引入了公平分发：

公平分发，它是由消费者主动发送ACK应答，告诉生产者：“我已经消费完了，快点给我下一个”，之前的都是，自动发送ACK，并非手动的。下面我们实现一下手动的。

只需要在前面的代码修改部分即可：

发送者：

public class Send {

    private static final String QUEUE_NAME = "work_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = RabbitConnection.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 消费者发送确认消息（ACK）之前，只发送一个消息给你
        channel.basicQos(1);

        for(int i = 0; i<50; i++){
            String message = "work+"+i;

            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            Thread.sleep(i*20);
        }
    }
}

消费者1：

public class ReceiveOne {
    private static final String QUEUE_NAME = "work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitConnection.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        channel.basicQos(1);  //需要修改

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [ConsumerOne is] Received '" + message + "'");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);  //这里是手动应答
            }
        };
        boolean autoAck = false;  //这里需要修改至手动应答 
        channel.basicConsume(QUEUE_NAME, autoAck, deliverCallback, consumerTag -> { });
    }
}

同理2也是一样的，这里就不再重复了。


很明显，消费者1的处理速度比消费者2要快，因为消费者1的sleep时间较短，这就和上面的轮询立判高下了，体现了能者多劳。

---

下面我们有一个问题，我们设置 boolean autoAck = false;这个是有隐患的，假设我们我的消费者1挂了，而消息已经发送过去了，这时候，我们该怎么办？这时候这个消息是丢失的。为了应对这种情况，我们可以设置autoack = true，能解决问题。但是我们又想公平分发，这就有点麻烦了，怎么解决这个问题，暂时没有想法，容我继续学习。

还有一个问题，如果RabbitMQ挂了，这时候怎么办？这里我们就要设置另外一个参数了，那就是durable，表示可持久化。

在声明队列的时候，就要设置好，等队列已经存在了再设置的话，就会报错。这点注意，如果已经报错了，就删除队列重新声明。

 boolean durable = false; //声明数据可以持久化
 channel.queueDeclare(QUEUE_NAME, durable, false, false, null);