RabbitMQ实战教程(三) : 工作队列

最新推荐文章于 2024-06-24 20:50:35 发布
最新推荐文章于 2024-06-24 20:50:35 发布
阅读量525 收藏 4
点赞数 2
分类专栏： RabbitMQ实战教程 文章标签： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37653556/article/details/82753995
版权

RabbitMQ实战教程(三) : 工作队列

1. 工作队列

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

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

工作队列分为两种情况:

  • 轮询分发

    在默认情况下, RabbitMQ将逐个发送消息到在序列中的下一个消费者(而不考虑每个任务处理的时长等等,且是提前一次性分配,并非一个一个的分配) . 平均每个消费者获取相同数量的消息. 这种分发消息机制称为 轮询分发

    当消息进入队列 ,RabbitMQ就会分发消息 .它不看消费者的应答的数目 ,也不关心消费者处理消息的能力,只是盲目的将第n条消息发给第n个消费者

  • 公平分发

    根据消费者处理性能,性能好的消费的数据量多,性能差的消费的数据量少 .这种分发消息机制称为 公平分发

2. 轮询分发

一处生产者,两个消费者, 其中消费者1处理需要 1s,消费者2处理需要2s .

2.1 连接工具类
package com.makesailing.neo.utils;

import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # RabbitMQ连接工具类
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 14:38
 */
public class ConnectionUtils {

  public static final String host = "127.0.0.1";

  public static final Integer port = 5672;

  public static Connection getConnection() throws IOException, TimeoutException {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost(host);
    connectionFactory.setPort(port);
    // 如果有 用户名 密码 vhost 配置即可
    connectionFactory.setUsername("jamie");
    connectionFactory.setPassword("123456");
    connectionFactory.setVirtualHost("/simple");
    return connectionFactory.newConnection();
  }
}
2.2 生产者
package com.makesailing.neo.polling.provider;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * #
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 16:31
 */
public class Send {

  public static final String QUEUE_NAME = "test_work_polling_queue";

  public static void main(String[] args) throws IOException, TimeoutException {
    // 1.创建连接
    Connection connection = ConnectionUtils.getConnection();
    // 2.创建信道
    Channel channel = connection.createChannel();
    // 3.声明信道中的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);

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

    // 关闭信道与连接
    channel.close();
    connection.close();
  }
}
2.3 消费者1
package com.makesailing.neo.polling.consumer;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # 轮询分发 消费者1
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 16:41
 */
public class Recvice1 {

  public static final String QUEUE_NAME = "test_work_polling_queue";

  public static void main(String[] args) throws IOException, TimeoutException {
    // 1.创建连接
    Connection connection = ConnectionUtils.getConnection();
    // 2.创建信道
    Channel channel = connection.createChannel();
    // 3.声明信道中的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    // 4. 创建一个回调类
    Consumer consumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
          throws IOException {
        super.handleDelivery(consumerTag, envelope, properties, body);
        String message = new String(body, "UTF-8");
        // 工作
        doWork(message);
      }
    };

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

  }

  private static void doWork(String message) {
    System.out.println(" [1] Received '" + message + "', 处理业务中...");
    // 模仿消费者处理业务的时间，也让其他消费者有机会获取到消息，实际开发中不需要，这里只是模拟
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      System.out.println("[1] done");
    }
  }
}
2.4 消费者2
package com.makesailing.neo.polling.consumer;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # 轮询分发 消费者2
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 16:54
 */
public class Recvice2 {
  public static final String QUEUE_NAME = "test_work_polling_queue";

  public static void main(String[] args) throws IOException, TimeoutException {
    // 1.创建连接
    Connection connection = ConnectionUtils.getConnection();
    // 2.创建信道
    Channel channel = connection.createChannel();
    // 3.声明信道中的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    // 4. 创建一个回调类
    Consumer consumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
          throws IOException {
        super.handleDelivery(consumerTag, envelope, properties, body);
        String message = new String(body, "UTF-8");
        // 工作
        doWork(message);
      }
    };

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

  }

  private static void doWork(String message) {
    System.out.println(" [2] Received '" + message + "', 处理业务中...");
    // 模仿消费者处理业务的时间，也让其他消费者有机会获取到消息，实际开发中不需要，这里只是模拟
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      System.out.println("[2] done");
    }
  }
}
2.5 测试

为了能让两个消费者均分消息,需要先启动两个消费者,再启动生产者.

生产者:

消费者1 :

消费者2：

2.6 总结

可以发现消费者1的数字全是偶数,消费者2的数字全是奇数,证明轮询分发,不管消费者性能的强弱都能接受均发的消费.

3. 公平分发

  • 从 轮询分发 可以看出消费者2处理时长1s ,消费者2处理时长2s ,很可能出现当消费者1才处理几条时,消费者2就已经处理完了,这样消费者2就处于空闲状态,而消费者1却忙的跟狗似的 .为了解决这种现象,让性能好的消费者干完了帮助性能差的消费者分担点任务,采用公平分发 .

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

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

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

  2. 默认自动应答改为手动应答

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

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

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

3.1 生产者
package com.makesailing.neo.fair.provider;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * #
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 16:31
 */
public class Send {

  public static final String QUEUE_NAME = "test_work_fair_queue";

  public static void main(String[] args) throws IOException, TimeoutException {
    // 1.创建连接
    Connection connection = ConnectionUtils.getConnection();
    // 2.创建信道
    Channel channel = connection.createChannel();
    // 3.声明信道中的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);


    for (int i = 0; i < 20; i++) {
      String meassage = "Hello RabbitMQ " + i;
      //发送消息
      channel.basicPublish("", QUEUE_NAME, null, meassage.getBytes());
      System.out.println("Send 发送消息" + meassage);

    }

    // 关闭信道与连接
    channel.close();
    connection.close();
  }
}
3.2 消费者1
package com.makesailing.neo.fair.consumer;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # 轮询分发 消费者1
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 16:41
 */
public class Recvice1 {

  public static final String QUEUE_NAME = "test_work_fair_queue";

  public static void main(String[] args) throws IOException, TimeoutException {
    // 1.创建连接
    Connection connection = ConnectionUtils.getConnection();
    // 2.创建信道
    Channel channel = connection.createChannel();
    // 3.声明信道中的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    // 设置每次从队列获取消息的数量
    int prefetchCount = 1 ;
    channel.basicQos(prefetchCount);

    // 4. 创建一个回调类
    Consumer consumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
          throws IOException {
        super.handleDelivery(consumerTag, envelope, properties, body);
        String message = new String(body, "UTF-8");
        // 工作
        doWork(message);

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

    // 消费消息 公平分发,关闭自动应答
    channel.basicConsume(QUEUE_NAME, false, consumer);

  }

  private static void doWork(String message) {
    System.out.println(" [1] Received '" + message + "', 处理业务中...");
    // 模仿消费者处理业务的时间，也让其他消费者有机会获取到消息，实际开发中不需要，这里只是模拟
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      System.out.println("[1] done");
    }
  }
}
3.3消费者2
package com.makesailing.neo.fair.consumer;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # 轮询分发 消费者2
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 16:54
 */
public class Recvice2 {
  public static final String QUEUE_NAME = "test_work_fair_queue";

  public static void main(String[] args) throws IOException, TimeoutException {
    // 1.创建连接
    Connection connection = ConnectionUtils.getConnection();
    // 2.创建信道
    Channel channel = connection.createChannel();
    // 3.声明信道中的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);

    // 设置每次从队列获取消息的数量
    // 换句话讲 在接收该 Consumer的 ack之前,他不会将新的message发给它
    int prefetchCount = 1 ;
    channel.basicQos(prefetchCount);
    // 4. 创建一个回调类
    Consumer consumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
          throws IOException {
        super.handleDelivery(consumerTag, envelope, properties, body);
        String message = new String(body, "UTF-8");
        // 工作
        doWork(message);

        channel.basicAck(envelope.getDeliveryTag(), false);
      }
    };

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

  }

  private static void doWork(String message) {
    System.out.println(" [2] Received '" + message + "', 处理业务中...");
    // 模仿消费者处理业务的时间，也让其他消费者有机会获取到消息，实际开发中不需要，这里只是模拟
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      System.out.println("[2] done");
    }
  }
}
3.4测试

3.5 总结

显然消费者1处理只要1s ,所以消费的记录数比消费者2要多很多 .表示确实是公平分发

注意点 :

当关闭自动应答autoAck=false之后，在消费者处理消费数据之后一定要对消息进行手动反馈处理，可以是basicAck，也可以是basicNack， basicReject

BasicReject一次只能拒绝接收一个消息，而BasicNack方法可以支持一次0个或多个消息的拒收，并且也可以设置是否requeue。

// 拒绝当前消息，并使这条消息重新返回到队列中
channel.basicNack(envelope.getDeliveryTag(), false, true);
相当于
channel.basicReject(envelope.getDeliveryTag(), true);
makesailing
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ教程(安装与使用详解,Spring集成)
鸟哥哥的专栏
12-26 50万+
RabbitMQ教程，面试题。消息队列(MQ)，本质是个队列，队列中存放的内容是message。MQ用于不同进程Process/线程Thread之间通信。本文介绍RabbitMQ的使用。RabbitMQ实战教程。
RabbitMQ实战
InterceptWall的博客
08-28 2148
解耦：在项目启动之初来预测将来会碰到什么需求是极其困难的。消息中间件在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口，这允许你独立地扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束即可冗余〈存储) 有些情况下，处理数据的过程会失败。消息中间件可以把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。在把 个消息从消息中间件中删除之前，需要你的处理系统明确地指出该消息己经被处理完成，从而确保你的数据被安全地保存直到你使用完毕。...
【消息队列】六万字长文详细带你RabbitMQ从入门到精通
最新发布
Hanson的博客
06-24 545
六万字长文深入了解RabbitMQ，从基础到精通
RibbitMQ入门实战详解
翰萨姆的博客
09-17 769
RabbitMQ 实战教程 MQ(Message Queue)=消息队列，消息中间件,是一种理念（规范）RabbitMQ其中的一个具体产品 1.MQ引言 1.1 什么是MQ MQ(Message Quene) : 翻译为 消息队列,通过典型的 生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为 消息中间件 通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数
RabbitMQ详细实战教程
ZhAoYaJ的博客
06-13 781
RabbitMQ详细实战教程 CSDN创作 C位 CSDN创作 C位
rabbitMq实战
02-27
RabbiMQ消息队列的介绍和在各个场景下的使用
RabbitMQ实战 高效部署分布式消息队列
11-29
RabbitMQ实战 高效部署分布式消息队列 RabbitMQ实战 高效部署分布式消息队列 RabbitMQ实战 高效部署分布式消息队列
RabbitMQ实战 高效部署分布式消息队列 带目录 高清版 PDF
09-13
《RabbitMQ实战：高效部署分布式消息队列》是一本深度解析RabbitMQ技术的书籍，旨在帮助读者理解和掌握如何在实际项目中高效地运用这一强大的消息中间件。书中不仅涵盖了RabbitMQ的基础知识，还深入探讨了其在分布式...
RabbitMQ实战 高效部署分布式消息队列 PDF下载
11-24
《RabbitMQ实战：高效部署分布式消息队列》是一本深度解析RabbitMQ技术的书籍，专注于帮助读者理解和掌握如何在实际项目中高效地部署和使用这个强大的消息中间件。RabbitMQ作为开源的消息代理和队列服务器，广泛应用...
RabbitMQ实战高效部署分布式消息队列
07-11
《RabbitMQ实战高效部署分布式消息队列》这本书籍详细阐述了如何在实际环境中高效地部署和使用RabbitMQ这一流行的消息中间件。RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）协议实现的开源消息队列系统...
SpringBoot整合RabbitMQ之 典型应用场景实战一
热门推荐
青松之竹_Java博客
10-09 9万+
实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。 其中课程的学习链接地址：https://edu.csdn.net/course/detail/9314 RabbitMQ 官网拜读 首先，让我们先拜读 Ra...
rabbitMQ实战
10-10
这是牧码人王老师讲的，里面的rabbitMQ下载、安装、六种消息类型都很全，代码我也都试过了，直接复制粘贴就可以使用，希望可以帮助到大家
RabbitMQ 实战教程（一） Hello World
咖啡的博客
03-20 395
准备 本教程假定 RabbitMQ 已在标准端口（5672） 的 localhost 上安装并运行。如果使用不同的主机，端口或凭据，连接设置将需要调整。 介绍 RabbitMQ 是一个消息代理：它接受并转发消息。你可以将其视为邮局：当你将要发布的邮件放在邮箱中时，您可以确信 Postman 先生最终会将邮件发送给收件人。在这个比喻中，RabbitMQ 是一个邮箱，邮局和邮递员。 Rabbi...
RabbitMQ实战教程(一) : 安装及相关概念介绍
makesailing的博客
09-16 418
RabbitMQ实战教程(一) : 安装及相关概念介绍 由于本人只在Windows安装 RabbitMQ 服务 ,其他系统安装暂时没有涉及,如果有需要请自行搜索安装教程… 1 . Windows 安装 Windows安装需要先安装Erlang，再安装RabbitMQ 第一步：安装Erlang OTP，由于RabbitMQ是用Erlang编写的，所以在安装RabbitMQ之前要先安...
RabbitMQ实战教程
程序员养成日记
09-13 447
RabbitMQ实战教程 1.MQ引言 1.1 什么是MQ MQ是翻译为消息队列，通过典型的生产者和消费者模型，生产者不断向消息队列中生产消息，消费者不断从队列中获取消息。因为消息的生产者和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，轻松实现系统间解耦。别名为消息中间件，通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。 1.2 MQ有哪些 当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、RabbitMQ、炙手可热的Kafka，阿里巴
RabbitMQ实战与比较：消息队列技术详解
RabbitMQ实战教程深入探讨了消息队列（MQ）的核心概念和几种主流MQ产品的特性。首先，我们了解到MQ是一种异步通信方式，通过生产者和消费者模型实现系统间的解耦，尤其在企业级应用中发挥重要作用。MQ作为消息中间件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值