rabbitmq学习笔记4 ： 工作队列work queue

最新推荐文章于 2024-10-15 21:01:54 发布
最新推荐文章于 2024-10-15 21:01:54 发布
阅读量363 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenshourui/article/details/81347526
本文介绍RabbitMQ中的工作队列概念及其两种分配策略：轮询分发与公平分发。通过示例代码展示了如何实现这两种策略，并讨论了消息应答机制的重要性。

一、概述和模型

  1. 工作队列，多个消费者处理同一个消息队列，每条消息只会发给其中一个消费者。工作队列有两种处理方式，Round-robin（轮询分发）和Fair dispatch（公平分发）。应用场景，订单系统中多台服务器处理上游系统的下发过来的订单（个人认为原理跟负载均衡类似）。

          

 

二、轮询分发 Round-robin

  • 轮询分发，即将信息平分成N份，并推送给N个消费者。
  • 轮询分发实现跟简单队列类似，只是多了N个消费者
  • 创建MQ连接工具类
public class RabbitmqUntil {
    //获取连接
    public static Connection getRabbitmqConnection() throws Exception{
        //定义连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("127.0.0.1");
        //设置端口（这里的端口号指定是AMQP协议所用的端口号）
        factory.setPort(5672);
        //设置数据库
        factory.setVirtualHost("/test");
        //设置用户名
        factory.setUsername("test");
        //设置密码
        factory.setPassword("test");
        return factory.newConnection();
    }
}
  • 创建消息发送者
public class WorkSender {
    public static final String QUEUE_NAME="work query";
    //发送信息
    public void sendMessage() throws Exception{
        //1、获取连接
        Connection rabbitmqConnection = RabbitmqUntil.getRabbitmqConnection();
        //2、获取管道
        Channel channel = rabbitmqConnection.createChannel();
        /**
         * 3、队列创建(如果队列存在，则不进行创建)
         * 参数1：队列名
         * 参数2：是否支持持久化，默认队列在内存中，重启会丢失。设置为true,会保存到erlang自带的数据库中
         * 参数3：当连接关闭后是否自动删除队列；是否私有队列，如果私有，其他通道不能访问当前队列
         * 参数4：当没有消费者，是否自动删除队列
         * 参数5：其他参数(通过BasicProperties进行传输)
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //4、发布消息
        for (int i = 0; i < 50; i++) {
            String message="hello ,I am work queue"+i;
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        }
        //5、关闭连接
        channel.close();
        rabbitmqConnection.close();
    }

    public static void main(String[] args)throws Exception {
        WorkSender workSender = new WorkSender();
        workSender.sendMessage();
    }
}
  • 创建两个消费者
public class WorkReceiver1 {
    //队列名称
    public static final String QUEUE_NAME="work query";

    //接收信息
    public void receiveMessage()throws Exception{
        //1、获取连接
        Connection rabbitmqConnection = RabbitmqUntil.getRabbitmqConnection();
        //2、获取管道
        Channel channel = rabbitmqConnection.createChannel();
        //3、创建队列（如果队列已存在，则不进行处理）
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //4、创建消费用户
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收者1:"+new String(body,"utf-8"));
                //模拟业务处理，0.5秒
                try {
                    Thread.sleep(500);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        };
        /**
         * 监听rabbitmq队列信息（此时程序会自动堵塞，当有数据到达时，处理相应的数据）
         * 参数1：队列名
         * 参数2：是否自动问答
         * 参数3：消费用户
         */
        channel.basicConsume(QUEUE_NAME,true,consumer);
    }

    public static void main(String[] args)throws Exception {
        WorkReceiver1 workReceiver1 = new WorkReceiver1();
        workReceiver1.receiveMessage();
    }
}
public class WorkReceiver2 {
    //队列名称
    public static final String QUEUE_NAME="work query";

    //接收信息
    public void receiveMessage()throws Exception{
        //1、获取连接
        Connection rabbitmqConnection = RabbitmqUntil.getRabbitmqConnection();
        //2、获取管道
        Channel channel = rabbitmqConnection.createChannel();
        //3、创建队列（如果队列已存在，则不进行处理）
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //4、创建消费用户
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收者2:"+new String(body,"utf-8"));
                //模拟业务处理，1秒
                try {
                    Thread.sleep(1000);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        };
        /**
         * 监听rabbitmq队列信息（此时程序会自动堵塞，当有数据到达时，处理相应的数据）
         * 参数1：队列名
         * 参数2：是否自动问答
         * 参数3：消费用户
         */
        channel.basicConsume(QUEUE_NAME,true,consumer);
    }

    public static void main(String[] args)throws Exception {
        WorkReceiver2 workReceiver2 = new WorkReceiver2();
        workReceiver2.receiveMessage();
    }
}
  • 运行main函数，可以看到，即使两个消费者处理消息的时间不一样，但是每个消费者都得到相同的消息。这就是轮询分发

 

三、公平分发 Fair dispatch

  • 公平分发，在多个消费者中，谁将消息处理完了，就将消息推送给该消费者，这里涉及到消息应答，即消费处理完成后，发送一个响应告诉rabbitmq。
  • 创建消费者（每次只给消费者发送一条消息）
public class WorkFairSender {
    //队列名称
    public static final String QUEUE_NAME="work fair query";

    //发送信息
    public void sendMessage() throws Exception{
        //1、获取连接
        Connection rabbitmqConnection = RabbitmqUntil.getRabbitmqConnection();
        //2、获取管道
        Channel channel = rabbitmqConnection.createChannel();
        //3、创建队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //4、设置每次发送信息不超过1条
        channel.basicQos(1);

        //5、发布消息
        for (int i = 0; i < 50; i++) {
            String message="hello ,I am work queue"+i;
            System.out.println("发布信息："+message);
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        }
    }

    public static void main(String[] args)throws Exception {
        WorkFairSender workFairSender = new WorkFairSender();
        workFairSender.sendMessage();
    }
}
  • 创建两个消费者（使用消息应答机制）
public class WorkFairReceiver1 {
    //队列名称
    public static final String QUEUE_NAME="work fair query";

    //接收消息
    public void receiveMessage()throws Exception{
        //1、获取连接
        Connection rabbitmqConnection = RabbitmqUntil.getRabbitmqConnection();
        //2、获取管道
        final Channel channel = rabbitmqConnection.createChannel();
        //3、创建队列（如果队列已存在，则不进行处理）
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //4、设置每次处理息不超过1条
        channel.basicQos(1);
        //5、创建消费用户
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("公平分发接收者1:"+new String(body,"utf-8"));
                try {
                    Thread.sleep(500);
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    //处理完成后给rabbitmq一个应答响应
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        /**
         * 6、监听rabbitmq队列信息（此时程序会自动堵塞，当有数据到达时，处理相应的数据）
         * 参数1：队列名
         * 参数2：是否自动问答（设置为非自动问答）
         * 参数3：消费用户
         */
        channel.basicConsume(QUEUE_NAME,false,consumer);
    }

    public static void main(String[] args)throws Exception {
        WorkFairReceiver1 workFairReceiver1 = new WorkFairReceiver1();
        workFairReceiver1.receiveMessage();
    }
}
public class WorkFairReceiver2 {
    //队列名称
    public static final String QUEUE_NAME="work fair query";
    //接收消息
    public void receiveMessage()throws Exception{
        //1、获取连接
        Connection rabbitmqConnection = RabbitmqUntil.getRabbitmqConnection();
        //2、获取管道
        final Channel channel = rabbitmqConnection.createChannel();
        //3、创建队列（如果队列已存在，则不进行处理）
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //4、设置每次处理息不超过1条
        channel.basicQos(1);
        //5、创建消费用户
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("公平分发接收者2:"+new Date().getTime()+"  "+new String(body,"utf-8"));
                try {
                    Thread.sleep(10000);
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    //处理完成后给rabbitmq一个应答响应
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        /**
         * 6、监听rabbitmq队列信息（此时程序会自动堵塞，当有数据到达时，处理相应的数据）
         * 参数1：队列名
         * 参数2：是否自动问答（设置为非自动问答）
         * 参数3：消费用户
         */
        channel.basicConsume(QUEUE_NAME,false,consumer);
    }

    public static void main(String[] args)throws Exception {
        WorkFairReceiver2 workFairReceiver2 = new WorkFairReceiver2();
        workFairReceiver2.receiveMessage();
    }
}

      代码解析：

  1. 在发送者中添加channel.basicQos(1)，表示每次只推送给消费者一条消息
  2. 在消费者中添加channel.basicQos(1)，表示每次只处理一条消息
  3. 消费这处理完成后给rabbitmq一个应答响应channel.basicAck(envelope.getDeliveryTag(),false）
  4. 监听rabbitmq队列是，是否自动问答设置为false channel.basicConsume(QUEUE_NAME,false,consumer)
  • 运行程序，就会发现消费者1处理的消息比消费者多，这就是公平分发。

 

注：

  • 当程序设置为自动问答的时候，队列中消息被获取的时候，消息会自动被删除，如果这时消费者处理出现异常导致系统奔溃，此时数据丢失。非自动问答，需要在得到消费者的应答相应后才会删除队列中的消息，所以非自动问答，在一定程度上可以保证数据安全
  • 非自动应答在rabbitmq奔溃时，也会丢失数据，这个可用通过在定义队列的时候申明为支持持久化即可channel.queueDeclare(QUEUE_NAME,true,false,false,null)
  • 如果直接在上面的例子中修改，让程序支持持久化channel.queueDeclare(QUEUE_NAME,true,false,false,null)，程序会报错，因为已经存在的队列不能修改其属性，必须先删掉原本的队列再进行修改

 

 

Linux·工作队列
m0_64560763的博客
08-24 2756
Linux·工作队列
Rabbitmq学习笔记三：工作队列work queue
Running
01-20 8093
前面我们已经实现了rabbitMQ的helloWorld,这篇中我们将会创建一个工作队列用来在工作者（consumer）间分发耗时任务。 rabbitmq queue work,Round-robin dispatching, Message acknowledgment,Fair Dispatch,Message Durability
RabbitMQ入门：工作队列(Work Queue)
JAVA开发老菜鸟的专栏
06-20 310
RabbitMQ入门：工作队列(Work Queue) 在上一篇博客《RabbitMQ入门：Hello RabbitMQ 代码实例》中，我们通过指定的队列发送和接收消息，代码还算是比较简单的。 假设有这一些比较耗时的任务，按照上一次的那种方式，我们要一直等前面的耗时任务完成了之后才能接着处理后面耗时的任务，那要等多久才能处理完？别担心，我们今天的主角--工作队列就可以解决该问题。我们将围...
Linux内核工作队列(workqueue)详解
咸鱼弟的博客
12-21 1万+
Linux内核工作队列(workqueue)详解
RabbitMQ之work queue
lishuangzhi的博客
04-19 609
work queue 主要思想: 避免立即执行资源密集型任务，而不得不等待它完成。安排任务在之后执行，我们将任务封装为消息并放送到队列。而后台的工作进程从消息队列中读取消息并执行任务。当有多个工作线程时，这些线程将一起处理这些任务。 这个概念在 Web 应用程序中特别有用，在这些应用程序中，无法在短暂的 HTTP 请求窗口中处理复杂的任务。 work queue适合在集群环境中做异步处理，能最大程度发挥每一台服务器的性能 生产者代码, 简单的往队列发送20条消息 package main import
RabbitMQ——work queue
薛定谔的Hello Kitty
12-19 327
工作队列 包含一个生产者和多个消费者的MQ。生产者发送消息非常轻松，消费者和业务结合，需要花费时间。 稍后补充！！
RabbitMQ系列学习笔记（三）--工作队列模式
最新发布
Scr1Pt的博客
10-15 741
本文介绍了RabbitMQ的工作队列模式（Work Queue），为作者在学习RabbitMQ时的笔记，特此记录，以便后续学习中能够查漏补缺。
RabbitMQ学习笔记(一)RabbitMQ部署、5种队列模型
挑灯日记 记录自己
06-04 1181
在该案例中，支付服务是事件发布者（Publisher），在支付成功后只需要发布一个支付成功的事件（Event），事件中带上订单id。但不支持并发消费，不支持多个消费者共同消费一个队列，因为一旦消息被一个消费者接收，它就会从队列中删除。这种模型适用于根据消息内容将消息路由到不同队列的场景，例如按标签或关键字分发和处理不同的任务。这种模型支持多个消费者同时处理同一个队列中的消息，实现了并发消费，具有更高的消息吞吐量。，被平均分配给不同的消费者。同时，当一个消费者正在处理一个消息时，它不能接收新的消息。
RabbitMQ学习笔记四：消息Publish/Subscrible
Running
01-22 4241
rabbitmq 的发布订阅Publish/Subscribe，mq转发器exchange，队列与转发器绑定Binding,临时队列temprorary queues
RabbitMQ学习笔记二：rabbitmq发送接收消息Helloworld（Java版）
Running
01-19 5277
rabbitMq学习笔记，rabbitmq消息队列，rabbitmq发送接收消息，rabbitmq简单示例helloworld，rabbitmq发送订阅接收消息
RabbitMQ之Work Queue（工作队列）
热门推荐
小威的博客
01-10 2万+
本篇文章将记录和分享RabbitMQ工作队列相关的知识点，感兴趣的大佬可以看过来哟~
RabbitMQ--Work Queue(任务模型)
qq_38530648的博客
02-24 296
Work Queue(任务模型) Work quenes也被称为(Task queues)，任务模型。当消息处理比较耗时的时候，可能生产消息的速度远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。此时就可以使用work模型：让多个消费者绑定到同一个队列，共同消费队列中的消息。队列中的消息一旦消费，就会消失，因此任务是不会被重复执行的。 默认情况下消费者1和消费者2消费的消息是一致的，也就是平均分配消息 RabbitMQ连接工具类在RabbitMQ工作原理中已经介绍这里不在赘述了 Pro
RabbitMQ 之 Work Queues 工作队列
weixin_73616913的博客
11-11 1790
例如，假设在通道上有未确认的消息 5、6、7，8，并且通道的预取计数设置为 4，此时 RabbitMQ 将不会在该通道上再传递任何消息，除非至少有一个未应答的消息被 ack。比方说 tag=6 这个消息刚刚被确认 ACK，RabbitMQ 将会感知这个情况到并再发送一条消息。消息应答和 QoS 预取值对用户吞吐量有重大影响。通常，增加预取将提高向消费者传递消息的速度。
RabbitMQ Work queues 工作队列
KingCruel的专栏
11-22 989
RabbitMQ 官网 工作队列有两种工作模式，分别是【轮询模式】和【公平模式】； 轮训模式： 公平模式： 一个生产者，多个消费者 1、工作队列--轮询模式--生产者 using RabbitMQ.Client; using System; using System.Text; namespace WorkSendConsole { class Program { /// <summary> /// 工作队列--轮询模式--生产者
RabbitMQ - work queue 工作模式
04-09 240
前言 上一篇 RabbitMQ 入门 对 RabbitMQ 做了入门了解并介绍了他的一种工作模式-简单模式。本篇来学习一下 RabbitMQ 的第二种工作模式 - work queue。 worke queue介绍 先来看官网的一张图， 如图所示，我们可以看到，与上一篇介绍的简单模式不...
RabbitMQ之工作模型 Work queues
YellowSubject的博客
03-12 198
**前言：**如图先来看看RabbitMQ的几种模型 P：生产者：任务的发布者 C1：消费者-1，领取任务并且完成任务，假设完成速度较慢 C2：消费者-2：领取任务并完成任务，假设完成速度快 消费者1 public class Customer1 { public static void main(String[] args) throws IOException { //获取连接对象 Connection connection = RabbitMQUtils.
RabbitMQ之工作队列 ( Work Queues )
JAVA开发区的博客
05-09 1668
工作队列（又称任务队列）的主要思想是避免立即执行资源密集型任务，而不得不等待它完成。相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。
2. RabbitMQ之Work Queues
u010502101的博客
05-21 1049
文章目录1. Work Quesues概述2. Work Queues案例 1. Work Quesues概述 work queues是工作队列，又叫任务队列，是为了解决多个消费者有序执行密集型的资源任务。比如以下图为例，生产者产生大量消息发给了消息队列中，但是消息消费时比较耗时，这种情况下可以创建多个消费者同时进行消费，但一定要保证一个消息只能被一个消费者进行消费，假如一个消息被Consumer1消费了就不能再被Consumer2或者Consumer3再消费，所以queue队列中消息就像有序的被消费，qu
RabbitMQ中的工作队列（work queues）
m0_37884977的博客
05-17 1306
工作队列的设计思想：避免立即执行资源密集型任务。 我们将任务封装为消息并将其发送到队列，消费者从队列中取出任务并执行任务。当我们开启了多个消费者的时候，任务将在他们之间共享。 循环调度 使用工作队列的优点之一就是能够轻松地把平行任务，也就是说，在使用工作队列时，任务能够被平行地分发给各个消费者。 如果工作队列中的消息过多，我们可以很方便的添加更多的消费者，来缓解压力。 默认情...
RabbitMQ入门与实战：消息队列与异步应用解耦
RabbitMQ使用手册是一份全面介绍RabbitMQ这一开源消息队列系统的指南。RabbitMQ基于Erlang语言开发，实现了AMQP协议，为分布式系统提供了高效、可靠的异步通信解决方案。本文档首先从基础概念入手，详细解释了以下几...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值