RocketMQ入门-顺序消息

最新推荐文章于 2024-06-30 18:40:12 发布
最新推荐文章于 2024-06-30 18:40:12 发布
阅读量265 收藏
点赞数
分类专栏： RocketMq 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43169156/article/details/115825129
版权

Rocket顺序消息

本篇基于RocketMQ集群开发，如需了解集群的搭建，可参考之前的文章RocketMQ集群安装。

摘录RocketMQ官方示例中顺序消息的解释信息：

1.顺序消息指按照消息发送的顺序(FIFO)消费。RocketMQ支持分区有序和全局有序。

2.在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。

顺序队列的关键就是让同一个订单的消息，按顺序放入同一个队列。

下面用订单进行分区有序的示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。

Producer生产者

生产者使用send(Message msg, MessageQueueSelector selector, Object arg)方法，控制订单消息分区有序需要MessageQueueSelector对订单号相同的返回同一个MessageQueue消息队列。

public class OrderProducer {

    public static void main(String[] args) throws Exception {
        // 1.指定生产者组
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer(MyRocketMqConstant.OrderLearn.ORDER_LEARN_PRODUCER_GROUP);
        // 2.关联注册中心
        defaultMQProducer.setNamesrvAddr(MyRocketMqConstant.NAME_SRV);
        // 3.启动生产者
        defaultMQProducer.start();
        String[] tags = {MyRocketMqConstant.OrderLearn.ORDER_LEARN_TAG_A
                , MyRocketMqConstant.OrderLearn.ORDER_LEARN_TAG_B
                , MyRocketMqConstant.OrderLearn.ORDER_LEARN_TAG_C};


        // 模拟订单数据
        List<OrderStep> orderStepList = new OrderProducer().buildOrders();

        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = sdf.format(date);

        for (int i = 0; i < 10; i++) {
            // 构造消息数据
            String body = orderStepList.get(i) + "Hello RocketMQ" + dateStr;
            Message message = new Message(MyRocketMqConstant.OrderLearn.ORDER_LEARN_TOPIC
                    , tags[i % tags.length]
                    , "KEY" + i, body.getBytes(StandardCharsets.UTF_8));

            SendResult sendResult = defaultMQProducer.send(message, new MessageQueueSelector() {
                // 消息队列对象
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    // arg来自于send(Message msg, MessageQueueSelector selector, Object arg)的第三个参数arg
                    // 同一订单号使用同一消息队列
                    Long id = (Long) arg;
                    long index = id % mqs.size();
                    return mqs.get((int) index);
                }
            }, orderStepList.get(i).getOrderId());

            System.out.println(String.format("SendResult status:%s,queueId:%d,body:%s",
                    sendResult.getSendStatus(),
                    sendResult.getMessageQueue().getQueueId(),
                    body));
        }
        defaultMQProducer.shutdown();
    }

    /**
     * 订单的步骤
     */
    private static class OrderStep {
        private long orderId;
        private String desc;

        public long getOrderId() {
            return orderId;
        }

        public void setOrderId(long orderId) {
            this.orderId = orderId;
        }

        public String getDesc() {
            return desc;
        }

        public void setDesc(String desc) {
            this.desc = desc;
        }

        @Override
        public String toString() {
            return "OrderStep{" +
                    "orderId=" + orderId +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    }

    /**
     * 生成模拟订单数据
     * 保证订单的生成顺序是：创建->付款->推送->完成
     */
    private List<OrderStep> buildOrders() {
        List<OrderStep> orderList = new ArrayList<OrderStep>();

        OrderStep orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("推送");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        return orderList;
    }
}

Consumer消费者

public class OrderConsumer {

    public static void main(String[] args) throws Exception {
        // 1.指定消费者组
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(MyRocketMqConstant.OrderLearn.ORDER_LEARN_CONSUMER_GROUP);
        // 2.关联注册中心
        consumer.setNamesrvAddr(MyRocketMqConstant.NAME_SRV);
        // 3.设置Consumer第一次启动是从队列头部开始消费还是从队列尾部开始消费
        // 如果非第一次启动，那么按照上次消费的位置继续消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

        String[] tags = {MyRocketMqConstant.OrderLearn.ORDER_LEARN_TAG_A
                , MyRocketMqConstant.OrderLearn.ORDER_LEARN_TAG_B
                , MyRocketMqConstant.OrderLearn.ORDER_LEARN_TAG_C};
        String join = String.join(" || ", tags);

        consumer.subscribe(MyRocketMqConstant.OrderLearn.ORDER_LEARN_TOPIC, join);

        consumer.registerMessageListener(new MessageListenerOrderly() {
            Random random = new Random();
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                context.setAutoCommit(true);
                for (MessageExt msg : msgs) {
                    // 每个queue不一定有唯一的consumer线程消费，订单对每个queue有序
                    System.out.println("[consumerThread="+Thread.currentThread().getName()+"] [queueId="+msg.getQueueId()+"] content"+new String(msg.getBody()));
                }

                try {
                    // 模拟业务逻辑处理...
                    TimeUnit.SECONDS.sleep(random.nextInt(10));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });

        consumer.start();
    }
}

tips:RocketMQ源码中示例说：每个queue有唯一的consumer线程消费，订单对每个queue有序，实践证明这个描述不正确。正确的是：每个queue不一定有唯一的consumer线程消费，订单对每个queue有序。

测试结果

总共测试了三次，输出结果如下（可以把输出内容放入notepad++中，双击订单号查看同订单号的输出顺序）。

发现消费者的输出顺序不一定会一致，但是针对同一个订单的输出顺序是一定相同的。同时消费者消费时，同一个订单号可能有不同的线程消费。

生产者输出

生产者
//队列3
SendResult status:SEND_OK,queueId:3,body:OrderStep{orderId=15103111039, desc='创建'}
SendResult status:SEND_OK,queueId:3,body:OrderStep{orderId=15103111039, desc='付款'}
SendResult status:SEND_OK,queueId:3,body:OrderStep{orderId=15103117235, desc='创建'}
SendResult status:SEND_OK,queueId:3,body:OrderStep{orderId=15103117235, desc='付款'}
SendResult status:SEND_OK,queueId:3,body:OrderStep{orderId=15103111039, desc='推送'}
SendResult status:SEND_OK,queueId:3,body:OrderStep{orderId=15103117235, desc='完成'}
SendResult status:SEND_OK,queueId:3,body:OrderStep{orderId=15103111039, desc='完成'}

//队列1
SendResult status:SEND_OK,queueId:1,body:OrderStep{orderId=15103111065, desc='创建'}
SendResult status:SEND_OK,queueId:1,body:OrderStep{orderId=15103111065, desc='付款'}
SendResult status:SEND_OK,queueId:1,body:OrderStep{orderId=15103111065, desc='完成'}

消费者输出

消费者
//队列3
[consumerThread=ConsumeMessageThread_1] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='创建'}]
[consumerThread=ConsumeMessageThread_3] [broker=broker-a/192.168.15.15:10911] [queueId=3] [content=OrderStep{orderId=15103117235, desc='创建'}]
[consumerThread=ConsumeMessageThread_1] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='付款'}]
[consumerThread=ConsumeMessageThread_1] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='推送'}]
[consumerThread=ConsumeMessageThread_1] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='完成'}]
[consumerThread=ConsumeMessageThread_3] [broker=broker-a/192.168.15.15:10911] [queueId=3] [content=OrderStep{orderId=15103117235, desc='付款'}]
[consumerThread=ConsumeMessageThread_3] [broker=broker-a/192.168.15.15:10911] [queueId=3] [content=OrderStep{orderId=15103117235, desc='完成'}]

//队列1
[consumerThread=ConsumeMessageThread_2] [broker=broker-a/192.168.15.15:10911] [queueId=1] [content=OrderStep{orderId=15103111065, desc='创建'}]
[consumerThread=ConsumeMessageThread_2] [broker=broker-a/192.168.15.15:10911] [queueId=1] [content=OrderStep{orderId=15103111065, desc='付款'}]
[consumerThread=ConsumeMessageThread_2] [broker=broker-a/192.168.15.15:10911] [queueId=1] [content=OrderStep{orderId=15103111065, desc='完成'}]


//==================================================测试分隔线===================================================================================

//队列3
[consumerThread=ConsumeMessageThread_4] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='创建'}]
[consumerThread=ConsumeMessageThread_6] [broker=broker-a/192.168.15.15:10911] [queueId=3] [content=OrderStep{orderId=15103117235, desc='创建'}]
[consumerThread=ConsumeMessageThread_4] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='付款'}]
[consumerThread=ConsumeMessageThread_6] [broker=broker-a/192.168.15.15:10911] [queueId=3] [content=OrderStep{orderId=15103117235, desc='付款'}]
[consumerThread=ConsumeMessageThread_6] [broker=broker-a/192.168.15.15:10911] [queueId=3] [content=OrderStep{orderId=15103117235, desc='完成'}]
[consumerThread=ConsumeMessageThread_4] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='推送'}]
[consumerThread=ConsumeMessageThread_4] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='完成'}]

//队列1
[consumerThread=ConsumeMessageThread_5] [broker=broker-a/192.168.15.15:10911] [queueId=1] [content=OrderStep{orderId=15103111065, desc='创建'}]
[consumerThread=ConsumeMessageThread_5] [broker=broker-a/192.168.15.15:10911] [queueId=1] [content=OrderStep{orderId=15103111065, desc='付款'}]
[consumerThread=ConsumeMessageThread_5] [broker=broker-a/192.168.15.15:10911] [queueId=1] [content=OrderStep{orderId=15103111065, desc='完成'}]


//==================================================测试分隔线===================================================================================

//队列3
[consumerThread=ConsumeMessageThread_7] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='创建'}]
[consumerThread=ConsumeMessageThread_9] [broker=broker-a/192.168.15.15:10911] [queueId=3] [content=OrderStep{orderId=15103117235, desc='创建'}]
[consumerThread=ConsumeMessageThread_10] [broker=broker-a/192.168.15.15:10911] [queueId=3] [content=OrderStep{orderId=15103117235, desc='付款'}]
[consumerThread=ConsumeMessageThread_10] [broker=broker-a/192.168.15.15:10911] [queueId=3] [content=OrderStep{orderId=15103117235, desc='完成'}]
[consumerThread=ConsumeMessageThread_7] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='付款'}]
[consumerThread=ConsumeMessageThread_7] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='推送'}]
[consumerThread=ConsumeMessageThread_7] [broker=broker-b/192.168.15.16:10911] [queueId=3] [content=OrderStep{orderId=15103111039, desc='完成'}]
//队列1
[consumerThread=ConsumeMessageThread_8] [broker=broker-a/192.168.15.15:10911] [queueId=1] [content=OrderStep{orderId=15103111065, desc='创建'}]
[consumerThread=ConsumeMessageThread_8] [broker=broker-a/192.168.15.15:10911] [queueId=1] [content=OrderStep{orderId=15103111065, desc='付款'}]
[consumerThread=ConsumeMessageThread_8] [broker=broker-a/192.168.15.15:10911] [queueId=1] [content=OrderStep{orderId=15103111065, desc='完成'}]

总结

消费时同一订单号的消息顺序是如何保证和生产者生成订单相同的？需要关注MessageQueueSelector，它的返回值就是消息所关联的队列。

MessageQueueSelector

创建的匿名内部类如下：

 new MessageQueueSelector() {
                // 消息队列对象
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    // arg来自于send(Message msg, MessageQueueSelector selector, Object arg)的第三个参数arg
                    // 同一订单号使用同一消息队列
                    Long id = (Long) arg;
                    long index = id % mqs.size();
                    return mqs.get((int) index);
                }

测试环境使用了集群，2个broker-a，2个broker-b；创建MessageQueueSelector对象时，参数List<MessageQueue> mqs内容如下，有8条记录。Long id = (Long) arg;获取到send方法传入的订单id,long index = id % mqs.size();取余会使同一订单id的不同消息关联同一个消息队列。

根据上面的消费者输出测试结果，三次输出的消费者信息顺序虽然不完全一致，但是同一个订单id的顺序一定是一致的，因为同一订单号的消息关联了同一个消息队列，这就是RocketMQ的分区顺序。

[
	{
		"brokerName": "broker-a","queueId": 0,"topic": "order-topic"
	},
	{
		"brokerName": "broker-a","queueId": 1,"topic": "order-topic"
	},
	{
		"brokerName": "broker-a","queueId": 2,"topic": "order-topic"
	},
	{
		"brokerName": "broker-a","queueId": 3,"topic": "order-topic"
	},
	{
		"brokerName": "broker-b","queueId": 0,"topic": "order-topic"
	},
	{
		"brokerName": "broker-b","queueId": 1,"topic": "order-topic"
	},
	{
		"brokerName": "broker-b","queueId": 2,"topic": "order-topic"
	},
	{
		"brokerName": "broker-b","queueId": 3,"topic": "order-topic"
	}
]

关闭slave02上的broker（启动了broker-b主节点和broker-a的从节点），启动生产者获取到的mqs对象内容如下：

[
	{
		"brokerName": "broker-a","queueId": 0,"topic": "order-topic"
	},
	{
		"brokerName": "broker-a","queueId": 1,"topic": "order-topic"
	},
	{
		"brokerName": "broker-a","queueId": 2,"topic": "order-topic"
	},
	{
		"brokerName": "broker-a","queueId": 3,"topic": "order-topic"
	}
]
春刀c
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RocketMQ讲义-03.pdf
04-25
RocketMQ是阿里巴巴开源的一款分布式消息中间件，广泛应用于大数据、实时计算、微服务等领域。本文将深入探讨RocketMQ的核心概念、优缺点、安装配置以及高级特性。 **1. MQ介绍** * **异步解耦**：MQ通过异步通信...
RocketMQ（十）RocketMQ事务消息
weixiaohuai的博客
03-31 1万+
一、RocketMQ事务消息概要 RocketMQ事务消息（Transactional Message）是指应用本地事务和发送消息操作可以被定义到全局事务中，要么同时成功，要么同时失败。RocketMQ的事务消息提供类似 X/Open XA 的分布式事务功能，通过事务消息能达到分布式事务的最终一致。 Apache RocketMQ在4.3.0版中已经支持分布式事务消息，采用了2PC（两阶段提交）+ 补偿机制（事务状态回查）的思想来实现了提交事务消息，同时增加一个补偿逻辑来处理二阶段超时或者失败的消息，.
RocketMQ自定义selector实现消息通道定向发送和拉取
iteye_3489的博客
04-23 4919
RocketMQ的安装部署请参考官网Quick Start RocketMQ的简单应用请参考官网github样例 本篇介绍如何通过自定义selector实现按messageQueue定向发送和接收消息   我们先看看MessageQueueSelector接口 public interface MessageQueueSelector { MessageQueue selec...
RocketMQ 顺序消息和事务消息及其原理
最新发布
STRANGE-P 的博客
06-30 1185
使用消息中间件时，首先要了解各类型mq消息中间件的优势和劣势，根据自己项目的实际情况，结合各消息中间件特性，取长避短。本篇博文讲解了RocketMQ 的两大重要特性：顺序消息、事务消息。
RocketMQ（九）RocketMQ顺序消息
weixiaohuai的博客
03-29 6581
目录 一、什么是顺序消息？ 二、顺序消息的原理 三、全局顺序消息 四、局部顺序消息 五、顺序消息缺陷 一、什么是顺序消息？ 消息有序指的是，消费者端消费消息时，需按照消息的发送顺序来消费，即先发送的消息，需要先消费(FIFO)。 举个容易理解的例子：通常创建订单后，会经历一系列的操作：【订单创建 -> 订单支付 -> 订单发货 -> 订单配送 -> 订单完成】。在创建完订单后，会发送五条消息到MQ Broker中，消费的时候要按照【订单创建 -> 订单支付 -&
解析 RocketMQ 业务消息 - “顺序消息”
阿里云技术
08-25 899
作为金融级可靠的业务消息方案，RocketMQ 从创建之初就一直专注于业务集成领域的异步通信能力构建。本篇将继续业务消息集成的场景，从功能原理、应用案例、最佳实践以及实战等角度介绍 RocketMQ 的顺序消息功能。
RocketMQ的顺序消息（顺序消费）
热门推荐
终生学习践行者
10-29 4万+
简单介绍了消息有序性的概念，以及RocketMQ如何实现消息的顺序消费。
轻松搞定RocketMQ入门
02-24
RocketMQ是一款分布式、队列模型的消息中间件，具有以下特点：能够保证严格的消息顺序提供丰富的消息拉取模式高效的订阅者水平扩展能力实时的消息订阅机制亿级消息堆积能力（1）NameServer是一个几乎无状态的节点，...
rocketmq-demo.zip
09-01
4. **Message Queue**：消息队列是RocketMQ中的物理存储单位，每个主题可以有多个消息队列，消息在队列中顺序存储。消费者通常按照轮询或者负载均衡的方式消费队列中的消息。 5. **Message ID**：每个发送的消息都...
rocketmq入门指南
01-15
RocketMQ 支持发布/订阅(Pub/Sub)和点对点(P2P)消息模型，能够在一个队列中实现可靠的先进先出(FIFO)和严格的顺序传递。此外，它还支持拉(pull)和推(push)两种消息模式，具备百万级别的消息堆积能力和多种消息协议的...
rocketMq浅析-顺序消息
hery的博客
08-26 415
一 什么是顺序消息 顺序消息（FIFO 消息）是 MQ 提供的一种严格按照顺序进行发布和消费的消息类型。顺序消息由两个部分组成：顺序发布和顺序消费。 顺序消息包含两种类型： 分区顺序：一个Partition内所有的消息按照先进先出的顺序进行发布和消费。 全局顺序：一个Topic内所有的消息按照先进先出的顺序进行发布和消费。 多线程中若没有因果关系则没有顺序。那么用户在多线程中去发消息就意味着用户不关心那些在不同线程中被发送的消息的顺序。即多线程发送的消息，不同线程间的消息不是顺序发布的，同一线程的消息是顺序
顺序消息
93张先生
02-03 407
顺序消息 顺序消息是指消息消费的顺序和生产者发送消息的顺序一样的。 例如：一个订单产生了三条消息分别是订单创建、订单付款、订单完成。消费时要按照这个顺序消费才能有意义，但是同时订单之间是可以并行消费的。RocketMQ可以严格的保证消息有序。 分区有序 分区有序是指这个Topic下这个队列下的消息是有顺序的，生产者发送消息的时候，将严格按照消息的顺序，将消息们发送到一个Topic下的一个队列，从而保证了生产者分区消息有序，消费者进行消费时，进行单线程单队列消费，保证了消费有序。 适用场景：性能要求高，以 s
rocketMQ架构(集群)流程，及顺序消费等问题
祁_z
05-20 3926
RocketMQ架构图 RocketMQ 四种集群部署方式 单个Master节点， 缺点就是如果宕机之后可能整个服务不可用； 多个Master节点，分摊存放我们的消息，缺点：没有Slave节点，主的Master节点宕机之后消息数据可能会丢失的； 多个Master和Slave节点，之间数据同步采用异步形式，效率非常高，数据可能短暂产生延迟（毫秒级别的） 多个Master和Slave节点，采用同步形式，效率比较低、数据不会产生延迟。 broker如果配置集群： 多个broker(master).
RocketMQ—Producer（五）路由队列选择
IT巅峰技术专栏
05-17 2130
前言 路由队列选择的作用在于发送消息时可以指定发送到某个broker队列，或均衡发送到broker队列，其作用就是在于选择合适的队列进行消息发送。 目前客户端队列选择分为三种方式： 第一种:可根据MessageQueueSelector的实现或自扩展实现选择队列； 第二种:未开启Broker故障延迟机制(sendLatencyFaultEnable:false),会采用默认轮训机制(默认是此种实现方式)； 第三种:开启Broker故障延迟机制(sendLatencyFaultEnable:true
RocketMq顺序消息解决方案
燕少江湖
05-07 3281
一、概念 顺序消费可以从业务层次分为两种：全局顺序消息、局部顺序消息 全局顺序消息：顾名思义，就是产生消息的顺序和消费消息的顺序一致，比如用户订单，大致分为：创建订单、支付、打包待发货、已发货、用户签收，业务上处理订单时必须按照先后次序来生产、消费消息，不能出现，已经消费了支付消息，然后消费创建订单消息 局部顺序消息：只要保证同一个订单（相同订单号）生产和消费的先后次序即可 保证全局消息顺序...
RocketMQ (四) 顺序消息
dmjxsy的博客
02-15 1437
RocketMQ(顺序消息)
RocketMQ5.0--顺序消息
专搞技术的小兔子
07-07 304
消费队列负载均衡后，便从重新负载后的消费队列拉取消息，参考​ 《RocketMQ5.0.0消息消费＜一＞ _ PUSH模式的消息拉取》 ​，其中拉取消息DefaultMQPushConsumerImpl#pullMessage方法中，关于顺序消息的代码如下所示。若是被锁定，则向Broker拉取消息成功后，提交到消费线程池中供消费者消费。遍历负载均衡后的每一个消费队列，若新增消费队列时，需要判定是不是顺序消息，若是则向Broker端发送锁定该消费队列（避免其他消费者消费），锁定失败后需要延迟重新负载均衡。
RocketMQ顺序消息机制源码分析~
m0_71777195的博客
08-24 190
RocketMQ为了保证消息的顺序性，分别从Producer和Consumer都有着相应的设计~Producer方面，为保证顺序消息，可自定义MessageQueueSelector来选择队列。例: orderId % msgQueueSize，从而可保证同一个orderId的相关消息，会被发送到同一个队列里。Consumer方面，在整体设计上用了三把锁，来保证消息的顺序消费。定时任务周期性对消费者所属队列加锁消费时对消息队列加锁消息真正被消费前，对processQueue加消费锁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值