RabbitMQ入門到進階之工作隊列Work queues(Round-robin)

大綱

此套免費課程視頻,本人錄播到了騰訊課堂
https://ke.qq.com/course/288116#tuin=5740604a
1.消息中間件概述,使用場景(日誌處理,異步,系統解耦,流量削鋒)
2.Rabbitmq3.7.2安裝,控制檯簡介,管理員添加
3.用戶vhost配置以及介紹
4.java操作簡單隊列,生產者發送消息到隊列,消費者接收消息
5.簡單隊列的缺陷,工作隊列work queues之 輪詢分發(Round-robin),以及輪詢分發現象
6.工作隊列work queues 公平分發(fair dispatch);prefetchCount = 1來限制RabbitMQ發送的消息,手動應答ack。
7.消息應答ack與消息持久化durable
8.publish/subscribe發佈訂閱模式 交換機(轉發器)匿名轉發Nameless exchange, Fanout Exchange不處理路由鍵 , Direct Exchange處理路由鍵, Topic Exchange將路由鍵和某模式進行匹配。隊列綁定交換機(Exchange) ;
9.routing路由模式
10.topic主題模式
11.Rabbitmq之消息確認機制(AMQP事務機制)txSelect(), txCommit()以及txRollback(),事務機制的缺陷
12.Rabbitmq之消息確認機制(Confirm機制串行) waitForConfirms
13.Rabbitmq之消息確認機制(Confirm機制異步) ConfirmListener deliveryTag unconfirm集合維護
14.spring集成rabbitmq-client,template 的使用
15.大數據日誌收集系統消息中間件應用
16.搜索系統DIH消息中間件應用

前言

那麼之前介紹了簡單隊列simple 模型,我們應用程序在是使用消息系統的時候,一般生產者P生產消息是毫不費力的(發送消息即可),而消費者接收完消息後的需要處理,會耗費一定的時間,這時候,就有可能導致很多消息堆積在隊列裏面,一個消費者有可能不夠用

那麼怎麼讓消費者同事處理多個消息呢?
在同一個隊列上創建多個消費者,讓他們相互競爭,這樣消費者就可以同時處理多條消息了
接下來就要介紹工作隊列

工作隊列

模型圖

使用任務隊列的優點之一就是可以輕易的並行工作。如果我們積壓了好多消息，我們可以通過增加消費者來解決這一問題，使得系統的伸縮性更加容易。

輪詢分發

生產者發送消息

public class Send {

    private final static String QUEUE_NAME  = "test_queue_work";

    public static void main(String[] argv) throws Exception {
        // 獲取到連接以及mq通道
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();

        // 聲明隊列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        for (int i = 0; i < 50; i++) {
            // 消息內容
            String message = "." + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");

            Thread.sleep(i * 10);
        }

        channel.close();
        connection.close();
    }
}

消費者1

package com.mmr.rabbitmq.work;

@SuppressWarnings("deprecation")
public class Recv1 {

    private final static String QUEUE_NAME  = "test_queue_wor1k";

    public static void main(String[] args) throws Exception {
        // 獲取到連接以及mq通道
        Connection connection = ConnectionUtils.getConnection();
        final Channel channel = connection.createChannel();

         // 聲明隊列，主要爲了防止消息接收者先運行此程序，隊列還不存在時創建隊列。
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //定義一個消息的消費者
        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [1] Received '" + message + "'");
                try {
                    doWork(message);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(" [x] Done");
                }
            }

        };
        boolean autoAck = true; //消息的確認模式自動應答
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }

    private static void doWork(String task) throws InterruptedException {
        Thread.sleep(1000);
    }

    @SuppressWarnings("unused")
    public static void oldAPi() throws Exception, TimeoutException {
        // 獲取到連接以及mq通道
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();

        // 聲明隊列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 定義隊列的消費者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 監聽隊列，手動返回完成狀態false  自動true 自動應答 不需要手動確認
        channel.basicConsume(QUEUE_NAME, true, consumer);
        // 獲取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
        }
    }

}

消費者2

public class Recv2 {

    private final static String QUEUE_NAME  = "test_queue_work";

    public static void main(String[] args) throws Exception {
        // 獲取到連接以及mq通道
        Connection connection = ConnectionUtils.getConnection();
        final Channel channel = connection.createChannel();

        // 聲明隊列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //定義一個消息的消費者
        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [2] Received '" + message + "'");
                try {
                        Thread.sleep(2000);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(" [x] Done");
                }
            }

        };
        boolean autoAck = true; //
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }
}

測試現象

消費者1 我們處理時間是1s ;而消費者2中處理時間是2s;
但是我們看到的現象並不是 1處理的多 消費者2處理的少,
[1] Received ‘.0’
[x] Done
[1] Received ‘.2’
[x] Done
[1] Received ‘.4’
[x] Done
[1] Received ‘.6’
……….

消費者1中將偶數部分處理掉了

[2] Received ‘.1’
[x] Done
[2] Received ‘.3’
[x] Done
[2] Received ‘.5’
[x] Done
…… .. . . .
消費者2中將基數部分處理掉了

我想要的是1處理的多,而2處理的少

測試結果:
1.消費者1和消費者2獲取到的消息內容是不同的,同一個消息只能被一個消費者獲取
2.消費者1和消費者2貨到的消息數量是一樣的 一個奇數一個偶數
按道理消費者1 獲取的比消費者2要多
這種方式叫做輪詢分發 結果就是不管誰忙或清閒，都不會給誰多一個任務或少一個任務，任務總是你一個我一個的分