RabbitMQ（二）Work Queues

最新推荐文章于 2024-06-16 18:21:02 发布
最新推荐文章于 2024-06-16 18:21:02 发布
阅读量131 收藏
点赞数
分类专栏： 消息中间件 文章标签： rabbitmq java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27331467/article/details/125056721
版权

RabbitMQ

文章目录

3. 简单模式的使用

3.1 Hello Word

在这里，我们将使用java编写两个程序，分别是生产者与消费者，流程为生产者连接MQ发送消息，然后利用消费者去消费这个消息。

  1. Maven依赖（java环境）

    <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>8</source>
                <target>8</target>
            </configuration>
        </plugin>
    </plugins>
</build>
<dependencies>
    <!--rabbitmq 依赖客户端-->
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>5.8.0</version>
    </dependency>
    <!--操作文件流的一个依赖-->
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.6</version>
    </dependency>
</dependencies>

  2. Producer.java（生产者代码）

    package com.lvhaoit.rabbitmq.one;

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

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (asus)
 * Date: 2022/5/30
 * Time: 9:03
 */
public class Producer {
    public static final String QUEUE_NAME = "hello";

    //发消息
    public static void main(String[] args) throws Exception {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //工厂ip
        factory.setHost("1.1.1.1");

        //用户名
        factory.setUsername("lvhao");
        //密码
        factory.setPassword("*****");

        //创建连接
        Connection connection = factory.newConnection();

        //获取信道
        Channel channel = connection.createChannel();

        //声明一个序列
        /**
         * 1. 队列名称
         * 2. 是否持久化到磁盘 (队列持久化)
         * 3. 是否共享
         * 4. 是否自动删除
         * 5. 队列参数
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        String message = "hello word";

        for (int i = 0; i < 10; i++) {
            //发送消息
            /**
             * 1. 交换机
             * 2. 队列名
             * 3. 参数 消息持久化
             * 4. 消息
             */
            channel.basicPublish("", QUEUE_NAME, null, (message + i).getBytes());
            System.out.println("消息已发送");
        }
    }
}

  3. Consumer.java（消费者代码）

    package com.lvhaoit.rabbitmq.one;

import com.rabbitmq.client.*;

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (asus)
 * Date: 2022/5/30
 * Time: 9:37
 */
public class Consumer {
    public static final String QUEUE_NAME = "hello";

    //发消息
    public static void main(String[] args) throws Exception {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //工厂ip
        factory.setHost("1.1.5.1");

        //用户名
        factory.setUsername("lvhao");
        //密码
        factory.setPassword("******");

        //创建连接
        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();

        //        声明接收消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println(new String(message.getBody()));
        };

        //取消消息回调
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println("消息被中断");
        };

          /**
         * 1. 队列名称
         * 2. 是否自动应答 true自动
         * 3. 接收消息处理方法
         * 4. 中断消息处理方法
         */
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);

    }
}

  4. 操作步骤

    1. 先运行生产者代码（可以看到生产者成功发送消息）

    2. 再运行消费者代码（可以看到消费者成功消费生产者发送的消息）

    3. 运行截图：
      在这里插入图片描述

4. Work Queues

工作队列(又称任务队列)的主要思想是避免立即执行资源密集型任务，而不得不等待它完成。 相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进 程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。

4.1 轮询分发消息

这个例子中，我们将启动三个工作线程，一个消息发送线程，看看MQ是如何分发消息的

  1. 抽取共同代码块，形成可共用工具类。（用来获取信道）

    public class RabbitMQUtils {
    public static Channel getChannel() throws Exception {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //工厂ip
        factory.setHost("121.196.195.124");

        //用户名
        factory.setUsername("lvhaoit");
        //密码
        factory.setPassword("lh051920");

        //创建连接
        Connection connection = factory.newConnection();

        //获取信道
        Channel channel = connection.createChannel();
        return channel;
    }
}

  2. 编写消费者工作线程

    public class Work01 {

    public static final String QUEUE_NAME = "hello";

    // 处理消息
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMQUtils.getChannel();

        //        声明接收消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println(new String(message.getBody()));
        };

        //取消消息回调
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println(consumerTag + "消息被中断");
        };

        System.out.println("C3正在的等待接收消息");
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
    }
}

  3. 编写生产者生产线程

    /**
 * 消息处理轮询机制，一个消费线程消费一个 交错消费
 */
public class Task01 {

    public static final String QUEUE_NAME = "hello";

    //发消息
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMQUtils.getChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            String message = scanner.next();

            //发消息
            channel.basicPublish("", QUEUE_NAME, null, (message).getBytes());
            System.out.println("消息已发送： " + message);

        }
    }
}

  4. 操作步骤

    1. 打开消费者的并行选项

      在这里插入图片描述

    2. 同时启动三个消费者线程

      在这里插入图片描述

    3. 打开生产者线程，并发送三条消息

      在这里插入图片描述

    4. 观察启动的三个消费者进程，可以发现如下情况

      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

  5. 得出结论工作队列默认是以轮询的方式进行消息分配，即人人平等，本着公平原则，一人一条，交错消费。

4.2 消息应答

4.2.1 概念

消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成 了部分突然它挂掉了，会发生什么情况。RabbitMQ 一旦向消费者传递了一条消息，便立即将该消 息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续 发送给该消费这的消息，因为它无法接收到。

为了保证消息在发送过程中不丢失，rabbitmq 引入消息应答机制，消息应答就是:消费者在接 收到消息并且处理该消息之后，告诉 rabbitmq 它已经处理了，rabbitmq 可以把该消息删除了。

4.2.2 自动应答

消息发送后立即被认为已经传送成功，这种模式需要在高吞吐量和数据传输安全性方面做权衡,因为这种模式如果消息在接收到之前，消费者那边出现连接或者 channel 关闭，那么消息就丢 失了,当然另一方面这种模式消费者那边可以传递过载的消息，没有对传递的消息数量进行限制， 当然这样有可能使得消费者这边由于接收太多还来不及处理的消息，导致这些消息的积压，最终 使得内存耗尽，最终这些消费者线程被操作系统杀死，所以这种模式仅适用在消费者可以高效并 以某种速率能够处理这些消息的情况下使用

​ 通俗来说：当使用自动应答的时候能够更加的高效，但是对工作环境有着更高的要求，万一其中发生MQ服务器宕机或者消息过度积压，就有可能造成消息丢失的情况。

4.2.3 消息应答的方法（手动应答）

  1. Channel.basicAck(用于肯定确认)

    使用场景：RabbitMQ 已知道该消息并且成功的处理消息，可以将其丢弃了

  2. Channel.basicNack(用于否定确认)

  3. Channel.basicReject(用于否定确认)

    与 Channel.basicNack 相比少一个参数

    使用场景：不处理该消息了直接拒绝，可以将其丢弃了

优点：手动应答的好处就是可以批量应答并且减少网络拥堵。

4.2.4 Multiple的解释

​ Channel.basicAck（deliveryTag，true）

​ 这里的true就是multiple，意思是代表批量应答

​ 批量应答：假设channel（信道）上传送tag的消息有1，2，3，4,当前tag是4，那么此时1-4这些还未应答的消息都会被批量收到消息应答。

​ 当这里为false时，每次只会应答当前此条消息的应答。

为了保证队列中的消息不出现消息丢失情况，最好将此选项设置为false。

4.2.5 消息的自动重新入队

​ 如果消费者由于某些原因失去连接(其通道已关闭，连接已关闭或 TCP 连接丢失)，导致消息 未发送 ACK 确认，RabbitMQ 将了解到消息未完全处理，并将对其重新排队。如果此时其他消费者 可以处理，它将很快将其重新分发给另一个消费者。这样，即使某个消费者偶尔死亡，也可以确 保不会丢失任何消息。

4.2.6 手动应答效果

  1. 消费线程 C3 （该线程会在处理消息时，线程沉睡三十秒，模拟处理消息慢的工作线程）

    public class Work03 {
    public static final String QUEUE_NAME = "ack_queue";

    // 处理消息
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMQUtils.getChannel();

        //        声明接收消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println(new String(message.getBody(), "UTF-8"));
            try {
                //睡眠三十秒
                Thread.sleep(1000 * 30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


            //手动应答
            /**
             * 1.消息的标记
             * 2.是否需要批量应答 最好不要批量应答，批量应答有可能造成消息丢失
             */
            channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
            System.out.println("处理结束！");
        };

        //取消消息回调
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println(consumerTag + "消息被中断");
        };

        System.out.println("C3(执行时间较长)正在的等待接收消息");
        //采用手动应答
        boolean autoACK = false;

        /**
         * 1. 队列名称
         * 2. 是否自动应答 true自动
         * 3. 接收消息处理方法
         * 4. 中断消息处理方法
         */
        channel.basicConsume(QUEUE_NAME, autoACK, deliverCallback, cancelCallback);
    }
}

  2. 消费线程 C4 （该线程会在处理消息时，线程沉睡两秒，模拟处理消息快的工作线程）

    public class Work04 {
    public static final String QUEUE_NAME = "ack_queue";

    // 处理消息
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMQUtils.getChannel();

        //        声明接收消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println(new String(message.getBody(), "UTF-8"));

            try {
                //睡眠2秒
                Thread.sleep(1000 * 2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //手动应答
            /**
             * 1.消息的标记
             * 2.是否需要批量应答 最好不要批量应答，批量应答有可能造成消息丢失
             */
            channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
            System.out.println("处理结束！");
        };

        //取消消息回调
        CancelCallback cancelCallback = consumerTag -> {
            System.out.println(consumerTag + "消息被中断");
        };


        System.out.println("C4(执行时间较短)正在的等待接收消息");


      
        //采用手动应答
        boolean autoACK = false;
        /**
         * 1. 队列名称
         * 2. 是否自动应答 true自动
         * 3. 接收消息处理方法
         * 4. 中断消息处理方法
         */

        channel.basicConsume(QUEUE_NAME, autoACK, deliverCallback, cancelCallback);
    }
}

  3. 生产线程

    /**
 * 生产者
 * 让其中一个消费线程中断宕机，消费的信息会重新丢回队列给新的消费者重新消费
 */
public class Task02 {


    public static final String QUEUE_NAME = "ack_queue";

    //发消息
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMQUtils.getChannel();
        /**
         * 1。 队列名称
         * 2. 是否持久化到磁盘 (队列持久化)
         * 3. 是否共享
         * 4. 是否自动删除
         * 5. 队列参数
         */
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        //循环发消息

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            String message = scanner.next();
            /**
             * 1. 交换机
             * 2. 队列名
             * 3. 参数 消息持久化
             * 4. 消息
             */
            channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes("UTF-8"));
            System.out.println("生产者发出消息： " + message);

        }
    }
}

  4. 操作步骤

    1. 打开两个消费进程与一个生产进程

      在这里插入图片描述

    2. 用生产进程发送四个消息

      在这里插入图片描述

    3. 可以发现c3进程第一个消息还没处理完成，此时c4进程两条消息已经都处理完成，c3进程处理中一条消息，堆积了一条消息，此时关闭c3进程，可知c3进程处理中的消息也未能正确进行消息应答。

      在这里插入图片描述

    4. 此时发现c4进行将c3未处理完的消息和堆积的消息一起拿过来处理掉了，可以证明c3中的消息重新入列了。

      在这里插入图片描述

LvhaoIT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RabbitMQ之Work Queues
weixin_38425605的博客
02-20 86
轮训分发消息、消息应答、RabbitMQ持久化
RabbitMQ 工作队列
chenjianhuideyueding的博客
06-12 304
工作队列 （使用java客户端） 在第一个教程中我们从命名的队列写了发送和接受信息的程序。在这个教程我们将创建在多个工作者中被用来分发时间消耗任务的工作队列。 工作队列（又名：任务队列）背后的主要的思想是避免立即做一些资源密集型的任务，并且必须等待它完成。相反，我们安排稍后完成。我们将任务封装成一个消息，并将它发送到队列中，一个工作者进程在后台运行将会弹出任...
设计模式—工厂方法模式
qq_27331467的博客
01-18 1585
设计模式之工厂方法模式
Maven
qq_27331467的博客
05-23 100
maven 文章目录maven第一部分1.完成一个java项目，需要做哪些工作2.传统开发项目的问题，没有使用maven管理的项目3.需要改进项目的开发和管理，需要maven4.构建： 项目的构建。5.maven核心概念： 用好maven，了解这些概念6.maven工具的安装和配置。第二部分1.maven约定的目录结构， 约定是大家都遵循的一个规则。2.疑问： mvn compile 编译src/main目录下的所有java文件的3.仓库4.pom:项目对象模型，是一个pom.xml文件5.maven生命周
Java线程学习笔记（三）
qq_27331467的博客
04-18 66
线程 （接上篇） 这一章东西比较多。 8.守护线程 ​ java中线程分为两大类： ​ 一类是：用户线程 ​ 一类是：守护线程（后台线程） ​ 其中最具代表性的就是：垃圾回收线程（守护线程） ​ 守护线程特点： ​ 一般守护线程是一个死循环，素有的用户线程只要结束，守护线程自动结束。 ​ 注意：主线程main方法是一个用户线程。 package 线程; public class 线程守护 { public static void main(String[] args) {
前端函数名词
qq_27331467的博客
09-10 147
纯函数 解释： 一个函数对于给定一个参数的返回值是固定的。 函数不会对外部造成影响 具有的优点 可测试性，即当测试值出现改变时，函数不会因为值的改变而失效 可缓存性，可以节约一定的计算资源（因为对于一个参数，他的返回值也一定是不变的） 可移植性，可以移植到任何地方 高阶函数 解释 函数的参数或返回值，是一个函数类型的对象，函数可以以变量，参数，返回值的方式引用或返回函数。 例如：apply 间接调用函数 函数柯里化 解释 将接收的所有参数变成单一参数的函数，并且返回接收余下参数返回结果的新函数
rabbitMQ简单应用pattern1 Work queues 工作队列模式
07-10
Work Queues与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列 中的消息。 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
RabbitMq
01-20
work queues 工作队列 公平分发 轮询分发 public/subscribe 发布订阅 routing 路由选择 通配符模式 topics 主题 手动和自动确认消息 队列的持久化和非持久化 RabbitMq的延迟队列 在官网教程中，描述了六类工作队列...
RabbitMQ.pdf-详情
05-29
2. **工作队列**（Work Queues）：多个消费者，消息被分发给空闲的消费者，保证任务的并行处理。 3. **发布/订阅**：多个生产者和消费者，每个消费者可以订阅多个主题，广播模式。 4. **路由**：根据路由键将消息...
rabbitMQ 消息队列 Demo
10-18
rabbitMQ官方Demo，包含01HelloWorld，02WorkQueues，03PublishSubscribe，04Routing，05Topics，06RPC六个示例
rabbitmq简单demo
08-17
rabbit的各种工作模式的demo，包括work queues模式，publish/Subscribe模式，Routing模式等
### RabbitMQ五种工作模式：
weixin_46597615的博客
06-13 498
4、路由模式：由交换机分发消息，但是发送方需要指定路由key，交换机会根据不同的routing key分发给不同的队列，消费方对应自己需要的队列。5、通配符模式：和路由模式有些相近，只是通配符模式可以在绑定routing key时使用通配符。2、工作队列模式：也是不通过交换机，消息直接通过队列，只是一个发送方可以有多个接收端。3、发布订阅模式：由交换机分发消息到不同队列，每个消费者只监听自己的队列。1、简单模式：就是不通过交换机，消息直接通过队列，一对一收发。
消息队列-RabbitMQ-延时队列实现
Nanki_的博客
06-16 406
DLX,全称为Dead-Letter-Exchange,死信交换机，死信邮箱。当消息在一个队列中变成死信之后，它能重新发送到另外一个交换器中，这个交换器就是DLX，绑定DLX的队列就称为死信队列。● 消息被拒(Basic.Reject/Basic.Nack)且requeue = false。● 消息TTL（消息的存活时间）过期。● 队列满了，无法再添加。
【RabbitMQ】异步消息及Rabbitmq安装
开心星人的博客
06-15 542
在异步调用中，发送者不再直接同步调用接收者的业务接口，而是发送一条消息投递给消息Broker。这样，发送消息的人和接收消息的人就完全解耦了。如果我们的业务需要实时得到服务提供方的响应，则应该选择同步通讯（同步调用）。如果我们追求更高的效率，并且不需要实时响应，则应该选择异步通讯（异步调用）消息Broker：管理、暂存、转发消息，你可以把它理解成微信服务器。消息接收者：接收和处理消息的人，就是原来的服务提供方。消息发送者：投递消息的人，就是原来的调用方。docker安装Rabbitmq。
RabbitMQ高频面试题整理
一个喜欢诗和远方的程序媛
06-12 1157
AMQP（Advanced Message Queuing Protocol，高级消息队列协议）是一种用于消息传递的开放标准协议，广泛用于消息队列和消息中间件系统中。RabbitMQ 是 AMQP 协议的一个实现。Broker（代理）消息代理是消息队列服务器，负责接收、存储和转发消息。例如，RabbitMQ 就是一个 AMQP 消息代理。Message（消息）消息是 AMQP 中的基本数据单元，包含要传递的数据和一些元数据（如路由键和头属性）。Producer（生产者）
RabbitMQ实践——在Ubuntu上安装并启用管理后台
方亮的专栏
06-13 664
RabbitMQ是一款功能强大、灵活可靠的消息代理软件，为分布式系统中的通信问题提供了优秀的解决方案。无论是在大规模数据处理、实时分析还是微服务架构中，RabbitMQ都能发挥出色的性能，帮助开发者构建高效、稳定的系统。本系列我们将基于Java技术栈，探索RabbitMQ的一些使用。
RabbitMQ从入门到入土
MADAO的博客
06-11 934
优势：时效性强，等到结果后就返回问题：扩展性差性能下降级联失败问题。
rabbitMQ的简单使用
最新发布
m0_66316879的博客
06-16 962
RabbitMQ是一个开源的消息代理和队列服务器，主要用于在不同的应用程序之间传递消息。它基于AMQP（Advanced Message Queuing Protocol）协议，提供了一种可靠的方式来处理异步通信。RabbitMQ使用Erlang语言编写，具有高可用性、可伸缩性和可靠性。
docker 启动 rabbitmq 国内启动调试
JavaPub
06-11 423
国内无法拉取 rabbitmq 镜像，使用国内镜像版本。
RabbitMQ面试
08-12
常见的消息模式包括：点对点模式（Point-to-Point）、发布/订阅模式（Publish/Subscribe）、工作队列模式（Work Queues）和主题模式（Topics）。 这些问题只是作为参考，你可能还会面试到其他方面的问题。建议你对...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LvhaoIT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值