RabbitMQ 工作队列

最新推荐文章于 2025-12-20 11:48:27 发布
原创 最新推荐文章于 2025-12-20 11:48:27 发布 · 151 阅读 · 0 ·
CC 4.0 BY-SA版权
转发请留下原链接哈，否则我会不开心的！！！
文章标签：

#java-rabbitmq #rabbitmq #java

本文介绍了RabbitMQ中的工作队列概念，包括轮询分发和公平分发两种方式。在轮询分发中，消息均匀分配给多个消费者，而公平分发则根据消费者处理速度动态调整。文中通过Java代码示例展示了这两种分发方式的实现，并讨论了启动消费者和生产者的时间顺序对消息处理的影响。
一、工作队列

官方文档：http://www.rabbitmq.com/tutorials/tutorial-two-java.html

简单队列不足：不支持多个消费者

即一个生产者可以对应多个消费者同时消费，相比简单队列支持多消费者。因为实际工作中，生产者服务一般都是很简单的业务逻辑处理之后就发送到队列， 消费者接收到队列的消息之后，进行复杂的业务逻辑处理，所以一般都是多个消费者进行处理。如果是一个消费者进行处理，那么队列会积压很多消息。

工作队列分两种情况：

轮询分发

不管消费者处理速度性能快慢，每个消费者都是按顺序分别每个拿一个的原则，比如3个消费者, 
消费者1拿1个，然后消费者2拿一个，然后消费者3拿一个，然后消费者1开始拿，即使中间有消费
者已经处理完了，也必须等待其他消费者都拿完一个才能消费到。

公平分发

根据消费者处理性能，性能好的消费的数据量多，性能差的消费的数据量少。

如上所示，如果配置有用户名密码以及vhost，则配置即可。
二、轮询分发
一个生产者，两个消费者，其中消费者处理只要1s，消费者2 处理需要2s
生产者
package com.rabbitmq.work;

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

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

/**
 * 生产者
 */
public class Send {

    private static final String QUEUE_NAME = "test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 获取连接
        Connection connection = ConnectionUtil.getConnection();
        // 从连接开一个通道
        Channel channel = connection.createChannel();
        // 申明这个通道连接的队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        for (int i = 0; i < 20; i++) {
            String message = "Hello RabbitMQ " + i;
            // 发送消息
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
        }

        // 关闭通道和连接
        channel.close();
        connection.close();
    }

}
消费者1
package com.rabbitmq.work;

import com.rabbitmq.client.*;
import com.rabbitmq.util.ConnectionUtil;

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

/**
 * 消费者
 */
public class Recv1 {

    private static final String QUEUE_NAME = "test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {

        // 获取连接
        Connection connection = ConnectionUtil.getConnection();

        // 打开通道
        Channel channel = connection.createChannel();

        // 申明要消费的队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 创建一个回调的消费者处理类
        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);
                System.out.println(" [1] Received '" + message + "'");

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(" [1] done ");
                }
            }
        };

        // 消费消息
        channel.basicConsume(QUEUE_NAME, true, consumer);

    }

}
消费者2
package com.rabbitmq.work;

import com.rabbitmq.client.*;
import com.rabbitmq.util.ConnectionUtil;

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

/**
 * 消费者
 */
public class Recv2 {

    private static final String QUEUE_NAME = "test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {

        // 获取连接
        Connection connection = ConnectionUtil.getConnection();

        // 打开通道
        Channel channel = connection.createChannel();

        // 申明要消费的队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 创建一个回调的消费者处理类
        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);
                System.out.println(" [2] Received '" + message + "'");

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(" [2] done ");
                }
            }
        };

        // 消费消息
        channel.basicConsume(QUEUE_NAME, true, consumer);

    }

}
测试

  1. 先启动两个消费者Recv、Recv2

  1. 再启动生产者Send

生产者控制台：

 [x] Sent 'Hello RabbitMQ 0'
 [x] Sent 'Hello RabbitMQ 1'
 [x] Sent 'Hello RabbitMQ 2'
 [x] Sent 'Hello RabbitMQ 3'
 [x] Sent 'Hello RabbitMQ 4'
 [x] Sent 'Hello RabbitMQ 5'
 [x] Sent 'Hello RabbitMQ 6'
 [x] Sent 'Hello RabbitMQ 7'
 [x] Sent 'Hello RabbitMQ 8'
 [x] Sent 'Hello RabbitMQ 9'
 [x] Sent 'Hello RabbitMQ 10'
 [x] Sent 'Hello RabbitMQ 11'
 [x] Sent 'Hello RabbitMQ 12'
 [x] Sent 'Hello RabbitMQ 13'
 [x] Sent 'Hello RabbitMQ 14'
 [x] Sent 'Hello RabbitMQ 15'
 [x] Sent 'Hello RabbitMQ 16'
 [x] Sent 'Hello RabbitMQ 17'
 [x] Sent 'Hello RabbitMQ 18'
 [x] Sent 'Hello RabbitMQ 19'

Process finished with exit code 0

消费者1：

 [1] Received 'Hello RabbitMQ 0'
 [1] done 
 [1] Received 'Hello RabbitMQ 2'
 [1] done 
 [1] Received 'Hello RabbitMQ 4'
 [1] done 
 [1] Received 'Hello RabbitMQ 6'
 [1] done 
 [1] Received 'Hello RabbitMQ 8'
 [1] done 
 [1] Received 'Hello RabbitMQ 10'
 [1] done 
 [1] Received 'Hello RabbitMQ 12'
 [1] done 
 [1] Received 'Hello RabbitMQ 14'
 [1] done 
 [1] Received 'Hello RabbitMQ 16'
 [1] done 
 [1] Received 'Hello RabbitMQ 18'
 [1] done

消费者2：

 [2] Received 'Hello RabbitMQ 1'
 [2] done 
 [2] Received 'Hello RabbitMQ 3'
 [2] done 
 [2] Received 'Hello RabbitMQ 5'
 [2] done 
 [2] Received 'Hello RabbitMQ 7'
 [2] done 
 [2] Received 'Hello RabbitMQ 9'
 [2] done 
 [2] Received 'Hello RabbitMQ 11'
 [2] done 
 [2] Received 'Hello RabbitMQ 13'
 [2] done 
 [2] Received 'Hello RabbitMQ 15'
 [2] done 
 [2] Received 'Hello RabbitMQ 17'
 [2] done 
 [2] Received 'Hello RabbitMQ 19'
 [2] done

可以发现消费者1 消费的数字全是整数，消费者2消费的全是奇数。

那么如果我事先启动三个消费者了，那么结果如何了？

因为20/3 除不了，如果消费者1,2,3按顺序启动，那么消费者1, 2会消费7条数据，消费者3消费6条，其中

消费者1 消费 0, 3, 6, 9, 12, 15, 18
消费者2 消费 1, 4, 7, 10, 13, 16, 19
消费者3 消费 2, 5, 8, 11, 14, 17

注意点：

如果生产者一次性发送完消息之后，再依次启动消费者1, 2, 3， 之后只有消费者1 能消费到数据，消费者都启动之后，再生产的消息就会轮询分发到消费者1, 2, 3

三、公平分发

官方示例图：

因为生产者发送消息到队列之后，队列不知道消费者有没有处理完，所以多个消费者同时订阅同一个Queue中的消息，Queue中的消息会被平摊给多个消费者。为了实现公平分发，我们需要告诉队列，每次发一个给我，然后我反馈给你我有没有处理完，处理完了你再发一条给我。

在默认轮询分发的基础上，要实现公平分发，需要两点：

限制发送给同一个消费者不得超过1条消息，在这个消费者确认消息之前，不会发送下一条消息给这个消费者

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

默认自动应答改成手动应答


关闭自动应答
boolean autoAck = false;
channel.basicConsume(QUEUE_NAME, autoAck, consumer);

手动应答
channel.basicAck(envelope.getDeliveryTag(), false);

DeliveryTag 用来标识信道中投递的消息， RabbitMQ 推送消息给 Consumer 时，会附带一个 Delivery Tag，以便 Consumer 可以在消息确认时告诉 RabbitMQ 到底是哪条消息被确认了。
生产者
package com.rabbitmq.workfair;

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

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

/**
 * 生产者
 */
public class Send {

    private static final String QUEUE_NAME = "test_workfair_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 获取连接
        Connection connection = ConnectionUtil.getConnection();
        // 从连接开一个通道
        Channel channel = connection.createChannel();
        // 申明这个通道连接的队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //服务器将传递的最大消息数，如果无限制则为 0
        channel.basicQos(1);

        for (int i = 0; i < 20; i++) {
            String message = "Hello RabbitMQ " + i;
            // 发送消息
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
            try {
                Thread.sleep(i*100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 关闭通道和连接
        channel.close();
        connection.close();
    }

}
消费者1
package com.rabbitmq.workfair;

import com.rabbitmq.client.*;
import com.rabbitmq.util.ConnectionUtil;

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

/**
 * 消费者
 */
public class Recv1 {

    private static final String QUEUE_NAME = "test_workfair_queue";

    public static void main(String[] args) throws IOException, TimeoutException {

        // 获取连接
        Connection connection = ConnectionUtil.getConnection();

        // 打开通道
        final Channel channel = connection.createChannel();

        // 申明要消费的队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 这样RabbitMQ就会使得每个Consumer在同一个时间点最多处理一个Message。
        // 换句话说，在接收到该Consumer的ack前，他它不会将新的Message分发给它。
        channel.basicQos(1);

        // 创建一个回调的消费者处理类
        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);
                System.out.println(" [1] Received '" + message + "'");

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(" [1] done ");
                    //手动应答:当处理完消息回复服务器
                    channel.basicAck(envelope.getDeliveryTag(), false);
                    //multiple – true 以确认所有消息，包括提供的交付标签； false 仅确认提供的交付标签。
                    //void basicAck(long deliveryTag, boolean multiple) throws IOException;

                }
            }
        };

        //关闭自动应答
        boolean autoAck = false;
        // 消费消息
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);

    }

}
消费者2
RabbitMQ消息队列的工作模式
江晓龙的博客
06-26 1万+
使用Routing路由模式时，Exchange与队列也不再进行绑定了，而是通过声明一个RoutingKey，通过这个key将消息路由到特定的队列中，因此在消息发送方发消息时，就需要指定消息的RoutingKey，Routing根据消息中的RoutingKey进行判断，当消息中的RoutingKey与队列中的RoutingKey完全一致时，消息才能正常存储到队列中，最后被消费者处理。简而言之，使用Topic模式后，可以对消息数据中的RoutingKey进行通配符匹配，将满足条件的消息数据分发到特定的队列中。
RabbitMQ Work Queues (工作队列模式) 使用案例
小蜗牛的珍贵百宝箱
02-11 1142
RabbitMQ 是一个消息队列（Message Queue）系统，它使用队列来存储消息，供消费者（Consumer）消费。在RabbitMQ的工作队列模式（Work Queues）中，多个消费者可以从队列中获取任务并并行处理，从而实现负载均衡。生产者（Producer）将任务放入队列中，而消费者会不断地从队列中取出任务进行处理。工作队列的特点是消息会被均匀分配给多个消费者，确保任务负载的均衡。在这种模式下，任务会被逐个消费，且如果有多个消费者，RabbitMQ 会将消息轮流发送给每个消费者。
详解RabbitMQ工作模式之工作队列模式
.
04-28 1万+
详解RabbitMQ工作模式之工作队列模式。
详解SpringBoot整合RabbitMQ之工作队列模式
.
05-26 1万+
详解SpringBoot整合RabbitMQ之工作队列模式。
Rabbitmq 镜像队列
qq_41893505的博客
12-07 1681
RabbitMQ 的镜像队列集群（Mirrored Queues Cluster）是实现高可用性的一种模式，它通过在集群中的多个节点之间复制队列，确保消息在集群的某些节点宕机时不会丢失，并且队列仍然可以正常工作。在 Spring Boot 项目中配置 RabbitMQ 镜像队列（Mirrored Queues）进行消息的收发，需要在 RabbitMQ 中设置队列为高可用队列，并在 Spring Boot 应用中进行相应的配置。同时，这个队列会被复制到集群中的其他节点，这些副本称为镜像（Mirrors）。
RabbitMQ延迟队列
学习学习学习
08-25 9068
RabbitMQ 延迟队列使用场景消息延迟推送的、预支付订单创建成功后，30分钟后还未完成支付则自动修改订单状态，自动取消订单、用户注册成功后，如果3天没有登录则进行短信提醒、优惠券过期前发送短信进行提醒等业务场景...
Rabbitmq死信队列
暗武逢天的博客
11-28 1万+
死信队列概念 死信，就是无法被消费的消息，一般来说, producer将消息投递到broker或者直接到queue里了, consumer从queue取出消息 进行消费,但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信， 有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使用到RabbitMQ的死信队列机制，当消息消费发生异常时， 将消息投入死信队列中.还有比如说:用户在商城下单成功并点击去支付后在指定时间未支付时自动失效 死
RabbitMQ延迟队列（重要）
qq_46112274的博客
11-06 3709
RabbitMQ延迟队列
RabbitMQ 延迟队列详解
热门推荐
dingd1234的博客
05-29 2万+
一、延迟队列概念 延迟队列存储的对象时对应的延迟消息，所谓“延迟消息”是指当消息呗发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费。 二、延迟队列使用场景 1、订单在十分钟之内未支付则自动取消 2、新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。 3、用户注册成功后，如果三天内没有登录则进行短信提醒。 4、用户发起退款后，如果三天内没有得到处理则通知相关运营人员。 5、预定会议后，需要在预定时间点前十分钟通知各个与会人员参加会议。 这些场景都有一个特点
RabbitMQ仲裁队列高可用架构解析
虽非技冠群英首，愿与同道共长歌； 大鹏一日同风起，扶摇直上九万里；
05-28 1714
RabbitMQ仲裁队列高可用架构解析
rabbitMQ工作队列共12页.pdf.zip
10-30
在本篇文档中，我们将深入探讨RabbitMQ的工作队列（Work Queues）模式，该模式是其核心特性之一，常用于处理大量并发任务。 首先，让我们理解什么是工作队列。工作队列，又称为负载均衡队列，旨在将大量任务分发到...
RabbitMQ延迟队列及消息延迟推送实现详解
08-25
RabbitMQ 延迟队列及消息延迟推送实现详解 RabbitMQ 延迟队列及消息延迟推送实现详解是指在 RabbitMQ 中实现消息延迟推送的功能，即在指定的时间后推送消息到目标队列中。这种机制在实际应用中非常有价值，如在淘宝...
rabbitmq 工作队列 java 实现
08-23
本篇文章将详细探讨如何在Java环境中实现基于RabbitMQ的工作队列，以及相关的特性如消息确认、消息持久化和公平调度。 首先，我们来了解什么是工作队列。工作队列（也称为任务队列）主要用于处理那些耗时的任务，...
中间件及框架漏洞详解（Nginx、Apache、Tomcat、Redis、Zookeeper、RabbitMQ、Kafka等）
土豆片的博客
12-19 655
①log4j和log4j2log4j是 Apache 的一个开源日志库，是一个基于 Java 的日志记录框架。log4j2是log4j 的后继者，其中引入了大量丰富的特性，可以控制日志信息输送的目的地为控制台、文件、GUI 组建等，被应用于业务系统开发，用于记录程序输入输出日志信息，log4j2 中存在JNDI注入漏洞，当程序记录用户输入的数据时，即可触发该漏洞，成功利用该漏洞可在目标服务器上执行任意代码。②什么是JNDI。
Java-204 RabbitMQ Connection/Channel 工作流程：AMQP 发布消费、抓包帧结构与常见坑
永远好奇 无限进步
12-19 756
AMQP Channel，实现多路复用、资源隔离与更低的连接开销。围绕 Java 客户端常用 API（channel.exchangeDeclare、queueDeclare、basicPublish、basicConsume）解释其与 AMQP 命令（Exchange.Declare、Queue.Declare、Basic.Publish、Basic.Consume）的对应关系，并给出“高并发/高吞吐”下从单 Connection 多 Channel 过渡到多 Connection 分流的配置思路。
Java-205 RabbitMQ 工作模式实战：Work Queue 负载均衡 + fanout 发布订阅（手动ACK/QoS/临时队列）
永远好奇 无限进步
12-19 1245
Work Queue 通过同一队列启动多个消费者实现负载均衡，配合 manual ack（basicAck/basicNack） 与 basicQos(prefetch=1) 避免消息“瞬间堆给某个消费者”，提升公平分发与失败可重试能力。发布订阅基于 fanout exchange 广播机制：生产者发到 Exchange，RabbitMQ 将消息复制到所有绑定队列；消费者常用 临时队列（exclusive/auto-delete） 订阅日志/事件流。文中同时说明 未命名交换器（default exchang
Java-202 RabbitMQ 生产安装与容器快速启动：Erlang 兼容、RPM 部署与常用命令
永远好奇 无限进步
12-18 854
RPM 做生产部署，以及使用 Docker Compose 拉起 rabbitmq:3.8.x-management 作为学习环境。重点覆盖 Erlang 运行时（Erlang/OTP 23.x）与 RabbitMQ 3.8/3.9 等版本兼容性检查、依赖包（socat、openssl、logrotate）准备、rabbitmq_management 插件启用、systemctl 启停与开机自启、rabbitmqctl 用户/权限/标签管理（administrator、monitoring、policyma
Java-207 RabbitMQ Direct 交换器路由：RoutingKey 精确匹配、队列多绑定与日志分流实战
最新发布
永远好奇 无限进步
12-20 854
routingKey 与 bindingKey 的精确匹配机制，并用日志分流场景给出可直接复用的 Java（amqp-client）示例：生产者向 direct_logs 按 severity（info/warn/error）发布消息，消费者通过 queueBind 绑定一个或多个 bindingKey 实现选择性消费。内容覆盖 direct 与 fanout 的边界、队列多重绑定导致“一条消息进多队列”的行为，以及 demo 中匿名临时队列、autoAck=true 的可靠性含义。适合 2025 年
Java-206 RabbitMQ 发布订阅（fanout）Java 实战：推/拉模式、ACK 与绑定排错全梳理
永远好奇 无限进步
12-20 500
发布订阅（Publish/Subscribe）模型，使用 fanout exchange 实现“广播式”消息分发：生产者通过 exchangeDeclare 创建广播交换机 logs，消费者启动时创建临时队列并 queueBind 绑定到交换机，实现多订阅者各收一份。并对比推模式（basicConsume + DeliverCallback/DefaultConsumer）与拉模式（basicGet）在实时性、吞吐、资源控制与批处理上的取舍，指出 autoAck 可能导致异常场景丢消息，应结合业务选择手动
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

黑石课堂

请给我打钱！！！谢谢，不客气！

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

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

打赏作者

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

抵扣说明：

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

余额充值