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——多线程下解决生产消费者模型
我们学习了操作系统,想必对生产消费者问题都不陌生.作为同步互斥问题的一个经典案例,生产消费者模型其实是解决实际问题的基础模型,解决很多的实际问题都会依赖于它.而此模型要解决最大的问题便是同步与互斥.而 ...
随机推荐
- MySQL学习9 - 单表查询
一.单表查询的语法 二.关键字的执行优先级(重点) 三.单表查询示例 1.where约束 2.group by分组查询 3.聚合函数 4.HAVING过滤 5.order by查询排序 6.limit ...
- (二)Java工程化--Maven实践
Maven项目版本号 默认版本号: 1.0-SNAPSHOT 最佳实践是约定该版本为不稳定版本,如果发布一定要删除; 建议的版本规则: 主版本号.次版本号.增量版本号- 如:1.0.0-RELEASE ...
- 第四节，目标检测---YOLO系列
1.R-CNN回顾 适应全卷积化CNN结构,提出全卷积化设计 共享ResNet的所有卷积层 引入变换敏感性(Translation variance) 位置敏感分值图(Position-sensiti ...
- java读写分离的实现
1. 背景 我们一般应用对数据库而言都是“读多写少”,也就说对数据库读取数据的压力比较大,有一个思路就是说采用数据库集群的方案, 其中一个是主库,负责写入数据,我们称之为:写库: 其它都是从库,负责 ...
- Pytorch 常用函数
1. torch.renorm(input, p, dim, maxnorm, out=None) → Tensor Returns a tensor where each sub-tensor of ...
- 网络编程中select模型和poll模型学习(linux)
一.概述 并发的网络编程中不管是阻塞式IO还是非阻塞式IO,都不能很好的解决同时处理多个socket的问题.操作系统提供了复用IO模型:select和poll,帮助我们解决了这个问题.这两个函数都能够 ...
- 【由浅入深理解java集合】(四)——集合 Queue
今天我们来介绍下集合Queue中的几个重要的实现类.关于集合Queue中的内容就比较少了.主要是针对队列这种数据结构的使用来介绍Queue中的实现类. Queue用于模拟队列这种数据结构,队列通常是指 ...
- mybatis mapper文件里的<set><trim>
简单介绍:翻看以前在学校写的代码,发现那时候有一个sql写的很有意思,用到了 <set>标签,和我现在写的虽然有点差别,但是效果一样 代码: //mapper里的sql <updat ...
- sqlserver(查看被锁进程)
-- ###### 查看被锁进程 ###### select 标志, 进程ID=spid,线程ID=kpid,块进程ID=blocked,数据库ID=dbid, 数据库名=db_name(dbid), ...
- chromedriver与chrome版本映射表
问题: 利用selenium调用谷歌浏览器时报错,后发现是由于浏览器与浏览器驱动不匹配造成的 C:\Users\\Desktop\selenium>python chrome.py[9956:6 ...