RabbitMQ五种队列介绍（一、Simple Queue与Work Queue）

最新推荐文章于 2024-09-20 10:11:13 发布
最新推荐文章于 2024-09-20 10:11:13 发布
阅读量1.6k 收藏 1
点赞数
文章标签： Java RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MrJDR/article/details/81511112
版权

本文将从三个方便了解的RabbitMQ

1，RabbitMQ的是什么

2，为什么要有的RabbitMQ 

3，RabbitMQ的五种队列的实现

一，RabbitMQ的是什么

首先在了解RabbitMQ之间我们要知道什么是MQ，MQ的全称为Message Queue也就是消息队列，是一种应用程序之间的通信方法 ;应用程序通过读写消息队列的消息（针对应用程序的数据）来通信，而无需专门用连接来链接它们。

二，为什么要有的RabbitMQ

由于高并发环境下数据来不及同步处理，请求往往会发生阻塞;比如大量的插入，更新等语句同时到达db，直接导致行锁，表锁，甚至最后请求会堆积过多，触发太多连接的错误;而RabbitMQ的是异步的消息，可以很好的解决高并发环境下的种种问题。

使用场景：一些无需及时报道查看御姐耗时的操作，使用MQ来处理，这样的话可以大大节省服务器的请求响应时间，从而提高系统的吞吐量。

三，RabbitMQ的五种队列的实现

1，Simple Queue（简单队列）

消息发送者

package com.vcredit.jdr.rabbitmq.project.send;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.vcredit.jdr.rabbitmq.project.config.RabbitMQConfig;

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

public class SendMessage {

    private static final String QUEUE_NAME = "queue_simple";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = null;
        Channel channel = null;
        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1");
            connection = factory.newConnection();
            channel = connection.createChannel();

            channel.queueDeclare(
                    QUEUE_NAME, // 队列的名称
                    false, // 是否为持久化队列，若为true，服务器关闭后次队列依然处在
                    false, // 是否为独占队列（仅限于此连接），true为是
                    false, // 是否自动删除（服务器不适用其时删除次队列），true为是
                    null // 队列的其他属性（构造参数）
            );
            String message = "[1] Hello World";
            channel.basicPublish(
                    "", // 消息发布到的交换器名
                    QUEUE_NAME, // 路由秘钥
                    null, // 消息的其他属性 - 路由头等
                    message.getBytes() // 消息信息（消息主体）
            );
            System.err.println("[1] success, send message: " + message);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            channel.close();
            connection.close();
        }
    }

}

消息接收者

package com.vcredit.jdr.rabbitmq.project.receive;

import com.rabbitmq.client.*;

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

public class ReceiveMessage {

    private static final String QUEUE_NAME = "queue_simple";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.err.println("[1] waiting for message...");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.err.println("[1] success，received message: " + message);
            }
        };
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

运行ReceivedMessage显示消费者正在等待消息

运行SendMessage函数显示成功发送了一条消息

让我们回ReceivedMessage发现，成功接收了一条消息

这就是简单队列，一个发送者对应一个消费者，当然多个发送者与多个消费者肯定是可以的; 这里建议读者多写几个发送者与消费者来测试效果，我这里就不一一列举了

因为一下的几个队列都需要创建连接，频道对象，所以我们稍作封装

RabbitMQUtil

package com.vcredit.jdr.rabbitmq.project.utils;

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

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

public class RabbitMQUtil {

    public static final String HOST = "127.0.0.1";

    public static Connection getConnection(String host) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);
        return factory.newConnection();
    }

    public static Channel getChannel(String host) throws IOException, TimeoutException {
        Connection connection = getConnection(host);
        return connection.createChannel();
    }

    public static void closeAll(Channel channel, Connection connection) throws IOException, TimeoutException {
        if (channel != null) channel.close();
        if (connection != null) connection.close();
    }
}

2，Work Queue（工作队列）

上面的简单队列只能简单的发送与接收消息，而不能很好的分发消息;例如有一个消息发送者发送了50条消息，接收者1的处理能力差些，接收者2的处理能力好些，这时你会发现一会后接收者2处理完了消息后，接收者1还在工作;这样的话一个很忙一个很闲，服务器的资源不能很好的分配;这样该怎么办这时候我们可以使用工作队列来处理类似问题

队列工作的主要思想的英文避免某一个消费者执行资源密集型任务，并且必须等待它完成，而其他消费者少任务或无任务执行（这里有一个机制，RabbitMQ的情况默认下的英文轮询配给物任务，也就是说如果有2个消费者，50条消息，每个消费者会执行25条消息，而不会管消息执行的繁琐程度）

发送者

package com.vcredit.jdr.rabbtmq.project.task;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import com.vcredit.jdr.rabbitmq.project.config.RabbitMQConfig;
import com.vcredit.jdr.rabbitmq.project.utils.RabbitMQUtil;

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

public class NewTask {

    private static final String QUEUE_NAME = "task";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = RabbitMQUtil.getConnection(RabbitMQConfig.MQ_HOST);
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        // 发送多条消息
        for (int i = 0; i < 50; i++) {
            String message = "send message: " + i;
            channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
            System.out.println("success, send message: " + message);
        }

        RabbitMQUtil.closeAll(channel, connection);
    }
}

接收者1
package com.vcredit.jdr.rabbtmq.project.task;

import com.rabbitmq.client.*;
import com.vcredit.jdr.rabbitmq.project.utils.RabbitMQUtil;

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

public class ReceiveTask {

    private static final String QUEUE_NAME = "task";

    public static void main(String[] args) throws TimeoutException, IOException {
        Connection connection = RabbitMQUtil.getConnection(RabbitMQUtil.HOST);
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
//        channel.basicQos(1); // 设置basicQos=1，每次发完消息后告诉队列自己已经发完了，队列就会给自己在发送一条消息
        System.err.println("[1] wait message ...");

        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("[1] Received1" + message);
                try {
                    Thread.sleep(1000); // 使用线程休眠模拟任务的复杂程度
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("[1] Done");
//                    channel.basicAck(
//                            envelope.getDeliveryTag(), // 收到的标签{@link com.rabbitmq.client.AMQP.Basic.GetOk}或{@link com.rabbitmq.client.AMQP.Basic.Deliver}
//                            false // 自动回执，true为是；收到消息后告诉消息发送者已经收到消息
//                    );
                }
            }
        };
        channel.basicConsume(
                QUEUE_NAME, // 队列名称
                // 是否自动应答
                // true为是，一旦RabbitMQ将消息发送给了消费者就会从内存中删除；如果杀死正在执行消息的消费者那么数据就会丢失
                // 若为false，消费者挂了后会将此消息交给另外一个消费者执行，收到消息后告诉消息发送者已经收到消息，并删除内存中的消息
                true,
                consumer
        );
    }
    
}

接收者2
package com.vcredit.jdr.rabbtmq.project.task;

import com.rabbitmq.client.*;
import com.vcredit.jdr.rabbitmq.project.utils.RabbitMQUtil;

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

public class ReceiveTask2 {

    private static final String QUEUE_NAME = "task";

    public static void main(String[] args) throws TimeoutException, IOException {
        Connection connection = RabbitMQUtil.getConnection(RabbitMQUtil.HOST);
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
//        channel.basicQos(1);
        System.err.println("[2] wait message ...");

        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("[2] Received" + message);
                try {
                    Thread.sleep(3000); // 使用线程休眠模拟任务的复杂程度
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("Done2");
//                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }

}

 

分别执行接收者1、接收者2、发送者，你会发现每个接收者处理了25条消息，且接收者1处理速度要比接收者2快；接下来我们改造上面代码，使队列公平的遣派任务。

其实很简单，我们只需要将两个消费者的注释去掉，将最后一行的channel.basicConsume（QUEUE_NAME，true，consume）;的第二个参数给为假即可;然后我们会惊奇的发现接收者1与接收者2基本是同一时间完成处理，而他们处理消息的数量也不一样了，这样我就解决了Simple Queue解决不了的问题了

MrJDR
关注
消息队列 Queue与Topic区别.docx
02-23
消息队列（Message Queue）是一种应用程序间通信机制，允许程序之间通过发送和接收消息进行通信，而不必直接建立连接。它提供了异步处理机制，使得消息的发送者无需等待接收者处理完毕即可继续执行，从而提高了系统...
RabbitMQ workQueue
lantianlu3的博客
09-02 561
rabbit workqueue 工作队列 任务队列 非公平模式 非公平方式
RabbitMQ---Workqueue模型&&多劳多得
weixin_58104242的博客
01-12 284
Provicer package WorkQuene; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import utils.RabbitMQUtil; import java.io.IOException; /** * @ProjectName: MyRabbitMQ * @Package: WorkQuene * @ClassName: Provider * @Author: zx
RabbitMQ中的队列有哪些类型？
最新发布
qq_33240556的博客
09-20 365
以上这些队列类型可以在不同的应用场景中根据需求选择使用。每种队列都有其特定的优点和适用场景，开发者可以根据自己的业务需求来决定使用哪种类型的队列。RabbitMQ 中的队列可以根据其特性和使用场景来分类。
RabbitMQ
weixin_46729085的博客
09-24 1597
1使用RabbitMQ的好处 1.解耦，系统A在代码中直接调用系统B和系统C的代码，如果将来D系统接入，系统A还需要修改代码，过于麻烦！ 2.异步，将消息写入消息队列，非必要的业务逻辑以异步的方式运行，加快响应速度 3.削峰，并发量大的时候，所有的请求直接怼到数据库，造成数据库连接异常 2.RabbitMQ 中的 broker 是指什么？cluster 又是指什么 broker 是指一个或多个 erlang node 的逻辑分组，且 node 上运行着 RabbitMQ 应用程序。cluster
【RabbitMQ教程】Work queues 工作队列模式
qq_43783527的博客
10-09 1088
将‘work queues工作队列模式’单独抽出来细讲，目的是借助这个模式好好讲一下rabbitmq的‘轮询分发’和‘公平分配’。
RabbitMQ入门：工作队列(Work Queue)
JAVA开发老菜鸟的专栏
06-20 255
RabbitMQ入门：工作队列(Work Queue) 在上一篇博客《RabbitMQ入门：Hello RabbitMQ 代码实例》中，我们通过指定的队列发送和接收消息，代码还算是比较简单的。 假设有这一些比较耗时的任务，按照上一次的那种方式，我们要一直等前面的耗时任务完成了之后才能接着处理后面耗时的任务，那要等多久才能处理完？别担心，我们今天的主角--工作队列就可以解决该问题。我们将围...
消息队列RabbitMQ入门与5种模式详解
02-24
AMQP（高级消息队列协议）是一个异步消息传递所使用应用层协议规范，为面向消息中间件设计，基于此协议的客户端与消息中间件可以无视消息来源传递消息，不受客户端、消息中间件、不同的开发语言环境等条件的限制；...
rabbitmq 7种队列实现java版
01-20
文章目录rabbitmq7种实现方式搭建maven项目引入依赖创建连接简单队列消息生产者消息消费者work queues 工作队列生产者消费者能者多劳（公平分发）：消费能力强则消费更多消息Publish/Subscribe 发布订阅模式生产者...
rabbitmq-dump-queue:将消息从 RabbitMQ 队列转储到文件，而不影响队列
08-05
rabbitmq-转储队列 将消息从 RabbitMQ 队列转储到文件，而不影响队列。 安装 下载一个版本 可以在页面上找到预编译的二进制包。 从源代码编译 如果您安装了 ，则可以通过运行以下命令从源代码安装 rabbitmq-dump-...
RabbitMQ之Work Queue（工作队列）
热门推荐
小威的博客
01-10 2万+
本篇文章将记录和分享RabbitMQ工作队列相关的知识点，感兴趣的大佬可以看过来哟~
SpringBoot整合RabbitMQ---Work Queue轮询模式
weixin_44428051的博客
04-27 1152
1、配置文件 application.yml #基本配置 server: port: 8080 spring: #mysql基本配置 datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/mybase?characterEncoding=utf8&useSSL=fal...
8-RabbitMQ工作模式总结
DevOps海洋的渔夫@专栏
10-05 434
8-RabbitMQ工作模式总结模式总结RabbitMQ工作模式：1、简单模式 HelloWorld一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）2、工作队列模式 Work Queue一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）3、发布订阅模式 Publish/subscribe需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换...
RabbitMQ之工作模型 Work queues
YellowSubject的博客
03-12 156
**前言：**如图先来看看RabbitMQ的几种模型 P：生产者：任务的发布者 C1：消费者-1，领取任务并且完成任务，假设完成速度较慢 C2：消费者-2：领取任务并完成任务，假设完成速度快 消费者1 public class Customer1 { public static void main(String[] args) throws IOException { //获取连接对象 Connection connection = RabbitMQUtils.
RabbitMQ系列（6）--RabbitMQ模式之工作队列(Work queues)的简介及实现
m0_64284147的博客
04-08 777
2、在写实现工作队列前先新建一个名为utils用于放工具类的包，然后在包里新建一个RabbitMqUtils工具类，抽取重复性的代码放入其中，这样就不用每次都写重复的代码了。当有多个工作线程（消费者）时，这些工作线程（消费者）将一起处理这些任务。值得注意的是一个消息只能被处理一次，不可以处理多次，三个工作线程之间是竞争关系。由图可看出两个工作线程（消费者）轮询的消费掉生产者发送的信息，由此可以证明工作队列运行成功！3、新建一个名为workqueues的包，用于装工作队列的代码。
RabbitMQ 工作模式介绍以及对比
weixin_44691279的博客
07-22 676
RabbitMQ 工作模式介绍
RabbitMQ 入门系列（11）— RabbitMQ 常用的工作模式（simple模式、work模式、publish/subscribe模式、routing模式、topic模式）
wohu1104的专栏
08-21 719
1. simple 模式 simple 模式是最简单最常用的模式 2. work 模式 work 模式有多个消费者 3. publish/subscribe 模式 publish/subscribe 模式 消息被路由投递到多个队列，一个消息被多个消费者获取。 4. routing 模式 routing 模式 一个消息被多个消费者获取，并且消息的目标队列可被生产者指定。 5. topic 模式 topic 模式，一个消息被多个消费者获取，消息的目标 queue 可用 BindKey 以通配符 # 一
5.RabbitMQ消息队列类型（7个）详细使用
相互学习 共同进步
05-22 3030
RabbitMQ是消息代理：接受并转发消息。可以将其视为邮局 将要发布的邮件放在邮箱中时，可以确保邮递员最终将邮件传递给收件人。以此类推，RabbitMQ是一个邮箱、一个邮局和一个邮递员 RabbitMQ与邮局之间的主要区别在于，它不处理纸张。只是做接收、存储和转发数据消息的二进制码 AMQP（Advanced Message Queuing Protocol，高级消息队列协议） 应用层协议的一个开放标准，为面向消息的中间件设计。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性
RabbitMQ 七种队列模式应用场景案例分析（通俗易懂）
Java知音
04-06 628
作者：我思知我在blog.csdn.net/qq_32828253/article/details/110450249七种模式介绍与应用场景简单模式（Hello World）做最简单的事情...
RabbitMQ消息队列入门与五种应用模式详解
2. Work Queue模式：Work Queue模式是RabbitMQ的一种模式，多个consumer可以从同一个队列中消费消息，从而实现任务的并行处理。 3. Publish/Subscribe模式：Publish/Subscribe模式是一种基于主题的消息队列模式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值