WorkQueues

最新推荐文章于 2024-04-26 15:31:27 发布
最新推荐文章于 2024-04-26 15:31:27 发布
阅读量66 收藏
点赞数
分类专栏： RabbitMQ 文章标签： 队列 rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46392290/article/details/115443349
版权

队列轮询

解决生产者生产过多的问题，添加多个消费者
生产者 我们的生产模拟的是生产20

package org.example.work.send;

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

import java.nio.charset.StandardCharsets;

//简单队列
public class Send {
    //队列的名称
    private final static String QUEUE_NAME = "work_rr";

public static void main(String[] argv) throws Exception {
    //创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //设置连接工厂的属性
    factory.setHost("192.168.26.146");
    factory.setUsername("aw");
    factory.setPassword("aw");
    factory.setPort(5672);
    factory.setVirtualHost("/yeb");
            //使用这种方式可以进行自动关闭           连接工厂创建连接；          创建通信通道
    try (  Connection connection = factory.newConnection(); Channel channel = connection.createChannel()) {
        /**
         * 声明队列 五个参数的意义
         * 1.队列名称
         * 2.是否持久化
         * 3.排他队列：如果一个队列被声明为排他队列，改队列仅对首次声明他的连接可见，并在连接断开时自动删除
         *      注意：排他队列是基于连接可见的，同一个连接的不同通道是可以同时访问同一个连接创建的排他队列。
         *          首次，如果一个连接声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
         *          即使改队列持久化的，一但连接关闭或客户端退出，改排他队列会被自动删除的。
         * 4.是否自动删除，如果队列没有任何订阅的消费者信息的化，改队列会被自动删除，这种队列被称为临时队列
         * 5.传递参数 可变参数
         */


        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        for (int i = 0; i < 20; i++) {
            //消息
            String message = "Hello World!"+i;
            //发送消息 参数 交换机、队列名字、参数、消息的实体
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println(" [x] Sent '" + message + "'"+i);
        }
    }
}
}

现在我们添加两个消费者，这里我们主要是添加了手动的确认消息回复

package org.example.work.recv;

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

public class Recv01 {
    //定义队列
    private final static String QUEUE_NAME = "work_rr";

    public static void main(String[] argv) throws Exception {
        //声明连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置连接工厂的属性
        factory.setHost("192.168.26.146");
        factory.setUsername("aw");
        factory.setPassword("aw");
        factory.setPort(5672);
        factory.setVirtualHost("/yeb");
        //连接工厂 创建连接
        Connection connection = factory.newConnection();
        //连接通信通道
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            try {
                //添加睡眠
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            //我们需要在这里手动添加确认设置
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

        };
        //监听连接  第二参数改为false意思是我们手动确认设置 这里的确认设置是主要是消费者告诉生产者我们接受到这条消息了
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
    }
}


package org.example.work.recv;

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

public class Recv02 {
    //定义队列
    private final static String QUEUE_NAME = "work_rr";

    public static void main(String[] argv) throws Exception {
        //声明连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置连接工厂的属性
        factory.setHost("192.168.26.146");
        factory.setUsername("aw");
        factory.setPassword("aw");
        factory.setPort(5672);
        factory.setVirtualHost("/yeb");
        //连接工厂 创建连接
        Connection connection = factory.newConnection();
        //连接通信通道
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        };
        //监听连接
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
    }
}

先开启两个消费者

在这里插入图片描述
在这里插入图片描述
开启生产者
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

队列公正

他的目的解决上面队列轮询的问题，
他会让让消费能将的人进行多消费，这样会减少资源的浪费。
生产者 生产者基本上不变 只改变了一下对列的名称

package org.example.work.fair.send;

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

import java.nio.charset.StandardCharsets;

//简单队列
public class Send {
    //队列的名称
    private final static String QUEUE_NAME = "work_fair";

public static void main(String[] argv) throws Exception {
    //创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //设置连接工厂的属性
    factory.setHost("192.168.26.146");
    factory.setUsername("aw");
    factory.setPassword("aw");
    factory.setPort(5672);
    factory.setVirtualHost("/yeb");
            //使用这种方式可以进行自动关闭           连接工厂创建连接；          创建通信通道
    try (  Connection connection = factory.newConnection(); Channel channel = connection.createChannel()) {
        /**
         * 声明队列 五个参数的意义
         * 1.队列名称
         * 2.是否持久化
         * 3.排他队列：如果一个队列被声明为排他队列，改队列仅对首次声明他的连接可见，并在连接断开时自动删除
         *      注意：排他队列是基于连接可见的，同一个连接的不同通道是可以同时访问同一个连接创建的排他队列。
         *          首次，如果一个连接声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同。
         *          即使改队列持久化的，一但连接关闭或客户端退出，改排他队列会被自动删除的。
         * 4.是否自动删除，如果队列没有任何订阅的消费者信息的化，改队列会被自动删除，这种队列被称为临时队列
         * 5.传递参数 可变参数
         */


        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        for (int i = 0; i < 20; i++) {
            //消息
            String message = "Hello World!"+i;
            //发送消息 参数 交换机、队列名字、参数、消息的实体
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println(" [x] Sent '" + message + "'"+i);
        }
    }
}
}

消费者1 添加了接收消息的设置

    //添加设置 一次只能接受一条消息 才能接受下一跳消息
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);

package org.example.work.fair.recv;

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

public class Recv01 {
    //定义队列
    private final static String QUEUE_NAME = "work_fair";

    public static void main(String[] argv) throws Exception {
        //声明连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置连接工厂的属性
        factory.setHost("192.168.26.146");
        factory.setUsername("aw");
        factory.setPassword("aw");
        factory.setPort(5672);
        factory.setVirtualHost("/yeb");
        //连接工厂 创建连接
        Connection connection = factory.newConnection();
        //连接通信通道
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        //添加设置 一次只能接受一条消息 才能接受下一跳消息
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            try {
                //添加睡眠
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            //我们需要在这里手动添加确认设置
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

        };
        //监听连接  第二参数改为false意思是我们手动确认设置 这里的确认设置是主要是消费者告诉生产者我们接受到这条消息了
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
    }
}

在这里插入图片描述

消费者2 同样添加了接受消息 又把线程时间增长了

package org.example.work.fair.recv;

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

public class Recv02 {
    //定义队列
    private final static String QUEUE_NAME = "work_fair";

    public static void main(String[] argv) throws Exception {
        //声明连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置连接工厂的属性
        factory.setHost("192.168.26.146");
        factory.setUsername("aw");
        factory.setPassword("aw");
        factory.setPort(5672);
        factory.setVirtualHost("/yeb");
        //连接工厂 创建连接
        Connection connection = factory.newConnection();
        //连接通信通道
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        int prefetchCount = 1;
        channel.basicQos(prefetchCount);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        };
        //监听连接
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
    }
}

在这里插入图片描述

13号新秀-阿威
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitMQ简单应用pattern1 Work queues 工作队列模式
07-10
Work Queues与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列 中的消息。 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
RabbitMQ的work queues模式
weixin_42947972的博客
03-14 204
RabbitMQ的work queues模式
2. RabbitMQ之Work Queues
u010502101的博客
05-21 853
文章目录1. Work Quesues概述2. Work Queues案例 1. Work Quesues概述 work queues是工作队列，又叫任务队列，是为了解决多个消费者有序执行密集型的资源任务。比如以下图为例，生产者产生大量消息发给了消息队列中，但是消息消费时比较耗时，这种情况下可以创建多个消费者同时进行消费，但一定要保证一个消息只能被一个消费者进行消费，假如一个消息被Consumer1消费了就不能再被Consumer2或者Consumer3再消费，所以queue队列中消息就像有序的被消费，qu
【RabbitMQ教程】Work queues 工作队列模式
qq_43783527的博客
10-09 940
将‘work queues工作队列模式’单独抽出来细讲，目的是借助这个模式好好讲一下rabbitmq的‘轮询分发’和‘公平分配’。
RabbitMQ 的工作模式——Work Queues 工作队列模式
dingd1234的博客
05-23 722
一、模式说明 Work Queues：与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。 应用场景：对于任务过重或任务较多情况，使用工作队列可以提高任务处理的速度。 二、代码 Producer_WorkQueues package com.itheima.producer; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.cli
Workqueues
liyucheng987的博客
04-02 91
Workqueues Workqueues are used to schedule actions to run in process context. The base unit with which they work is called work. There are two types of work: structwork_struct- it schedules a task to run at a later time structdelayed_work- it schedu...
biased-work-queues
04-16
[roc@fedora biased-work-queues]$ perf stat target/release/biased-work-queues crossbeam... 19,556.10 msec task-clock # 7.756 CPUs utilized 315,292 context-switches # 0.016 M/sec 861
RabbitMq
01-20
work queues 工作队列 公平分发 轮询分发 public/subscribe 发布订阅 routing 路由选择 通配符模式 topics 主题 手动和自动确认消息 队列的持久化和非持久化 RabbitMq的延迟队列 在官网教程中，描述了六类工作队列...
Essential Linux-DeviceDrivers
04-20
It then moves on to helper interfaces such as linked lists, work queues, completion functions, and notifier chains. These helper facilities simplify your code, weed out redundancies from the kernel, ...
202006学习2.zip
06-22
Work queues，也被称为（Task queues），任务模型。 当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越 多，无法及时处理。此时就可以使用work 模型：让多个...
RabbitMQ发布确认和消息回退(6)
weixin_45751763的博客
04-23 733
rabbitmq的发布确认和消息回退以及备份交换机的概览，确保生产者的消息能推送成功，即使失败也不会丢失
深入理解Java消息中间件-RabbitMQ
u011532237的博客
04-21 800
RabbitMQ是基于高级消息队列协议（AMQP）实现的一款开源消息代理软件，旨在提供高可用性、安全、互操作性强的企业消息系统。它由Erlang编写，因而继承了Erlang语言高并发、高可靠性的特点。
RabbitMQ：消息队列的卓越之选
shiranyyds的博客
04-22 655
RabbitMQ：消息队列的卓越之选
不重启服务 动态停止、启动RabbitMQ消费者 监听器
熊孩子的博客
04-23 316
不重启服务 动态停止、启动RabbitMQ消费者 监听器
RabbitMQ在Java中的完美实现：从入门到精通
木头大左的博客
04-23 301
RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。本文将详细介绍如何在Java项目中使用RabbitMQ。
Rabbitmq安装延迟插件rabbitmq_delayed_message_exchange失败
Mr_Richard的博客
04-23 238
Docker里的Rabbitmq容器安装延迟插件rabbitmq_delayed_message_exchange失败。排除了版本问题和端口问题等，发现是虚拟机运行内存不够，增加虚拟机运行内存才成功安装。一启动插件Rabbitmq容器直接停止运行了。
RabbitMQ（高级）笔记
最新发布
程序员碎像的博客
04-26 271
（2）生产者确认 引入日志依赖 二、MQ持久化 （1）持久化介绍 发送100万条消息给队列，需要先在application.yml中取消生产者确认 没有持久化的测试用例，会出行阻塞的状态： 改为持久化后的测试用例： 使用auto自动模式 注意：创建的simple.queue需要Add Dead letter exchange，其他都跟之前创建的操作差不多 监听 测试用例 （3）取消订单
异步线程与RabbitMQ应该如何选择？
weixin_53390884的博客
04-23 237
异步线程是一种编程技术，它允许程序在执行长时间操作（如I/O操作、网络请求等）时，不阻塞主执行线程。这可以通过多线程或使用语言特性（如Python的。
Rabbitmq消息应答，持久化，权重分配(7)
weixin_45751763的博客
04-24 768
Rabbitmq的消息应答，持久化，权重分配机制
Linux workqueue
03-30
Workqueues are implemented using a set of kernel threads known as worker threads. These threads are responsible for executing the tasks that are queued in the workqueue. The workqueue API provides ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值