RabbitMQ-Java实现工作队列work_queues

最新推荐文章于 2023-04-01 18:34:17 发布
最新推荐文章于 2023-04-01 18:34:17 发布
阅读量419 收藏
点赞数
分类专栏： 消息队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38905818/article/details/104113926
版权

上篇博文已经实现了RabbitMQ在java中的配置和简单队列的实现，这篇博文将结合现实情况介绍RabbitMQ中的工作队列。

 

工作队列-单个生产者对应多个消费者

新建连接RabbitMQ的工具类utils

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

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

public class utils {
    public  static Connection getConnection() throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        factory.setVirtualHost("/vhost_zdy");
        factory.setUsername("username");
        factory.setPassword("password");

        return factory.newConnection();
    }
}

新建生产者类work_Queue_Send类，假设每20ms产生一条消息

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

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

public class workQueue_Send {
    private final static String QUEUE_NAME = "work_queue";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = utils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        for(int i=0;i<50;i++)//发50条消息
        {
            String msg="msg"+i;
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            Thread.sleep(20);//假设每20ms发送一次消息
            System.out.println("send:"+ msg);
        }
        channel.close();
        connection.close();
    }
}

新建两个消费者类work_Queue_Receive和work_Queue_Receive_2，并且其处理消息的速度分别为2s和1s


import com.rabbitmq.client.*;

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

public class workQueue_Receive {
    private final static String QUEUE_NAME = "work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = utils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [1] Waiting for messages.");

        DefaultConsumer defaultConsumer= new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg = new String(body,"UTF-8");
                System.out.println("[1]receive:"+ msg);
                try {
                    Thread.sleep(2000);//假设消费者1处理时间为2s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1]done:"+ msg);
                }
            }
        };

        channel.basicConsume(QUEUE_NAME,defaultConsumer);

    }

}

import com.rabbitmq.client.*;

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

public class workQueue_Receive_2 {
    private final static String QUEUE_NAME = "work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = utils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [2] Waiting for messages.");

        DefaultConsumer defaultConsumer= new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg = new String(body,"UTF-8");
                System.out.println("[2]receive:"+ msg);
                try {
                    Thread.sleep(1000);//假设消费者2处理时间为1s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[2]done:"+ msg);
                }
            }
        };

        channel.basicConsume(QUEUE_NAME,defaultConsumer);

    }
}

 按照常理，work_Queue_Receive_2应该能够处理更多的消息，但是结果缺与我们的想象不同，两个消费者处理了同样数量的消息，且消费者1处理了奇数序号消息，消费者2处理了偶数序号消息。

     

出现这种情况是因为work_Queue默认使用了轮询分发的模式(Round-Robin)

 

下面讲介绍如何使用公平分发(Fair dispatch)

首先在Send类中设置 prefetchCount = 1

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

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

public class workQueue_Send {
    private final static String QUEUE_NAME = "work_queue";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = utils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //每个消费者发送确认消息之前，消息队列不发送下一个到消费者，即一次只处理一个信息
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);
        for(int i=0;i<50;i++)//发50条消息
        {
            String msg="msg"+i;
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            Thread.sleep(20);//假设每20ms发送一次消息
            System.out.println("send:"+ msg);
        }
        channel.close();
        connection.close();
    }
}
import com.rabbitmq.client.*;

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

public class workQueue_Receive {
    private final static String QUEUE_NAME = "work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = utils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicQos(1);//保证一次只分发一个
        System.out.println(" [1] Waiting for messages.");

        DefaultConsumer defaultConsumer= new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg = new String(body,"UTF-8");
                System.out.println("[1]receive:"+ msg);
                try {
                    Thread.sleep(2000);//假设消费者1处理时间为2s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1]done:"+ msg);
                    //手动回执
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoack=false;
        channel.basicConsume(QUEUE_NAME,autoack,defaultConsumer);

    }

}
import com.rabbitmq.client.*;

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

public class workQueue_Receive_2 {
    private final static String QUEUE_NAME = "work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = utils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicQos(1);//保证一次只分发一个
        System.out.println(" [2] Waiting for messages.");

        DefaultConsumer defaultConsumer= new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg = new String(body,"UTF-8");
                System.out.println("[2]receive:"+ msg);
                try {
                    Thread.sleep(1000);//假设消费者2处理时间为1s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[2]done:"+ msg);
                    //手动回执
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        boolean autoack=false;
        channel.basicConsume(QUEUE_NAME,autoack,defaultConsumer);

    }
}

我们来看下结果，在公平分发模式下，work_Queue_Receive_2处理了更多的信息，符合预期

  

 

消息应答和消息持久化

那么消费者中autoack设置为false与设置为true有什么区别呢？

        boolean autoack=false;
        channel.basicConsume(QUEUE_NAME,autoack,defaultConsumer);

autoack=true（自动确认模式）

一旦rabbitMQ将消息分发给消费者就会从内存中删除此消息，如果消费者未能正常处理消息，有可能造成消息丢失。

autoack=false（手动确认模式）--默认

由消费者通知消息队列，这条消息已经处理完毕，消息队列才删除此消息。

 

那么能不能对消息队列中的数据进行持久化呢？

我们需要在声明一个队列时将第二个参数durable设置为true（值得注意的是对于已存在的未持久化队列是不可以修改为持久化的队列的）

channel.queueDeclare(QUEUE_NAME, true, false, false, null);

更多详情推荐参考官方文档

https://www.rabbitmq.com/tutorials/tutorial-two-java.html

Slayer_Zhao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java工作队列_RabbitMQ入门：工作队列(Work Queue)
weixin_33328904的博客
02-16 180
在上一篇博客《RabbitMQ入门：Hello RabbitMQ 代码实例》中，我们通过指定的队列发送和接收消息，代码还算是比较简单的。假设有这一些比较耗时的任务，按照上一次的那种方式，我们要一直等前面的耗时任务完成了之后才能接着处理后面耗时的任务，那要等多久才能处理完？别担心，我们今天的主角--工作队列就可以解决该问题。我们将围绕下面这个索引展开：什么是工作队列代码准备循环分发消息确认公平分发消...
Rabbitmq学习笔记三：工作队列work queue
Running
01-20 7987
前面我们已经实现了rabbitMQ的helloWorld,这篇中我们将会创建一个工作队列用来在工作者（consumer）间分发耗时任务。 rabbitmq queue work,Round-robin dispatching, Message acknowledgment,Fair Dispatch,Message Durability
amqp java_RabbitMQ基于Spring AMQP的Java Config 简单配置实例
weixin_39729784的博客
02-21 392
本实例尝试针对 Direct exchange、Fanout exchange、Topic exchange三种路由形式进行了消费者和生产者的集中实现，如有不对之处烦请读者指出。1、项目基于Maven，在pom.xml中引入相关依赖。com.rabbitmqamqp-client${rabbitmq.version}org.springframework.amqpspring-rabbit${sp...
Java中Queue和RabbitMQ
weixin_52236586的博客
04-01 246
Java中Queue和RabbitMQ
关于RabbitMQ的几道面试题
LiJianGuo_Mr的博客
09-23 380
1、什么是RabbitMQ？为什么使用RabbitMQ，RabbitMQ好处？ RabbitMQ是一款开源的，Erlang编写的，基于AMQP协议的，消息中间件； 可以用它来：解耦、异步、削峰。 好处就是：解耦、异步、削峰。 2、如何保证RabbitMQ不被重复消费？ 先说为什么会重复消费：正常情况下，消费者在消费消息的时候，消费完毕后，会发送一个确认消息给消息队列，消息队列就知道该消息被消费了，就会将该消息从消息队列中删除； 但是因为网络传输等等故障，确认信息没有传送到消息队列，导致消息队列不知道自己已经
java实现RabbitMQ消息队列
记得笑
04-19 9389
MQ（Message Queue）消息队列，是基础数据结构中“先进先出”的一种数据结构。一般用来解决应用解耦，异步消息，流量削峰等问题，实现高性能，高可用，可伸缩和最终一致性架构。
rabbitmq 7种队列实现java版
01-20
文章目录rabbitmq7种实现方式搭建maven项目引入依赖创建连接简单队列消息生产者消息消费者work queues 工作队列生产者消费者能者多劳（公平分发）：消费能力强则消费更多消息Publish/Subscribe 发布订阅模式生产者...
rabbitMQ简单应用pattern1 Work queues 工作队列模式
07-10
在本文中，我们将深入探讨RabbitMQ中的"Work Queues"（工作队列模式），这是一种优化任务处理效率的重要策略。 工作队列模式，也称为负荷分发或批处理队列，其核心思想是通过将大量任务分解为小型可处理单元，然后...
rabbitmq-server-3.9.13
03-04
6. **工作队列（Work Queues）**：常用于负载均衡，多个消费者可以从队列中获取任务并并行处理。 此外，RabbitMQ还支持多种插件，如用于监控的Management Plugin，可以提供Web界面来查看服务器状态、队列信息、节点...
java实现rabbitMQ 5种工作方式的demo
最新发布
08-04
Java 实现 RabbitMQ 的五种工作方式是理解消息队列在实际应用中的核心知识点。RabbitMQ 是一个广泛使用的开源消息代理，它基于 AMQP（Advanced Message Queuing Protocol）协议，提供可靠的消息传递服务。本示例代码...
rabbitmq根据配置文件动态生成队列
03-23
支持配置文件动态生成队列，创建交换器，根据配置好的对应关系绑定队列和交换器
RabbitMQ-Day1-Code
06-29
7. **工作队列（Work Queues）**：用于负载均衡，一个队列中有多个消费者，消息会被均匀分发给这些消费者。 8. **发布/订阅（Publish/Subscribe）模式**：生产者发布消息到一个主题交换机，消费者订阅特定的路由键...
rabbitmq学习(2)——java实现简单队列
专注写bug
10-24 1224
一、创建maven-java项目 创建maven项目工程，实现简单消息队列操作。 简单消息图示信息解释： P:消息生产者 C 消息消费者 二、依赖引入 <dependencies> <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-clien...
java 动态队列_RabbitMq之动态修改队列参数
weixin_39663378的博客
02-16 741
RabbitMq不支持修改已经存在的队列和交换机参数，可以通过创建失败，捕获异常信息，然后删除原队列或交换机，然后重新创建，以达到修改参数的功能。package com.sky.study.delete;import java.io.IOException;import java.util.concurrent.TimeoutException;import com.rabbitmq.client...
rabbitmq java实例_RabbitMQ消息队列入门篇（环境配置+Java实例+基础概念）
weixin_39743357的博客
02-21 259
转载http://blog.csdn.net/u013142781一、消息队列使用场景或者其好处消息队列一般是在项目中，将一些无需即时返回且耗时的操作提取出来，进行了异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。在项目启动之初来预测将来项目会碰到什么需求，是极其困难的。消息队列在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口...
使用JAVA代码创建RabbitMQ队列以及绑定
qq_29864549的博客
05-06 1291
@Configuration public class RabbitConfig { private final String exchange_name="myexchange"; private final String queue_name="myqueue"; //创建交换机对象 @Bean public Exchange exchange(){ Exchange exchange= ExchangeBuilder.fanoutExchang
基于JavaConfig配置，整合Spring和ActiveMQ
m0_37942215的博客
08-03 302
pom.xml <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <org.springframework.version>4.3.7.RELEASE</org.springframework.version> </properties> <dependencies>
SpringBoot使用JavaConfig配置ActiveMQ
qq_33392133的博客
11-22 4191
SpringBoot读取磁盘或SpringConfig中ActiveMQ的配置信息，使用JavaConfig的方式进行配置，便于多服务共享配置信息，节省开发和维护成本。
java配置mq环境变量_RocketMQ学习-01安装及环境配置
weixin_42365401的博客
02-28 599
安装jdk环境yum install java-1.8.0-openjdkjava -versionwhich java 输出 /usr/bin/java#软连接ls -l /usr/bin/java 输出 /usr/bin/java -> /etc/alternatives/javals -l /etc/alternatives/java --> 输出Java安装目录{JAVA_H...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值