2工作队列

于 2024-09-05 15:03:58 发布
阅读量726 收藏 14
点赞数 21
分类专栏： RabbitMQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wen_J_Q/article/details/141931480
版权

工作队列

逻辑图

image-20210810220747032

<!-- SpringBoot 消息队列的起步依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

轮询分发 Round-robin

生产者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeoutException;

public class WorkQueueProducer {
    /**
     * 生产者 → 消息队列
     * 创建连接工厂,并设置参数
     * 创建连接 Connection
     * 创建通道 Channel
     * 创建队列
     * 发送消息
     **/
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        if(true){
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
        }
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //创建队列
        /**
         * String queue                     队列名称
         * boolean durable                  是否持久化，
         * boolean exclusive                含义一:是否独占,是否只能有一个消费者监听
         *                                  含义二:connection 关闭是否删除队列
         * boolean autoDelete               是否自动删除,当没有消费者的时候是否自动删除
         * Map<String, Object> arguments    参数
         */
        channel.queueDeclare("WorkQueues",true,false,false,null);

        //发送消息
        /**
         * String exchange          : 交换机名称,简单模式不使用交换机
         * String routingKey        : 路由规则,当不使用交换机时,路由键需要和队列名称相同
         * BasicProperties props    : 配置参数
         * byte[] body              : 消息体,真实的数据
         */
        for (int i = 0; i < 20; i++) {
            String str = "WorkQueues is so easy!\t" + i + "\t" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());;
            System.out.println("发送消息:\t" + str);
            channel.basicPublish("","WorkQueues",null,str.getBytes());
        }

        //释放资源
        channel.close();
        connection.close();

        System.out.println("消息发送成功");
    }
}
  • 与简单队列几乎没有什么不同

消费者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class WorkQueueConsumerA {

    /**
     * 消息队列 ← 消费者
     * 创建连接工厂,并设置参数
     * 创建连接 Connection
     * 创建通道 Channel
     * 订阅队列
     * 接收消息
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂,并设置参数
        ConnectionFactory factory = new ConnectionFactory();
        if (true) {
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
        }
        //创建连接 Connection
        Connection connection = factory.newConnection();
        //创建通道 Channel
        Channel channel = connection.createChannel();


        /**
         * consumerTag  消费信息标签
         * delivery     回执
         */
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            byte[] body = delivery.getBody();
            System.out.println("消费消息:\t" + new String(body));
        };
        /**
         * basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback)
         * String queue                         :   队列名称
         * boolean autoAck                      :   是否自动确认,如果true,消费者接收到消息会自动发送一个回执给消息队列
         * DeliverCallback deliverCallback      :   回调函数
         * CancelCallback cancelCallback        :   消费者取消订阅时的回调函数
         */
        channel.basicConsume("WorkQueues", true, deliverCallback, consumerTag -> {
        });
    }
}
  • 再创建一个类 WorkQueueConsumerB，代码与 WorkQueueConsumerA 一样，只是类型不同

测试

  • 先启动生产者，查看 RabbitMQ 网页控制台

  • 先将2个消费者启动

    • 第一个消费者启动的时候，会将所有的都消费掉
    • 将两个都启动之后，再启动生产者

  • 再启动生产者

image-20210810224949350

image-20210810225050947image-20210810225104104

公平分发 Fair

如果机器 A 性能很好，一下子就处理完了，其他时间一直空闲，而机器 B 性能很差，很久都不能处理完一条，但是队列还是一人一条的轮询分发，这就造成 A 性能浪费，B 处理慢

我们采用公平分发

采用 basicQos(prefetchCount=1) ，来限制 MQ 只发不超过1条的消息给同一个消费者，当消费者处理完消息，给 MQ 反馈了，MQ 才会进行第二次发送

生产者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeoutException;

public class WorkQueueProducer {
    /**
     * 生产者 → 消息队列
     * 创建连接工厂,并设置参数
     * 创建连接 Connection
     * 创建通道 Channel
     * 创建队列
     * 发送消息
     **/
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        if(true){
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
        }
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //创建队列
        /**
         * String queue                     队列名称
         * boolean durable                  是否持久化，
         * boolean exclusive                含义一:是否独占,是否只能有一个消费者监听
         *                                  含义二:connection 关闭是否删除队列
         * boolean autoDelete               是否自动删除,当没有消费者的时候是否自动删除
         * Map<String, Object> arguments    参数
         */
        channel.queueDeclare("WorkQueues",true,false,false,null);

        //发送消息
        /**
         * String exchange          : 交换机名称,简单模式不使用交换机
         * String routingKey        : 路由规则,当不使用交换机时,路由键需要和队列名称相同
         * BasicProperties props    : 配置参数
         * byte[] body              : 消息体,真实的数据
         */
        for (int i = 0; i < 20; i++) {
            String str = "WorkQueues is so easy!\t" + i + "\t" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());;
            System.out.println("发送消息:\t" + str);
            channel.basicPublish("","WorkQueues",null,str.getBytes());
        }

        //释放资源
        channel.close();
        connection.close();

        System.out.println("消息发送成功");
    }
}

消费者

消费者A
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class WorkQueueConsumerA {

    /**
     * 消息队列 ← 消费者
     * 创建连接工厂,并设置参数
     * 创建连接 Connection
     * 创建通道 Channel
     * 订阅队列
     * 接收消息
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂,并设置参数
        ConnectionFactory factory = new ConnectionFactory();
        if (true) {
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
        }
        //创建连接 Connection
        Connection connection = factory.newConnection();
        //创建通道 Channel
        Channel channel = connection.createChannel();


        /**
         * prefetchCount 设为 1
         * MQ 发送小于等于 1 的数据给消费者
         * 当消费者消费完这几条数据,就会给 MQ 一个反馈,MQ 再次发送
         */
        channel.basicQos(1);


        /**
         * consumerTag  消费信息标签
         * delivery     回执
         */
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            byte[] body = delivery.getBody();
            System.out.println("消费消息:\t" + new String(body));

            try {
                /**
                 * 睡眠 1 秒,模拟等待
                 */
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /**
             * 手动回执
             * long deliveryTag
             * boolean multiple
             */
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        };
        /**
         * basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback)
         * String queue                         :   队列名称
         * boolean autoAck                      :   是否自动确认,如果true,消费者接收到消息会自动发送一个回执给消息队列
         * DeliverCallback deliverCallback      :   回调函数
         * CancelCallback cancelCallback        :   消费者取消订阅时的回调函数
         */
        channel.basicConsume("WorkQueues", false, deliverCallback, consumerTag -> {
        });
    }
}
消费者B
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class WorkQueueConsumerB {

    /**
     * 消息队列 ← 消费者
     * 创建连接工厂,并设置参数
     * 创建连接 Connection
     * 创建通道 Channel
     * 订阅队列
     * 接收消息
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂,并设置参数
        ConnectionFactory factory = new ConnectionFactory();
        if (true) {
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
        }
        //创建连接 Connection
        Connection connection = factory.newConnection();
        //创建通道 Channel
        Channel channel = connection.createChannel();

        /**
         * prefetchCount 设为 1
         * MQ 发送小于等于 1 的数据给消费者
         * 当消费者消费完这几条数据,就会给 MQ 一个反馈,MQ 再次发送
         */
        channel.basicQos(1);


        /**
         * consumerTag  消费信息标签
         * delivery     回执
         */
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            byte[] body = delivery.getBody();
            System.out.println("消费消息:\t" + new String(body));

            try {
                /**
                 * 睡眠 1 秒,模拟等待
                 */
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /**
             * 手动回执
             * long deliveryTag
             * boolean multiple
             */
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        };
        /**
         * basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback)
         * String queue                         :   队列名称
         * boolean autoAck                      :   是否自动确认,如果true,消费者接收到消息会自动发送一个回执给消息队列
         * DeliverCallback deliverCallback      :   回调函数
         * CancelCallback cancelCallback        :   消费者取消订阅时的回调函数
         */
        channel.basicConsume("WorkQueues", false, deliverCallback, consumerTag -> {
        });
    }
}

  • 与轮询的区别

    • channel.basicQos(1);

    • try {
    /**
    * 睡眠 1 秒,模拟等待
    */
    TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
    e.printStackTrace();
}

    • channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

    • 自动确认的 autoAck 改为 false
channel.basicConsume("WorkQueues", false, deliverCallback, consumerTag -> {});

测试

image-20210810232114774

image-20210810232129482image-20210810232142274

SpringBoot整合

小结

2 个消费者监听同一个队列，消息被平均分配到 2 个消费者，提高了处理效率，3个4个消费者效率更高

轮询分发：假设有100条消息，A消费者消费50条，B消费者消费50条，但是 A 机器是8核32G的，B机器是1核1G的，显然 B机器消费慢，A机器一直空闲

公平分发：性能好的机器多消费一点，性能差的少消费一点，负载均衡

架构小闻闻
关注
专栏目录
RabbitMQ消息队列的工作模式
江晓龙的博客
06-26 1万+
使用Routing路由模式时，Exchange与队列也不再进行绑定了，而是通过声明一个RoutingKey，通过这个key将消息路由到特定的队列中，因此在消息发送方发消息时，就需要指定消息的RoutingKey，Routing根据消息中的RoutingKey进行判断，当消息中的RoutingKey与队列中的RoutingKey完全一致时，消息才能正常存储到队列中，最后被消费者处理。简而言之，使用Topic模式后，可以对消息数据中的RoutingKey进行通配符匹配，将满足条件的消息数据分发到特定的队列中。
工作队列示例
03-01
2. **工作队列（BlockingQueue)** - 一个阻塞队列，用于存储待处理的任务。当队列满时，生产者会阻塞直到队列有空位；当队列空时，消费者会阻塞直到有新任务可用。 3. **拒绝策略** - 当线程池和工作队列都满载时，...
Linux内核工作队列(workqueue)详解
热门推荐
咸鱼弟的博客
12-21 1万+
Linux内核工作队列(workqueue)详解
RabbitMQ:工作队列模式
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
10-03 4095
任务队列）背后的主要思想是避免立即执行资源密集型任务并等待其完成。相反，我们将任务安排在以后完成。我们将_任务_封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当您运行多个工作线程时，任务将在它们之间共享。这个概念在 Web 应用程序中特别有用，因为在 Web 应用程序中，不可能在较短的 HTTP 请求窗口中处理复杂的任务。
RabbitMQ六种队列模式-工作队列模式
niceyoo的博客
09-02 1564
前言 RabbitMQ六种队列模式-简单队列 RabbitMQ六种队列模式-工作队列 [本文] RabbitMQ六种队列模式-发布订阅 RabbitMQ六种队列模式-路由模式 RabbitMQ六种队列模式-主题模式 上文我们了解了 RabbitMQ 六种队列模式中的简单队列，代码也是非常的简单，比较容易理解。 但是简单队列有个缺点，简单队列是一一对应的关系，即点对点，一个生产者对应一个消费者，...
workqueue 工作队列
生活需要深度
09-02 2249
Workqueue工作队列是利用内核线程来异步执行工作任务的通用机制；Workqueue工作队列可以用作中断处理的机制，利用进程上下文来执行中断处理中耗时的任务，因此它允许睡眠，而Softirq和Tasklet在处理任务时不能睡眠；在中断处理过程中，或者其他子系统中，调用workqueue的调度或入队接口后，通过建立好的链接关系图逐级找到合适的worker，最终完成工作任务的执行；
linux内核工作队列
z961968549的博客
12-09 5551
内核工作队列概述工作队列（workqueue）是另外一种将工作推后执行的形式，工作队列可以把工作推后，交由一个内核线程去执行，也就是说，这个下半部分可以在进程上下文中执行，最重要的就是工作队列允许被重新调度甚至睡眠。linux workqueue工作原理linux系统启动期间会创建名为kworker/u:x(x是0开始的整数，表示CPU编号)工作者内核线程，该线程创建之后处于sleep状态。从调度器
理解 linux 工作队列
sinat_30545941的博客
06-05 2458
对 linux 工作队列的理解
Linux工作队列实现机制
漫不经心
06-30 1935
本文转载自：http://blog.csdn.net/tommy_wxie/article/details/7204306 工作项、工作队列和工作者线程  把推后执行的任务叫做工作（work），描述它的数据结构为work_struct ，这些工作以队列结构组织成工作队列（workqueue），其数据结构为workqueue_struct ，而工作线程就是负责执行工作队列中的工作。系统默
Linux内核学习之工作队列
遇见你是我最美丽的意外
12-03 6745
Author : Toney Email : vip_13031075266@163.com Date : 2020.12.02 Copyright: 未经同意不得转载！！！ Version ： Linux-2.6.12 Reference：https://www.linux.org/ ...
Linux内核工作队列workqueue详解
weixin_44810385的博客
07-26 2989
linux 内核 workqueue详解
Java工作队列代码详解
08-28
Java工作队列是一种高效的任务调度和分配机制，它在分布式系统和并发编程中扮演着重要角色。本篇文章将深入探讨Java工作队列的实现，特别是使用RabbitMQ作为消息中间件的情况，涉及到的关键概念包括Round-robin转发...
rabbitMQ工作队列共12页.pdf.zip
10-30
在本篇文档中，我们将深入探讨RabbitMQ的工作队列（Work Queues）模式，该模式是其核心特性之一，常用于处理大量并发任务。 首先，让我们理解什么是工作队列。工作队列，又称为负载均衡队列，旨在将大量任务分发到...
Linux操作系统内核工作队列的操作模式
03-04
Linux操作系统内核中的工作队列（workqueue）是一种机制，用于在后台线程中异步处理非紧急任务，从而避免阻塞系统响应。工作队列是内核调度的一部分，它允许可延迟操作在适当的时间点由工作队列的处理线程执行。下面...
RabbitMQ 基础架构流程 数据隔离 创建用户
生产队的驴
09-02 553
publisher：消息发送者-exchange：交换机，复制路由的消息-queue：队列，存储消息consumer：消息的消费者工作流程publisher消息发送者 -> exchange 交换机 -> queue 队列 -> consumer 消息的消费者。
RabbitMQ 应用
不能再留遗憾了的博客
09-02 859
rabbitmq应用
【RabbitMQ之一：windows环境下安装RabbitMQ】
sinat_31986807的博客
09-02 508
链接：https://pan.baidu.com/s/1nNYLXid259e-iuCIU3B9UA。win+R键，输入cmd，再输入erl，看到erlang版本号就说明erlang安装成功了。双击系统变量path，点击“新建”，将%ERLANG_HOME%\bin加入到path中。官网下载地址：https://www.erlang.org/downloads。新建系统变量名为：ERLANG_HOME 变量值为erlang安装地址。双击otp_win64_20.2.exe，点击next。
RabbitMQ简介
最新发布
Wen_J_Q的博客
09-05 672
RabbitMQ简介。
模拟RabbitMQ实现消息队列【项目】
start_fall的博客
09-02 932
​RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。异步处理无需即时返回且耗时的操作，提高系统吞吐量。解耦生产者和消费者，提高系统灵活性。实现分布式系统的集成。RabbitMQ实际上是实现了一个基于AMQP的生产者消费者模型。解耦合。并发处理。支持忙闲不均。削谷填峰等。在实际的后端开发中，尤其是分布式系统里，跨主机之间使用生产者消费者模型，也是很普遍的需求。因此我们以AMQP为核心封装一个独立的服务器程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值