RabbitMq 七大发布消息之Work queues模式

RabbitMQ研究(四)几种模式 RabbitMQ的几种工作模式: 1、Work queues 工作模式 2、Publish/Subscribe 发布订阅 3、Routing 路由 4、Topics 通配符 5、Header Header转发 6、RPC 远程调用 Work quenes : 一个生产者,一个队列,多个消费者 多个消费者共同监听一个队列,消息不能被重复消费,rabbitMQ采用轮询的... 阅读详情

上一篇文章我们讲了helloword模式的消息发布:RabbitMq 七大发布消息之helloword最简单的发布和消费消息

这一篇我们讲解第二种消息发布模式——Work queues,也就是项目中常用的Task queues模式。从以下图中不难看出是属于一个生产者对应多个消费者模式,是一对多的关系。

Work queues,也被成为Task queues,任务模型。当消息处理比较耗时的时候,可能生产消息的速度远远大于消费者消费的速度,那么就会造成队列中的消息发生堆积,无法及时被处理。此时就可以使用Work queues,让多个消费者绑定到一个队列,共同消费队列中的消息。队列中的消息一旦被消费就会消失,因此不会造成重复消费的情况。

我们在上一篇helloword的基础上进行优化,先提出一个公共类的代码。

1.RabbitMqUtil

package 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;

/**
 * @Author: 
 * @Despriction:
 * @Package: utils
 * @Date:Created in 2020/3/23 8:44
 * @Modify By:
 */
public class RabbitMqUtil {

    private static ConnectionFactory connectionFactory;

    static {
        //第一步:创建rabbitmq的连接工厂
        connectionFactory = new ConnectionFactory();
        //第二步:设置连接的rabbitmq服务器的连接ip
        connectionFactory.setHost("192.168.4.6");
        //第三步:连接端口号,默认的为5672
        connectionFactory.setPort(5672);
        //第四步:设置连接哪个虚拟主机
        connectionFactory.setVirtualHost("/ems");
        //第五步:设置连接虚拟主机的用户和密码
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("123");
    }

    //获取rabbitmq的连接
    public static Connection getConnection() {
        //第六步:获取连接对象
        Connection connection = null;
        try {
            connection = connectionFactory.newConnection();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return connection;
    }

    public static void getClose(Connection connection, Channel channel) {
        try {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }

    }
}

在项目中rabbitmq的连接将会以配置文件的形式进行配置,此处只是简单的学习使用,用静态代码块的原因是为了只需要开辟一次空间即可,且只会在类加载的时候执行一次,此后不再执行。

2.生产者代码

package workQueues;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import org.junit.Test;
import utils.RabbitMqUtil;

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

/**
 * @Author: 
 * @Despriction: Work queues 生产消费模式
 * @Package: helloword
 * @Date:Created in 2020/3/19 11:14
 * @Modify By:
 */
public class Provider {

    @Test
    public void sendMsg() throws IOException, TimeoutException {
        //通过公用方法获取rabbit连接
        Connection connection = RabbitMqUtil.getConnection();
        //第七步:创建连接通道
        Channel channel = connection.createChannel();
        //第八步:通道绑定对应的消息队列
        /**
         * 参数1 queue:队列名称,如果队列不存在则自动创建
         * 参数2 durable:用来定义队列是否需要持久化,true  需要持久化;false  不需要持久化
         * 参数3 exclusive:定义是否独占队列,true  是;false 否
         * 参数4 autodelete:消费完成后是否需要自动删除队列,true 是;false 否
         * 参数5:自定义的额外附加参数
         */
        channel.queueDeclare("work", true, false, false, null);
        //第九步:发布消息
        /**
         * 参数1:交换机名称
         * 参数2:队列名称
         * 参数3:传递消息的额外设置
         *       MessageProperties.PERSISTENT_TEXT_PLAIN 表示该队列中的未被消费的消息会进行持久化
         * 参数4:消息的具体内容,必须二进制
         */
        //for循环测试一个生产者对应多个消费者时,消息队列中的消息是怎样分配的
        for (int i = 0; i < 10; i++) {
            channel.basicPublish("", "work", MessageProperties.PERSISTENT_TEXT_PLAIN, ("第(" + i + ")条Work queues").getBytes());
        }

        //第十步:关闭通道和连接
        //channel.close();
        //connection.close();
        RabbitMqUtil.getClose(connection, channel);
    }
}

此处使用for循环生产多个消息为了方便测试。

3.消费者1和消费2的代码

package workQueues;

import com.rabbitmq.client.*;
import utils.RabbitMqUtil;

import java.io.IOException;

/**
 * @Author: 
 * @Despriction:
 * @Package: workQueues
 * @Date:Created in 2020/3/23 9:05
 * @Modify By:
 */
public class Consumer1 {

    public static void main(String args[]) throws IOException {
        //通过公用方法获取rabbit连接
        Connection connection = RabbitMqUtil.getConnection();
        //创建通道连接
        Channel channel = connection.createChannel();
        //通道绑定队列
        /**
         * 参数1 queue:队列名称,如果队列不存在则自动创建
         * 参数2 durable:用来定义队列是否需要持久化,true  需要持久化;false  不需要持久化
         * 参数3 exclusive:定义是否独占队列,true  是;false 否
         * 参数4 autodelete:消费完成后是否需要自动删除队列,true 是;false 否
         * 参数5:自定义的额外附加参数
         */
        channel.queueDeclare("work",true,false,false,null);
        //消费消息
        /**
         * 参数1:队列名称,即将要消费哪一个队列的消息
         * 参数2:开启消息的自动确认机制
         * 参数3:消费时的回调接口,常用来处理业务逻辑,一般都是Consumer接口的实现类,此处用默认的DefaultConsumer
         */
        channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-1:" + new String(body));
            }
        });
    }

}
package workQueues;

import com.rabbitmq.client.*;
import utils.RabbitMqUtil;

import java.io.IOException;

/**
 * @Author: 
 * @Despriction:
 * @Package: workQueues
 * @Date:Created in 2020/3/23 9:05
 * @Modify By:
 */
public class Consumer2 {

    public static void main(String args[]) throws IOException {
        //通过公用方法获取rabbit连接
        Connection connection = RabbitMqUtil.getConnection();
        //创建通道连接
        Channel channel = connection.createChannel();
        //通道绑定队列
        /**
         * 参数1 queue:队列名称,如果队列不存在则自动创建
         * 参数2 durable:用来定义队列是否需要持久化,true  需要持久化;false  不需要持久化
         * 参数3 exclusive:定义是否独占队列,true  是;false 否
         * 参数4 autodelete:消费完成后是否需要自动删除队列,true 是;false 否
         * 参数5:自定义的额外附加参数
         */
        channel.queueDeclare("work",true,false,false,null);
        //消费消息
        /**
         * 参数1:队列名称,即将要消费哪一个队列的消息
         * 参数2:开启消息的自动确认机制
         * 参数3:消费时的回调接口,常用来处理业务逻辑,一般都是Consumer接口的实现类,此处用默认的DefaultConsumer
         */
        channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-2:" + new String(body));
            }
        });
    }

}

 4.执行之后控制台的打印

消费者1控制台的打印

消费者2控制台的打印

可以看到这两个消费者的控制台打印的东西都是平均打印的,即队列的消息分配在默认情况下是均衡分配的。且在官方文档上是明确说明的:https://www.rabbitmq.com/tutorials/tutorial-two-java.html

 

以上这种情况也会造成不友好的情况,一旦某一个消费者出现网络延迟等问题就会造成一部分的消息丢失,尽管被消费者消费了,但是却没法进行业务逻辑的处理,客户没法获取到消息的反馈,因此这部分消息就被丢失了。

例如我们此时将消费者1的代码里面加入线程阻塞来进行实验。代码如下:

package workQueues;

import com.rabbitmq.client.*;
import utils.RabbitMqUtil;

import java.io.IOException;

/**
 * @Author: 
 * @Despriction:
 * @Package: workQueues
 * @Date:Created in 2020/3/23 9:05
 * @Modify By:
 */
public class Consumer1 {

    public static void main(String args[]) throws IOException {
        //通过公用方法获取rabbit连接
        Connection connection = RabbitMqUtil.getConnection();
        //创建通道连接
        Channel channel = connection.createChannel();
        //通道绑定队列
        /**
         * 参数1 queue:队列名称,如果队列不存在则自动创建
         * 参数2 durable:用来定义队列是否需要持久化,true  需要持久化;false  不需要持久化
         * 参数3 exclusive:定义是否独占队列,true  是;false 否
         * 参数4 autodelete:消费完成后是否需要自动删除队列,true 是;false 否
         * 参数5:自定义的额外附加参数
         */
        channel.queueDeclare("work",true,false,false,null);
        //消费消息
        /**
         * 参数1:队列名称,即将要消费哪一个队列的消息
         * 参数2:开启消息的自动确认机制
         * 参数3:消费时的回调接口,常用来处理业务逻辑,一般都是Consumer接口的实现类,此处用默认的DefaultConsumer
         */
        channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者-1:" + new String(body));
            }
        });
    }

}

控制台的打印

 此时很明显的可以看到消费者1消费的速度缓慢,也会造成消费者1的信息堆积,一旦发生网络异常,还未被消费的或者还未被业务逻辑处理的消息就会被丢失。以下是官方文档的叙述:

如何改进?

一是让每个消费者每次只消费一条消息,而不是像之前一次性打包消费;

//表示该消费者每次只能消费处理一个消息
channel.basicQos(1);

二是将自动消费确认true改为false,即由自动确认更改为手动确认,手动确认完成之后才算该消息在整个流程中完成了可以消费下一个消息了。

//消费消息
        /**
         * 参数1:队列名称,即将要消费哪一个队列的消息
         * 参数2:开启消息的自动确认机制
         * 参数3:消费时的回调接口,常用来处理业务逻辑,一般都是Consumer接口的实现类,此处用默认的DefaultConsumer
         */
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者-1:" + new String(body));
                //手动确认
                /**
                 * 参数1:手动确认的标识
                 * 参数2:是否开启多个消息同时确认机制,false 每次确认1个
                 */
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });

一定不要漏了:

//手动确认
/**
 * 参数1:手动确认的标识
 * 参数2:是否开启多个消息同时确认机制,false 每次确认1个
 */
channel.basicAck(envelope.getDeliveryTag(),false);

最后给出优化之后的消费者1和消费者2的详细代码,我了有所比较,依然将消费者1进行线程阻塞。

消费者1:

package workQueues;

import com.rabbitmq.client.*;
import utils.RabbitMqUtil;

import java.io.IOException;

/**
 * @Author: yangli@elane.cn
 * @Despriction:
 * @Package: workQueues
 * @Date:Created in 2020/3/23 9:05
 * @Modify By:
 */
public class Consumer1 {

    public static void main(String args[]) throws IOException {
        //通过公用方法获取rabbit连接
        Connection connection = RabbitMqUtil.getConnection();
        //创建通道连接
        final Channel channel = connection.createChannel();
        //表示该消费者每次只能消费处理一个消息
        channel.basicQos(1);
        //通道绑定队列
        /**
         * 参数1 queue:队列名称,如果队列不存在则自动创建
         * 参数2 durable:用来定义队列是否需要持久化,true  需要持久化;false  不需要持久化
         * 参数3 exclusive:定义是否独占队列,true  是;false 否
         * 参数4 autodelete:消费完成后是否需要自动删除队列,true 是;false 否
         * 参数5:自定义的额外附加参数
         */
        channel.queueDeclare("work",true,false,false,null);
        //消费消息
        /**
         * 参数1:队列名称,即将要消费哪一个队列的消息
         * 参数2:开启消息的自动确认机制
         * 参数3:消费时的回调接口,常用来处理业务逻辑,一般都是Consumer接口的实现类,此处用默认的DefaultConsumer
         */
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者-1:" + new String(body));
                //手动确认
                /**
                 * 参数1:手动确认的标识
                 * 参数2:是否开启多个消息同时确认机制,false 每次确认1个
                 */
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }

}

消费者2:

package workQueues;

import com.rabbitmq.client.*;
import utils.RabbitMqUtil;

import java.io.IOException;

/**
 * @Author: yangli@elane.cn
 * @Despriction:
 * @Package: workQueues
 * @Date:Created in 2020/3/23 9:05
 * @Modify By:
 */
public class Consumer2 {

    public static void main(String args[]) throws IOException {
        //通过公用方法获取rabbit连接
        Connection connection = RabbitMqUtil.getConnection();
        //创建通道连接
        final Channel channel = connection.createChannel();
        //表示该消费者每次只能消费处理一个消息
        channel.basicQos(1);
        //通道绑定队列
        /**
         * 参数1 queue:队列名称,如果队列不存在则自动创建
         * 参数2 durable:用来定义队列是否需要持久化,true  需要持久化;false  不需要持久化
         * 参数3 exclusive:定义是否独占队列,true  是;false 否
         * 参数4 autodelete:消费完成后是否需要自动删除队列,true 是;false 否
         * 参数5:自定义的额外附加参数
         */
        channel.queueDeclare("work",true,false,false,null);
        //消费消息
        /**
         * 参数1:队列名称,即将要消费哪一个队列的消息
         * 参数2:开启消息的自动确认机制
         * 参数3:消费时的回调接口,常用来处理业务逻辑,一般都是Consumer接口的实现类,此处用默认的DefaultConsumer
         */
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-2:" + new String(body));
                //手动确认
                /**
                 * 参数1:手动确认的标识
                 * 参数2:是否开启多个消息同时确认机制,false 每次确认1个
                 */
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }

}

控制台打印-----

消费者1控制台打印:

消费者2控制台打印:

可以看到由于消费者1我们进行了线程阻塞来模拟网络延迟等现象,而消费者二正常执行,最终结果,消费者1只消费了一个,而消费者2消费了9条消息,最终实现了能者多劳的效果,满足业务场景。

基于深度强化学习的柔性作业车间动态调度 在追求敏捷和灵活的生产调度方面,处理不可预测的动态事件的能力变得越来越重要。与此同时,生产系统中的网络-物理融合产生了大量需要实时挖掘和分析的工业数据。为了便于这种实时控制,本研究提出了一种分层分布式的体系结构来解决动态柔性作业车间调度问题。采用双深度Q网络算法(DDQN)训练调度智能体,捕捉生产信息与调度目标之间的关系,为具有恒定任务到达的柔性作业车间实时做出调度决策。为了处理动态调度中问题的可变规格说明,提出了专门的状态和动作表示法。此外,还提出了一种代理奖励整形技术(surrogate reward 阅读详情

相关推荐

Bioconductor核心包(GO.db等)安装失败排查指南:从版本冲突到网络优化

本文详细解析了Bioconductor核心包(如GO.db)安装失败的常见原因及解决方案,包括版本冲突、网络问题和依赖关系。通过版本检查、镜像配置和依赖管理等方法,帮助用户高效解决安装难题,提升R语言生物信息学分析的工作效率。

weixin_29066781的博客 427

【RabbitMQ教程】Work queues 工作队列模式

将‘work queues工作队列模式’单独抽出来细讲,目的是借助这个模式好好讲一下rabbitmq的‘轮询分发’和‘公平分配’。

qq_43783527的博客 1279

Zabbix-01简单导入MIB文件并测试

这里写自定义目录标题安装 MIB文件启用MIB文件测试MIB文件 MIB文件 MIB代表管理信息库。 MIB文件允许您使用OID(对象标识符)的文本表示。 ##例如: ifHCOutOctets 是OID【1.3.6.1.2.1.31.1.1.1.10】的文本表示 安装 MIB文件 在基于Debian的系统上: # apt install snmp-mibs-downloader # download-mibs 在基于RedHat的系统上: # yum install net-snmp-libs 启用M

lokibaba的博客 9180

RabbitMQ 6种队列模式——Work queues工作队列

上一篇博文,详细模拟了简单队列模式, 简单队列有个缺点,简单队列是一一对应的关系,即点对点,一个生产者对应一个消费者,按照这个逻辑,如果我们有一些比较耗时的任务,也就意味着需要大量的时间才能处理完毕,显然简单队列模式并不能满足我们的工作需求。 工作队列模式概念 一个消息生产者,一个交换器,一个消息队列,多个消费者。同样也称为点对点模式 当消息生产速度远大于消费速度时,消息队列就会爆满,从而导致服务器不可用,那么我们就要设置多个消费者,共同进行消费。 但是不同的消费者处理消息的快慢也不.

祝我飞黄腾达 1129

新手必看:LiteRadio 2c SE遥控器从开箱到飞行的完整指南(附常见问题解答)

本文为新手提供LiteRadio 2c SE遥控器的完整使用指南,涵盖从开箱到首飞的20个关键步骤。详细介绍了遥控器的功能设置、与无人机的对频技巧以及首飞注意事项,帮助用户快速掌握飞行控制,避免常见错误。特别适合无人机初学者阅读。

weixin_29209801的博客 381

API安全攻防实战:从信息搜集到漏洞利用的完整路径

本文详细解析了API安全攻防实战的全过程,从信息搜集到漏洞利用,涵盖了渗透测试的核心技巧和工具使用。通过真实案例展示如何发现和利用API漏洞,如HTTP方法滥用、内容类型转换攻击等,并提供企业级防御策略和测试心得,帮助安全研究人员提升API安全防护能力。

weixin_30394981的博客 435

RabbitMQ的第2种消息模型:work模式

work消息模型【能者多劳】 不同消费者可能消费消息的速度不一样,work模型通过手动确认机制实现能者多劳 多个消费者通过自动确认机制 工具类 public class RabbitMQUtil { private static ConnectionFactory connectionFactory; static { //创建连接工厂 connectionFactory = new ConnectionFactory(); //设置Rabb

user2025的博客 1639

加权余量法求解偏微分方程

加权余量法(Weighted Residual Method)是一种数值方法,用于求解偏微分方程(PDEs)。其基本思想是将偏微分方程的残差(或余量)通过加权函数加权,并使加权余量在定义域上为零,从而形成一组代数方程进行求解。

leizhengshenglzs的博客 1793

RabbitMQ基础入门(三)work消息模型

RabbitMQ基础入门(二)work消息模型一、生产者代码二、消费者代码1. 轮询2. 公平(能者多劳) work消息模型称为工作队列或者竞争消费者模式。 在上一篇文章中,我们讲了简单消息模型,从一个队列中发送并接收消息。在这里,我们将创建一个工作队列,在多个工作者之间分配耗时任务。 工作队列,又称为任务队列。主要是想就是避免执行资源密集型任务时,必须等待它执行完成。相反,我们将稍后完成任务,将它封装为消息,并将其发送发到队列。在后台运行的工作进程将获取任务并最终执行作业。当运行许多消费者时,任务将在他们

weixin_44283682的博客 414

1、CUDA 编程基础

GPU计算的发展历程与重要性。首先回顾了计算机技术的发展,特别是摩尔定律的影响,强调了计算能力的快速提升。然而,随着晶体管尺寸的缩小和频率的停滞,单线程性能增长放缓。为了继续提升性能,多核处理器开始普及,促使软件开发者开始考虑并行计算。介绍了延迟导向设计和吞吐量导向设计的概念,CPU和GPU分别代表了这两种设计方法。GPU是吞吐量导向的,拥有众多弱小的ALU,通过流水线处理提高算术吞吐量。GPU的成功在于其高并行性和高吞吐量,以及能够分摊高昂的固定成本的大量销售额。

Justinyh的博客 581

152:vue+leaflet 判断一个点是否在一个电子围栏内

本文介绍了一个基于Vue+Leaflet的示例,演示如何判断点是否在电子围栏内。作者大剑师兰特(优快云知名博主)展示了使用polygon.getBounds().contains(latlng)方法检测点与多边形边界的关系。代码仅需80行,通过点击地图触发判断逻辑,结果显示提示信息。该技术可广泛应用于地理围栏、位置服务等场景,需要安装turf依赖。文章提供了完整源码和配置说明,适合GIS开发者学习参考。

大剑师兰特的GIS世界 759

RabbitMQ消息模型之Work Queues

,任务模型,也是官网给出的第二个模型,使用的交换机类型是直连direct,也是默认的交换机类型。当消息处理比较耗时的时候,可能生产消息的速度会远远大于消息的消费速度。长此以往,消息就会堆积越来越多,无法及时处理。这里使用的生产者和消费者都是一样的,区别是消费者同时运行了两个进程。队列中的消息一旦消费,就会消失,因此任务是不会被重复执行的。可以看到,消息被轮训均匀分配给了两个消费者。Work Queues,也被称为(

学而时习之,不亦说乎?温故而知新,可以为师矣! 693

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

消息队列RabbitMQ核心:简单(Hello World)模式、队列(Work Queues)模式、发布确认模式

消息队列RabbitMQ提供了六种工作模式:简单模式、work queues、发布订阅模式、路由模式、主题模式、发布确认模式。本文将介绍前三种工作模式。所有的案例代码都是使用Java语言实现。本工作模式主要设计三个角色:生产者、MQ,消费者。由生产者将数据发送到MQ消息队列中,再通过MQ将消息数据转发到消费者,完成一次整体消息数据的通信。1.创建Java maven工程,添加如下依赖 2.消息数据生产者 测试运行,进入后台管理页面,名为的队列中总共有一条消息,且已经准备好等待消费!接下来编写消费者代码进行消

我这么骄傲的一个人。 9981

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

RabbitMQ中的Work Queues模式

Work Queues 模式(也称为任务队列模式)是一种消息传递模式,用于在多个消费者之间分配任务。在这种模式下,生产者将任务(消息)发送到队列中,多个消费者从队列中获取任务并进行处理。每个任务只会被一个消费者处理,从而实现负载均衡。负载均衡:多个消费者可以并行处理任务,从而提高系统的处理能力。解耦:生产者和消费者之间通过队列进行通信,彼此之间不需要直接交互。异步处理:任务可以异步处理,生产者不需要等待任务完成即可继续执行其他操作。

weixin_39033358的博客 1507

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

RabbitMQ Work Queues (工作队列模式) 使用案例

工作队列模式

明志の博客 5788

RabbitMQ通讯方式第二讲:Work Queues

1.1官网中的图片:通过官网里的图片,我们可以看到Word Queues 与Hello World 的区别,这里的消费者增加,但是时多个消费者消费单个队列,在这里我们依然要注意,这里面使用的是默认的交换机,并不是直接连接的队列。在消费者二的代码里面,线程休眠了1000ms 显然一的速度更快。RabbitMQ是AMQP协议的一个实现者,它是一个开源的消息队列系统,基于AMQP协议实现。注意这里面的交换机是默认的,与队列连接的方式式直接连接。更好的理解每次的连接都是需要交换机的,对于后续的学习是有帮助的。

hdk5855的博客 1282

RabbitMQ Work Queues 消息确认

RabbitMQ Work Queues 简介 Hello Word中只是简单介绍,下面开始重点分析 例如:当我们有复杂需求,我们需要提升效率,毕竟只有一个消费者难免处理不过来,就如官网中所提到的一样——在这篇教程中,将创建一个工作队列(Work Queue),它会发送一些耗时的任务给多个工作者(Worker)。 工作队列(又称:任务队列——Task Queues)是为了避免等待一些占用大量资源、...

十年饮冰,难凉热血 2034

RabbitMQ-Work Queues

RabbitMQ的Work Queues模型通过多个消费者绑定队列实现消息分发,默认采用轮询方式。为确保消息可靠传输,提供手动/自动应答机制。

zl979899的博客 673

RabbitMQ之Work Queues模式

RabbitMQ之Work Queues模式 本下面的文字代码原来自官网???? 附上链接–》RabbitMq 之 Work Queues 看完这篇文章对你绝对有好处。 好处一、你可以了解透 Work Queues模式,本文章内容98%以上都是来自官网。通俗易懂。 好处二、看完文章,你再点击上面的官网连接,进去看一看官网的文档,你会发现读官方文档不是难事。 手敲1w多个字,要个赞应该不过分吧。???? 先附上所有的模式 当前文章所讲的模式对应下图 注意:下文说的 “消息"与"任务”、“woker"

jianghuchuang的博客 492

RabbitMQ(02)——RabbitMQ的Work消息模型

文章目录RabbitMQ——RabbitMQ的Work消息模型1、Work消息模型之发布者发布消息2、Work消息模型之消费者消费消息3、消息自动确认机制 RabbitMQ——RabbitMQ的Work消息模型 1、Work消息模型之发布者发布消息 Wlork queues ,也被称为(Task queues ),任务模型。当消息处理比较耗时的时候,可能生产消息的速度会远远大于消息的消费速度。长此以往,消息就会堆积越来越多无法及时处理。此时就可以使用work模型:让多个消费者绑定到一个队列,共同消费队列中的

万里顾一程的博客 1442

go消息队列RabbitMQ - 直连模式与work模式

本文纯属rabbitmq在集中模式下的操作,对于rabbitmq的八股文介绍就不做过多解释了。首先,使用go get安装amqp代码公共部分,所有需要使用到rabbitmq都需要导入amqp。

liu289747235的专栏 1618

rabbitmq工作模式之简单模式、work queues

rabbitmq工作模式之简单模式、work queues1、基础工作1.1、创建用户和虚拟机1.1.1、创建用户1.1.2、创建虚拟机1.2、基础类1.2.1、常量类1.2.2、基础类1.2.3、pom依赖2、简单模式2.1、消费者2.2、生产者2.3、运行测试3、work queues3.1、消费者3.2、生产者3.3、短信实体类3.4、运行测试 1、基础工作 由于目前编写的代码无法给我们自动创建用户和虚拟机,所以需要我们自己先手动创建一下用户和虚拟机。 1.1、创建用户和虚拟机 1.1.1、创建用

qq_41931364的博客 606

【Rabbitmq的消息模型】

如上模型,如果是循环的分发方式,Consumer-1一次性被分到的消息为1,3,5号消息,Consumer-2一次性被分到的消息为2,4,6号消息。如果开启消息自动确认,那么一旦MQ把消息发送给消费者,那么该消息就会立即标记为删除。例如,有编号1-10的消息在MQ中,同时存在两个消费者,则消费者A分到的消息为1,3,5,7,9,消费者B分到的消息为2,4,6,8,10。的分发消息的方式,消费能力强的消费者就会被分到更多的消息,消费能力弱的消费者就会被分到更少的消息,该方式需要作额外设置。

m0_50116974的博客 1798

【消息中间件RabbitMQ 】:简单模式和Work queues

文章目录1、消息提供方2、消息消费方3、提取工具类 在上一篇我们成功在服务器上搭建了 RabbitMQ,那就相当于中间红框部分。 想要使用 RabbitMQ,还必须用到两个角色——Produces 和 Consumer 。 1、消息提供方 首先通过 Maven 创建一个 java 项目,然后通过如下步骤完成消息生产者的搭建: 引入依赖:引入 RabbitMQ 所需依赖<dependency> <groupId>com.rabbitmq</groupId>

悦.L的博客 1203

04- 基于SpringAMQP封装RabbitMQ,消息队列的Work模型和发布订阅模型

04- 基于SpringAMQP封装RabbitMQ,消息队列的Work模型和发布订阅模型

欢迎阅读我的博客 1565

RabbitMQ学习(二):Work Queues

说明 通过翻译上篇博文,我们初步了解了RabbitMQ的使用方式,本篇博文将继续翻译官方的第二篇教程Work Queues, 通过本次翻译,我将简单记录梳理有关RabbitMQ的消息派发方式,消息确认机制,消息持久化等内容。 正文 任务队列 在第一篇教程中,我们写了从指定队列中发送和接收消息的程序。在本篇教程中我们将创建一个工作队列,它将被用于在多个消费者中分发耗时任务。 工作队列(又名:任务队...

wds的博客 940
上一篇: RabbitMq 七大发布消息之helloword最简单的发布和消费消息
下一篇: RabbitMq 七大发布消息之Publish/Subscribe 发布/订阅,广播模式
Ai_Ying_Java
博客等级 码龄9年 30粉丝 47原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值