RabbitMQ Work queues 工作队列

最新推荐文章于 2023-09-14 08:29:40 发布
最新推荐文章于 2023-09-14 08:29:40 发布
阅读量888 收藏
点赞数
分类专栏： 消息队列 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KingCruel/article/details/121468941
版权

RabbitMQ 官网

工作队列有两种工作模式，分别是【循环分发】和【公平分发】；
循环分发：RabbitMQ的消息分发默认按照消费端的数量，按顺序循环分发，也称为轮询。使用工作队列的好处就是它能够并行的处理队列。如果堆积了很多任务，只需要添加更多的工作者（workers）就可以了。
公平分发(Fair Dispatch)：消费者1从队列中获取一条消息之后，处理完消息之后手动发送反馈回执，告诉RabbitMQ我处理完了，接着就会再从队列中获取一条消息 ；在消费者1获取消息后处理业务之时，消费者2也会从队列中获取一条消息之后，处理完消息之后同样会手动发送反馈回执，告诉RabbitMQ我处理完了，接着也会再从队列中获取一条消息。两个消费者(消费者1&消费者2)不需要彼此等待对方处理完业务才能获取消息，这样一来业务处理时间短的消费者就能多处理消息，做到“能者多劳”，提高工作效率。
【注意1：保证消费者一次只接收一条消息channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false)】
【注意2：使用公平分发需要消费者手动反馈，所以必须关闭自动应答(ack 改为手动)】

一个生产者，多个消费者

1、工作队列--轮询模式--生产者

using RabbitMQ.Client;
using System;
using System.Text;

namespace WorkSendConsole
{
    class Program
    {
        /// <summary>
        /// 工作队列--轮询模式--生产者
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            ///队列名称
            string queueName = "work_rr";
            ///1. 创建连接工厂
            ConnectionFactory factory = new ConnectionFactory
            {
                HostName = "127.0.0.1",//rabbitmq ip
                Port = 5672,//端口号
                UserName = "guest",//用户名
                Password = "guest",//密码
                //VirtualHost="/tj"//虚拟主机
            };
            ///2. 创建连接对象
            using (IConnection connection = factory.CreateConnection())
            {
                ///3. 创建连接会话对象，信道
                using (IModel channel = connection.CreateModel())
                {
                    ///4. 声明一个队列，绑定队列
                    channel.QueueDeclare(
                        queue: queueName,//队列名称
                        durable: false,//持久化
                        exclusive: false,//排他队列
                        autoDelete: false,//队列自动删除
                        arguments: null);

                    for (int i = 0; i < 20; i++)
                    {
                        ///消息内容
                        string message = $"Hello World {i} !!!";
                        ///5. 发送消息
                        channel.BasicPublish(exchange: "", routingKey: queueName, basicProperties: null, body: Encoding.UTF8.GetBytes(message));
                        Console.WriteLine(" [x] Sent {0}", message);
                    }
                }
            }
            Console.WriteLine(" Press [enter] to exit.");
            Console.ReadLine();
        }
    }
}

2、工作队列--轮询模式--消费者1

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Text;

namespace WorkReceiveFirstConsole
{
    class Program
    {
        /// <summary>
        /// 工作队列--轮询--消费者
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            ///队列名称
            string queueName = "work_rr";
            ///1. 创建连接工厂
            ConnectionFactory factory = new ConnectionFactory
            {
                HostName = "127.0.0.1",
                Port = 5672,//端口号
                UserName = "guest",//用户名
                Password = "guest",//密码
                //VirtualHost = "/tj"
            };
            ///2. 创建连接对象
            using (var connection = factory.CreateConnection())
            {
                ///3. 创建连接会话对象
                using (var channel = connection.CreateModel())
                {
                    ///4. 声明一个队列，绑定队列
                    channel.QueueDeclare(
                        queue: queueName,//消息队列名称
                        durable: false,//持久化
                        exclusive: false,//排他队列
                        autoDelete: false,//自动删除
                        arguments: null);

                    ///事件基本消费者
                    EventingBasicConsumer consumer = new EventingBasicConsumer(channel);

                    ///接收到消息事件
                    consumer.Received += (model, ea) =>
                    {
                        ///打印消息
                        Console.WriteLine(" [x] Received {0}", Encoding.UTF8.GetString(ea.Body.ToArray()));
                    };
                    ///消费消息
                    channel.BasicConsume(
                        queueName, //队列名称
                        true, //自动确认
                        consumer);

                    Console.WriteLine(" Press [enter] to exit.");
                    Console.ReadLine();
                }
            }
        }
    }
}

3、工作队列--轮询模式--消费者2

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Text;

namespace WorkReceiveSecondConsole
{
    class Program
    {
        /// <summary>
        /// 工作队列--轮询--消费者
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            ///队列名称
            string queueName = "work_rr";
            ///1. 创建连接工厂
            ConnectionFactory factory = new ConnectionFactory
            {
                HostName = "127.0.0.1",
                Port = 5672,//端口号
                UserName = "guest",//用户名
                Password = "guest",//密码
                //VirtualHost = "/tj"
            };
            ///2. 创建连接对象
            using (var connection = factory.CreateConnection())
            {
                ///3. 创建连接会话对象
                using (var channel = connection.CreateModel())
                {
                    ///4. 声明一个队列，绑定队列
                    channel.QueueDeclare(
                        queue: queueName,//消息队列名称
                        durable: false,//持久化
                        exclusive: false,//排他队列
                        autoDelete: false,//自动删除
                        arguments: null);

                    ///事件基本消费者
                    EventingBasicConsumer consumer = new EventingBasicConsumer(channel);

                    ///接收到消息事件
                    consumer.Received += (model, ea) =>
                    {
                        ///打印消息
                        Console.WriteLine(" [x] Received {0}", Encoding.UTF8.GetString(ea.Body.ToArray()));
                    };
                    ///消费消息
                    channel.BasicConsume(
                        queueName, //队列名称
                        true, //自动确认
                        consumer);

                    Console.WriteLine(" Press [enter] to exit.");
                    Console.ReadLine();
                }
            }
        }
    }
}

4、工作队列--公平模式--生产者

using RabbitMQ.Client;
using System;
using System.Text;

namespace WorkFairSendConsole
{
    class Program
    {
        /// <summary>
        /// 工作队列--公平模式--生产者
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            ///队列名称
            string queueName = "work_fair";
            ///1. 创建连接工厂
            ConnectionFactory factory = new ConnectionFactory
            {
                HostName = "127.0.0.1",//rabbitmq ip
                Port = 5672,//端口号
                UserName = "guest",//用户名
                Password = "guest",//密码
                //VirtualHost="/tj"//虚拟主机
            };
            ///2. 创建连接对象
            using (IConnection connection = factory.CreateConnection())
            {
                ///3. 创建连接会话对象，信道
                using (IModel channel = connection.CreateModel())
                {
                    ///4. 声明一个队列，绑定队列
                    channel.QueueDeclare(
                        queue: queueName,//队列名称
                        durable: false,//持久化
                        exclusive: false,//排他队列
                        autoDelete: false,//队列自动删除
                        arguments: null);

                    for (int i = 0; i < 20; i++)
                    {
                        ///消息内容
                        string message = $"Hello World {i} !!!";
                        ///5. 发送消息
                        channel.BasicPublish(exchange: "", routingKey: queueName, basicProperties: null, body: Encoding.UTF8.GetBytes(message));
                        Console.WriteLine(" [x] Sent {0}", message);
                    }
                }
            }
            Console.WriteLine(" Press [enter] to exit.");
            Console.ReadLine();
        }
    }
}

5、工作队列--公平模式--消费者1

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Text;

namespace WorkFairReceiveFirstConsole
{
    class Program
    {
        /// <summary>
        /// 工作队列--公平模式--消费者
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            ///队列名称
            string queueName = "work_fair";
            ///1. 创建连接工厂
            ConnectionFactory factory = new ConnectionFactory
            {
                HostName = "127.0.0.1",
                Port = 5672,//端口号
                UserName = "guest",//用户名
                Password = "guest",//密码
                //VirtualHost = "/tj"
            };
            ///2. 创建连接对象
            using (var connection = factory.CreateConnection())
            {
                ///3. 创建连接会话对象
                using (var channel = connection.CreateModel())
                {
                    ///4. 声明一个队列，绑定队列
                    channel.QueueDeclare(
                        queue: queueName,//消息队列名称
                        durable: false,//持久化
                        exclusive: false,//排他队列
                        autoDelete: false,//自动删除
                        arguments: null);
                    
                    ///限制消费1条消息，消费完在继续下一条消息
                    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);

                    ///事件基本消费者
                    EventingBasicConsumer consumer = new EventingBasicConsumer(channel);

                    ///接收到消息事件
                    consumer.Received += (model, ea) =>
                    {
                        ///打印消息
                        Console.WriteLine(" [x] Received {0}", Encoding.UTF8.GetString(ea.Body.ToArray()));

                        /// 注意：手动确认
                        channel.BasicAck(
                            deliveryTag: ea.DeliveryTag, //回调的消息的唯一标识
                            multiple: false //是否确认多条
                        );
                    };
                    ///消费消息
                    channel.BasicConsume(
                        queueName, //队列名称
                        false, //注意：【自动确认】改为【手动确认】
                        consumer
                    );

                    Console.WriteLine(" Press [enter] to exit.");
                    Console.ReadLine();
                }
            }
        }
    }
}

6、工作队列--公平模式--消费者2

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Text;

namespace WorkFairReceiveSecondConsole
{
    class Program
    {
        /// <summary>
        /// 工作队列--公平模式--消费者
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            ///队列名称
            string queueName = "work_fair";
            ///1. 创建连接工厂
            ConnectionFactory factory = new ConnectionFactory
            {
                HostName = "127.0.0.1",
                Port = 5672,//端口号
                UserName = "guest",//用户名
                Password = "guest",//密码
                //VirtualHost = "/tj"
            };
            ///2. 创建连接对象
            using (var connection = factory.CreateConnection())
            {
                ///3. 创建连接会话对象
                using (var channel = connection.CreateModel())
                {
                    ///4. 声明一个队列，绑定队列
                    channel.QueueDeclare(
                        queue: queueName,//消息队列名称
                        durable: false,//持久化
                        exclusive: false,//排他队列
                        autoDelete: false,//自动删除
                        arguments: null);

                    ///限制消费1条消息，消费完在继续下一条消息
                    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);

                    ///事件基本消费者
                    EventingBasicConsumer consumer = new EventingBasicConsumer(channel);

                    ///接收到消息事件
                    consumer.Received += (model, ea) =>
                    {
                        ///打印消息
                        Console.WriteLine(" [x] Received {0}", Encoding.UTF8.GetString(ea.Body.ToArray()));

                        /// 注意：手动确认
                        channel.BasicAck(
                            deliveryTag: ea.DeliveryTag, //回调的消息的唯一标识
                            multiple: false //是否确认多条
                        );
                    };
                    ///消费消息
                    channel.BasicConsume(
                        queueName, //队列名称
                        false, //注意：【自动确认】改为【手动确认】
                        consumer
                    );

                    Console.WriteLine(" Press [enter] to exit.");
                    Console.ReadLine();
                }
            }
        }
    }
}

*
*

KingCruel
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ的工作模式及消息顺序性的保证
桐花思雨
08-27 1430
RabbitMQ工作模式 在 RabbitMQ 官网上提供了 6 中工作模式：简单模式、工作队列模式、发布/订阅模式、路由模式、主题模式和 RPC 模式 simple简单模式 1：只涉及生产者、队列、消费者: 2：生产者负责生产消息，将消息发送到队列中，消费者监听队列，队列有消息就进行消费，消费成功后，自动从队列中删除。有可能造成消息的丢失 work工作模式 1：只涉及生产者、队列、消费者 2：工作队列模式其实就是有多个消费者的简单模式。C1,C2共同争抢当前的消息队列内容,谁先拿到谁负责消费消
RabbitMQ 工作队列
chenjianhuideyueding的博客
06-12 308
工作队列 （使用java客户端） 在第一个教程中我们从命名的队列写了发送和接受信息的程序。在这个教程我们将创建在多个工作者中被用来分发时间消耗任务的工作队列。 工作队列（又名：任务队列）背后的主要的思想是避免立即做一些资源密集型的任务，并且必须等待它完成。相反，我们安排稍后完成。我们将任务封装成一个消息，并将它发送到队列中，一个工作者进程在后台运行将会弹出任...
解决rabbitmq消息队列的顺序及重复消费问题
热门推荐
varyall的专栏
01-20 8万+
五一期间去韩国游玩，顺便去了朋友公司扯淡去了。 所谓的扯淡，就是过去听技术分享，有python, golang, devops，docker一些话题。总的来说，技术方面跟国内还是有一些差距的。  正题开始，因为业务的各方面的强需求，我们使用了rabbitmq作为消息队列，利用rabbitmq的ack机制来确认消息的可靠性。 但是rabbitmq本身是没有绝对的消息顺序机制的，单个qu
2. RabbitMQ之Work Queues
u010502101的博客
05-21 891
文章目录1. Work Quesues概述2. Work Queues案例 1. Work Quesues概述 work queues是工作队列，又叫任务队列，是为了解决多个消费者有序执行密集型的资源任务。比如以下图为例，生产者产生大量消息发给了消息队列中，但是消息消费时比较耗时，这种情况下可以创建多个消费者同时进行消费，但一定要保证一个消息只能被一个消费者进行消费，假如一个消息被Consumer1消费了就不能再被Consumer2或者Consumer3再消费，所以queue队列中消息就像有序的被消费，qu
【RabbitMQ教程】Work queues 工作队列模式
qq_43783527的博客
10-09 1009
将‘work queues工作队列模式’单独抽出来细讲，目的是借助这个模式好好讲一下rabbitmq的‘轮询分发’和‘公平分配’。
RabbitMQ-工作队列模式
海的那边，还是海吗
09-14 217
在分布式应用程序中，任务分发是一个常见的挑战。RabbitMQ是一个强大的消息队列系统，可以用于实现各种消息传递模式，包括工作队列模式。本博客将介绍RabbitMQ工作队列模式的基本概念，以及如何使用Java编写示例代码来实现高效的任务分发。工作队列模式，也称为任务队列模式，是一种消息传递模式，用于在分布式系统中实现任务分发。在这种模式下，一个生产者（producer）将任务发布到队列中，多个消费者（consumer）从队列中获取任务并执行。
RabbitMQ之工作队列
baidu_30851231的博客
06-17 223
工作队列（又称任务队列），其主要思想时避免立即执行资源密集型任务，而不得不等待它完成，在RabbitMQ中将任务封装为消息并将其发送到队列，在后台运行的工作进程将弹出任务并最终执行作业，当有多个工作者时，任务将在他们之间共享。 这个概念在Web应用程序中特别有用，因为在Web应用程序中，不可能在较短的HTTP请求窗口内处理复杂的任务 我们代码实现下向同一个队列中发送多个消息，消息是否依次发给下一个使用者。 消息发送方主要实现代码(JAVA)： ConnectionFactory factory = ne
rabbitMQ简单应用pattern1 Work queues 工作队列模式
07-10
在本文中，我们将深入探讨RabbitMQ中的"Work Queues"（工作队列模式），这是一种优化任务处理效率的重要策略。 工作队列模式，也称为负荷分发或批处理队列，其核心思想是通过将大量任务分解为小型可处理单元，然后...
rabbitMQ工作队列共12页.pdf.zip
10-30
在本篇文档中，我们将深入探讨RabbitMQ的工作队列（Work Queues）模式，该模式是其核心特性之一，常用于处理大量并发任务。 首先，让我们理解什么是工作队列。工作队列，又称为负载均衡队列，旨在将大量任务分发到...
rabbitmq 7种队列实现java版
01-20
文章目录rabbitmq7种实现方式搭建maven项目引入依赖创建连接简单队列消息生产者消息消费者work queues 工作队列生产者消费者能者多劳（公平分发）：消费能力强则消费更多消息Publish/Subscribe 发布订阅模式生产者...
RabbitMQ Work Queue实例
05-05
基于RabbitMQ的工作队列实现，包括消息确认机制、消息持久化机制、消息的公平调度等。
rabbitMQ 消息队列 Demo
10-18
2. **02WorkQueues（任务队列）** 在这个示例中，多个消费者可以并发地从队列中获取任务进行处理，实现负载均衡。例如，处理一个耗时的任务时，如果有多台服务器（消费者），RabbitMQ会将任务分发给空闲的服务器，...
RabbitMQ高级消息队列协议.rar
最新发布
05-21
3. **工作队列（Work Queues）**：用于分配工作负载，多个工作者可以并行处理队列中的任务，提高了系统的处理能力。 4. **延迟队列（Delayed Queue）**：允许消息在指定的时间后才被消费，适用于定时任务。 5. **...
【RabbitMQ】- 工作队列（Work Queues）
ls199848的博客
06-16 175
工作队列(又称任务队列)的主要思想是避免立即执行资源密集型任务，而不得不等待它完成。 相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进 程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。
RabbitMQ之工作队列 ( Work Queues )
JAVA开发区的博客
05-09 1465
工作队列（又称任务队列）的主要思想是避免立即执行资源密集型任务，而不得不等待它完成。相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。
RabbitMQ——Hello World
前尘忆梦的博客
04-25 385
文章目录1、RabbitMQ四个核心概念1.1、四大核心概念1.2、各个名词介绍1.3、安装2、Hello World2.1、依赖2.2、消息生产者 1、RabbitMQ四个核心概念 RabbitMQ 是一个消息中间件：它接受并转发消息。你可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑 RabbitMQ 是一个快递站，一个快递员帮你传递快件。 RabbitMQ 与快递站的主要区别在于，它不处理快件而是接收，存储和转发消息数据。 1.
rabbitmq工作队列
白鸽
07-15 476
8、work queue（工作队列） 工作队列(又称任务队列)的主要思想是避免立即执行资源密集型任务，而不得不等待它完成。相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。 工作队列（work queue）是采用多个工作的线程，接收处理从队列中出来的大量消息，避免一个工作线程（一个消费者）接收处理大量的消息，因为单一处理速度肯定慢 1、队列的轮询分发消息机制（相对公平的消费模式） 1、启动两个
RabbitMQ 6种队列模式——Work queues工作队列
祝我飞黄腾达
03-22 893
上一篇博文，详细模拟了简单队列模式， 简单队列有个缺点，简单队列是一一对应的关系，即点对点，一个生产者对应一个消费者，按照这个逻辑，如果我们有一些比较耗时的任务，也就意味着需要大量的时间才能处理完毕，显然简单队列模式并不能满足我们的工作需求。 工作队列模式概念 一个消息生产者，一个交换器，一个消息队列，多个消费者。同样也称为点对点模式 当消息生产速度远大于消费速度时，消息队列就会爆满，从而导致服务器不可用，那么我们就要设置多个消费者，共同进行消费。 但是不同的消费者处理消息的快慢也不.
MSMQ消息队列安装
KingCruel的专栏
11-29 1万+
一、Windows 7安装、管理消息队列 1、安装消息队列    执行用户必须要有本地 Administrators 组中的成员身份，或等效身份。    具体步骤：     开始—》控制面板—》程序—》程序和功能—》打开或关闭Windows功能—》依次展开Microsoft Message Queue (MSMQ) 服务器、Microsoft Message Queue (MSMQ) 服务
RabbitMQ基础教程-中文版
- **工作队列(Work Queues)**：用于分配任务到多个工作者，确保任务被均匀处理，避免单一消费者过载。 - **发布/订阅(Publish/Subscribe)**：允许广播消息模式，其中多个消费者可以订阅同一个主题，每条消息都会被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值