RabbitMQ——work queue

工作队列

RabbitMQ——work queue_第1张图片
包含一个生产者和多个消费者的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
RabbitMQ——work queue_第2张图片
ReceiveTwo
RabbitMQ——work queue_第3张图片

事实证明,设置两个不同的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也是一样的,这里就不再重复了。
RabbitMQ——work queue_第4张图片
RabbitMQ——work queue_第5张图片
很明显,消费者1的处理速度比消费者2要快,因为消费者1的sleep时间较短,这就和上面的轮询立判高下了,体现了能者多劳。


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

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

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

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

你可能感兴趣的:(Java开发日记,java,rabbitmq,队列)