RocketMQ生产消费模型选择
一. 生产者，根据某个标识将消息放到同一个队列中
在发送消息时，使用SelectMessageQueueByHash，该类根据传入进去的arg，进行hash计算，将消息分配到相应的队列中。
public class Producer {
public static void main(String[] args) throws MQClientException {
DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
producer.setNamesrvAddr("10.130.41.36:9876");
producer.setInstanceName("Producer");
producer.setVipChannelEnabled(false);
producer.start();
String[] tags = {"tagA","tagB"};
for (int i = 1; i <= 10; i++) {
try {
Message msg = new Message("TopicTest",tags[i%tags.length],"key1"+i,("订单一号" + i).getBytes());
SendResult sendResult = producer.send(msg, new SelectMessageQueueByHash(),1);
System.out.println(sendResult);
} catch (Exception e) {
e.printStackTrace();
}
}
for (int i = 1; i <= 10; i++) {
try {
Message msg = new Message("TopicTest",tags[i%tags.length],"key2"+i,("订单二号" + i).getBytes());
SendResult sendResult = producer.send(msg, new SelectMessageQueueByHash(),2);
System.out.println(sendResult);
} catch (Exception e) {
e.printStackTrace();
}
}
for (int i = 1; i <= 10; i++) {
try {
Message msg = new Message("TopicTest",tags[i%tags.length],"key3"+i,("订单三号" + i).getBytes());
SendResult sendResult = producer.send(msg, new SelectMessageQueueByHash(),3);
System.out.println(sendResult);
} catch (Exception e) {
e.printStackTrace();
}
}
producer.shutdown();
}
}
上述代码执行后Topic队列中的内容：
二. 消费者
(1). 顺序消费
使用MessageListenerOrderly，顺序消费同一个队列中的数据，只有第一个数据消费成功了才会消费第二个数据。
模拟在消费某个队列中的数据时出现了阻塞状态。
public class ConsumerOrderly {
public static void main(String[] args) throws InterruptedException,
MQClientException {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
consumer.setNamesrvAddr("10.130.41.36:9876");
consumer.setInstanceName("Consumer1");
consumer.setMessageModel(MessageModel.CLUSTERING);
consumer.subscribe("TopicTest", "*");
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
//设置自动提交,如果不设置自动提交就算返回SUCCESS,消费者关闭重启 还是会重复消费的
context.setAutoCommit(true);
try {
for (MessageExt msg:msgs) {
String msgKey = msg.getKeys();
if(msgKey.equals("key13") || msgKey.equals("key22")){
Thread.sleep(1000);
}
System.out.println(" 消费者1 ==> 当前线程:"+Thread.currentThread().getName()+" ,quenuID: "+msg.getQueueId()+ " ,content: " + new String(msg.getBody()));
}
} catch (Exception e) {
e.printStackTrace();
//如果出现异常,消费失败，挂起消费队列一会会，稍后继续消费
return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
}
//消费成功
return ConsumeOrderlyStatus.SUCCESS;
}
});
/**
* Consumer对象在使用之前必须要调用start初始化，初始化一次即可
*/
consumer.start();
System.out.println("C1 Started.");
}
}
测试结果如下：
当"订单一号3"没有消费时 "订单一号4"，"订单一号5"是不能被消费的，"订单二号2"也是同样的情况。
(2). 并发消费
使用MessageListenerConcurrently，并发消费同一个队列中的数据，不能保证消费的顺序。
模拟在消费某个数据时出现了阻塞状态。
public class ConsumerConcurrently {
public static void main(String[] args) throws InterruptedException,
MQClientException {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
consumer.setNamesrvAddr("10.130.41.36:9876");
consumer.setInstanceName("Consumer1");
consumer.setMessageModel(MessageModel.CLUSTERING);
consumer.subscribe("TopicTest", "*");
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
try {
for (MessageExt msg:msgs) {
String msgKey = msg.getKeys();
if(msgKey.equals("key13") || msgKey.equals("key22")){
Thread.sleep(1000);
}
System.out.println(" 消费者1 ==> 当前线程:"+Thread.currentThread().getName()+" ,quenuID: "+msg.getQueueId()+ " ,content: " + new String(msg.getBody()));
}
} catch (Exception e) {
e.printStackTrace();
return ConsumeConcurrentlyStatus.RECONSUME_LATER;
}
//消费成功
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
System.out.println("C1 Started.");
}
}
测试结果如下
当消费"订单一号3"阻塞时，会将后面的数据交给其他线程消费，所以"订单一号4" ，"订单一号5"在 "订单一号3"之前消费了。
(3). 集群消费
不同消费者设置成相同的组名，在MessageModel.CLUSTERING模式下，不同消费者会消费不同的队列，同一个消费者中保证顺序
消费者1
public class ConsumerOrderly_1 {
public static void main(String[] args) throws InterruptedException,
MQClientException {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
consumer.setNamesrvAddr("10.130.41.36:9876");
consumer.setInstanceName("Consumer1");
consumer.setMessageModel(MessageModel.CLUSTERING);
consumer.subscribe("TopicTest", "*");
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
//设置自动提交,如果不设置自动提交就算返回SUCCESS,消费者关闭重启 还是会重复消费的
context.setAutoCommit(true);
try {
for (MessageExt msg:msgs) {
String msgKey = msg.getKeys();
if(msgKey.equals("key13")){
Thread.sleep(1000);
}
System.out.println(" 消费者1 ==> 当前线程:"+Thread.currentThread().getName()+" ,quenuID: "+msg.getQueueId()+ " ,content: " + new String(msg.getBody()));
}
} catch (Exception e) {
e.printStackTrace();
//如果出现异常,消费失败，挂起消费队列一会会，稍后继续消费
return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
}
//消费成功
return ConsumeOrderlyStatus.SUCCESS;
}
});
/**
* Consumer对象在使用之前必须要调用start初始化，初始化一次即可
*/
consumer.start();
System.out.println("C1 Started.");
}
}
消费者2
public class ConsumerOrderly_2 {
public static void main(String[] args) throws InterruptedException,
MQClientException {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
consumer.setNamesrvAddr("10.130.41.36:9876");
consumer.setInstanceName("Consumer2");
consumer.setMessageModel(MessageModel.CLUSTERING);
consumer.subscribe("TopicTest", "*");
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
//设置自动提交,如果不设置自动提交就算返回SUCCESS,消费者关闭重启 还是会重复消费的
context.setAutoCommit(true);
try {
for (MessageExt msg:msgs) {
String msgKey = msg.getKeys();
if(msgKey.equals("key22")){
Thread.sleep(1000);
}
System.out.println(" 消费者2 ==> 当前线程:"+Thread.currentThread().getName()+" ,quenuID: "+msg.getQueueId()+ " ,content: " + new String(msg.getBody()));
}
} catch (Exception e) {
e.printStackTrace();
//如果出现异常,消费失败，挂起消费队列一会会，稍后继续消费
return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
}
//消费成功
return ConsumeOrderlyStatus.SUCCESS;
}
});
/**
* Consumer对象在使用之前必须要调用start初始化，初始化一次即可
*/
consumer.start();
System.out.println("C2 Started.");
}
}
测试结果如下：
消费者1负责队列1，并保证队列1中的所有消息是按照顺序消费的
消费者2负责队列2和队列3，根据"订单二号2"可以看出，他保证了队列2和队列3的顺序消费。
(4). 消费者A和消费者B同组，消费者A消费tagA，消费者B消费tagB如图
在这种情况下，因为集群中订阅消息不一致，导致消费出现问题，最后启动的消费者才可以正常消费消息。
要解决这个问题，需要保证集群中的消费者拥有统一的订阅消息，Topic和Tag要一致才可以。
参考：
https://www.jianshu.com/p/524ef06ce25a
https://mp.weixin.qq.com/s/HbIS0yEJsCPMYwwYDBIvMQ
(5). 消费者A和消费者B不同组，消费者A消费tagA，消费者B消费tagB
在消费者1中，能保证tagA1,tagA2顺序的消费，消费者2中能保证tagB1,tagB2顺序的消费。
但是不能保证tagA1和tagB1的消费顺序。
测试代码：
消费者1
public class ConsumerOrderly_1 {
public static void main(String[] args) throws InterruptedException,
MQClientException {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
consumer.setNamesrvAddr("10.130.41.36:9876");
consumer.setInstanceName("Consumer1");
consumer.setMessageModel(MessageModel.CLUSTERING);
consumer.subscribe("TopicTest", "tagA");
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
//设置自动提交,如果不设置自动提交就算返回SUCCESS,消费者关闭重启 还是会重复消费的
context.setAutoCommit(true);
try {
for (MessageExt msg:msgs) {
System.out.println(" 消费者1 ==> 当前线程:"+Thread.currentThread().getName()+" ,quenuID: "+msg.getQueueId()+ " ,content: " + new String(msg.getBody()));
}
} catch (Exception e) {
e.printStackTrace();
//如果出现异常,消费失败，挂起消费队列一会会，稍后继续消费
return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
}
//消费成功
return ConsumeOrderlyStatus.SUCCESS;
}
});
/**
* Consumer对象在使用之前必须要调用start初始化，初始化一次即可
*/
consumer.start();
System.out.println("C1 Started.");
}
}
消费者2
public class ConsumerOrderly_2 {
public static void main(String[] args) throws InterruptedException,
MQClientException {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName1");
consumer.setNamesrvAddr("10.130.41.36:9876");
consumer.setInstanceName("Consumer2");
consumer.setMessageModel(MessageModel.CLUSTERING);
consumer.subscribe("TopicTest", "tagB");
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
//设置自动提交,如果不设置自动提交就算返回SUCCESS,消费者关闭重启 还是会重复消费的
context.setAutoCommit(true);
try {
for (MessageExt msg:msgs) {
String msgKey = msg.getKeys();
if(msgKey.equals("key11")){
Thread.sleep(1000);
}
System.out.println(" 消费者2 ==> 当前线程:"+Thread.currentThread().getName()+" ,quenuID: "+msg.getQueueId()+ " ,content: " + new String(msg.getBody()));
}
} catch (Exception e) {
e.printStackTrace();
//如果出现异常,消费失败，挂起消费队列一会会，稍后继续消费
return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
}
//消费成功
return ConsumeOrderlyStatus.SUCCESS;
}
});
/**
* Consumer对象在使用之前必须要调用start初始化，初始化一次即可
*/
consumer.start();
System.out.println("C2 Started.");
}
}
测试结果：
消费者1
消费者2
"订单一号2" 在 "订单一号1" 前被消费了。
RocketMQ生产消费模型选择的更多相关文章
- Python并发编程-生产消费模型
生产消费模型初步 #产生两个子进程,Queue可以在子进程之间传递消息 from multiprocessing import Queue,Process import random import t ...
- Python学习之路并发编程--信号量、事件、队列及生产消费模型
1. 信号量 对于多进程来说,多个进程同时修改数据,就可能出现安全隐患,所以引入了锁,这一机制,但锁只能有一把来控制一个的开关,当你需要几把锁的时候,就可能用到信号量的概念.他是用了锁的原理,内置了一 ...
- 初识Kafka：构架、生产消费模型以及其他相关概念
当前使用的事件总线采用的是Kafka分布式消息队列来完成的,近来项目需要接入到事件总线中,故开启了kafka的学习之旅(之前一直在听说kafka这玩意儿,但是学习计划中还没有将它安排进去,借着这个机会 ...
- 并发编程：生产消费模型、死锁与Rlock、线程、守护线程、信号量、锁
一.生产者消费者模型1 二.生产者消费者模型2 三.守护线程 四.常用方法 五.启动线程的另一种方式 六.锁 七.锁死 八.死锁 九.单个锁能不能死锁 十.信号旗 一.生产者消费者模型1 import ...
- Day9 进程同步锁 进程队列 进程池 生产消费模型 进程池 paramike模块
进程同步锁: 当运行程序的时候,有可能你的程序同时开多个进程,开进程的时候会将多个执行结果打印出来,这样的话打印的信息都是错乱的,怎么保证打印信息是有序的呢? 其实也就是相当于让进程独享资源. fro ...
- JAVA 多线程制作大球吃小球 一、实现球的自动生成及运动 生产消费模型
前几天用多线程实现了创建小球并移动,想到大鱼吃小鱼,便突发奇想要写一个大球吃小球.首先第一步自然是先把界面弄好啦 public class BallUI extends JPanel { privat ...
- 并发编程： 生产消费模型、死锁与Rlock、线程、守护线程、信号量、锁
一.守护进程 二.互斥锁 三.抢票 四.进程间通讯 五.进程间通讯2 一.守护进程 """ 进程间通讯的另一种方式 使用queue queue 队列 队列的特点: 先进的 ...
- 使用wait/notify实现生产消费模型
public class A { private Deque<Integer> list = new LinkedList<>(); private int max = 10; ...
- Linux——多线程下解决生产消费者模型
我们学习了操作系统,想必对生产消费者问题都不陌生.作为同步互斥问题的一个经典案例,生产消费者模型其实是解决实际问题的基础模型,解决很多的实际问题都会依赖于它.而此模型要解决最大的问题便是同步与互斥.而 ...
随机推荐
- codeblocks更改颜色主题
链接:http://www.cnblogs.com/wenbosheng/p/5899483.html
- pythonのsimple_tag
当我们需要在页面种直接调用py文件中的某些方法时,我们就要用到simple_tag.具体步骤如下: 1.在某个app下创建templatetags文件夹,切记该名称是不可以改变的. 2.在该文件夹下创 ...
- Python学习笔记-Linux下安装Python
Linux系统CentOS 1.安装依赖组件 yum install openssl-devel bzip2-devel expat-devel gdbm-devel readline-devel s ...
- xheditor编辑器上传图片
之前在用csdn的时候,觉得他们家的编辑器挺好用,精美,简洁,大方,功能强大.最近自己的项目也要用到编辑器,我就想起了xheditor. 好多大网站都用到它~好棒! 我把xheditor用于文章模块, ...
- MS SQL Server 查询元数据
use test -- 查询数据库中所有的表和架构名称select SCHEMA_NAME(schema_id) as table_schema_name, name as table_name fr ...
- js 禁止f12、Ctrl +S 、右键
<script language=javascript> window.onload=function(){ document.onkeydown=function(){ ]; ){ re ...
- 第十一篇：Mysql系列
Python开发基础之路 第十一篇:Mysql系列 Python-数据库 基本SQL语句 Python-数据类型 主键auto_increment Python-多表关联 外键 级联 Python-s ...
- linux磁盘阵列 逻辑卷管理器
Difficult doesn't mean impossible.It simply meansthat you have to work hard.困难并不代表不可能,它仅仅意味着你必须努力奋斗. ...
- add web server(nginx+apache)
#!/bin/bash # # Web Server Install Script # Last Updated 2012.09.24 # ##### modify by WanJie 2012.09 ...
- sqlserver(查看被锁进程)
-- ###### 查看被锁进程 ###### select 标志, 进程ID=spid,线程ID=kpid,块进程ID=blocked,数据库ID=dbid, 数据库名=db_name(dbid), ...