RocketMQ源码分析之有序消息（3）

最新推荐文章于 2023-03-21 13:14:27 发布
最新推荐文章于 2023-03-21 13:14:27 发布
阅读量964 收藏
点赞数
分类专栏： RocketMQ 文章标签： RocketMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ph3636/article/details/90294697
版权

执行消费请求任务，判断执行队列的状态是否有效

public void run() {
    if (this.processQueue.isDropped()) {
        log.warn("run, the message queue not be able to consume, because it's dropped. {}", this.messageQueue);
        return;
    }

    final Object objLock = messageQueueLock.fetchLockObject(this.messageQueue);
    synchronized (objLock) {
        if (MessageModel.BROADCASTING.equals(ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl.messageModel())
            || (this.processQueue.isLocked() && !this.processQueue.isLockExpired())) {
            final long beginTime = System.currentTimeMillis();
            for (boolean continueConsume = true; continueConsume; ) {
                if (this.processQueue.isDropped()) {
                    log.warn("the message queue not be able to consume, because it's dropped. {}", this.messageQueue);
                    break;
                }

                if (MessageModel.CLUSTERING.equals(ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl.messageModel())
                    && !this.processQueue.isLocked()) {
                    log.warn("the message queue not locked, so consume later, {}", this.messageQueue);
                    ConsumeMessageOrderlyService.this.tryLockLaterAndReconsume(this.messageQueue, this.processQueue, 10);
                    break;
                }

                if (MessageModel.CLUSTERING.equals(ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl.messageModel())
                    && this.processQueue.isLockExpired()) {
                    log.warn("the message queue lock expired, so consume later, {}", this.messageQueue);
                    ConsumeMessageOrderlyService.this.tryLockLaterAndReconsume(this.messageQueue, this.processQueue, 10);
                    break;
                }

                long interval = System.currentTimeMillis() - beginTime;
                if (interval > MAX_TIME_CONSUME_CONTINUOUSLY) {
                    ConsumeMessageOrderlyService.this.submitConsumeRequestLater(processQueue, messageQueue, 10);
                    break;
                }

                final int consumeBatchSize =
                    ConsumeMessageOrderlyService.this.defaultMQPushConsumer.getConsumeMessageBatchMaxSize();

                List<MessageExt> msgs = this.processQueue.takeMessags(consumeBatchSize);
                if (!msgs.isEmpty()) {
                    final ConsumeOrderlyContext context = new ConsumeOrderlyContext(this.messageQueue);

                    ConsumeOrderlyStatus status = null;

                    ConsumeMessageContext consumeMessageContext = null;
                    if (ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl.hasHook()) {
                        consumeMessageContext = new ConsumeMessageContext();
                        consumeMessageContext
                            .setConsumerGroup(ConsumeMessageOrderlyService.this.defaultMQPushConsumer.getConsumerGroup());
                        consumeMessageContext.setMq(messageQueue);
                        consumeMessageContext.setMsgList(msgs);
                        consumeMessageContext.setSuccess(false);
                        // init the consume context type
                        consumeMessageContext.setProps(new HashMap<String, String>());
                        ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl.executeHookBefore(consumeMessageContext);
                    }

                    long beginTimestamp = System.currentTimeMillis();
                    ConsumeReturnType returnType = ConsumeReturnType.SUCCESS;
                    boolean hasException = false;
                    try {
                        this.processQueue.getLockConsume().lock();
                        if (this.processQueue.isDropped()) {
                            log.warn("consumeMessage, the message queue not be able to consume, because it's dropped. {}",
                                this.messageQueue);
                            break;
                        }

                        status = messageListener.consumeMessage(Collections.unmodifiableList(msgs), context);
                    } catch (Throwable e) {
                        log.warn("consumeMessage exception: {} Group: {} Msgs: {} MQ: {}",
                            RemotingHelper.exceptionSimpleDesc(e),
                            ConsumeMessageOrderlyService.this.consumerGroup,
                            msgs,
                            messageQueue);
                        hasException = true;
                    } finally {
                        this.processQueue.getLockConsume().unlock();
                    }

                    if (null == status
                        || ConsumeOrderlyStatus.ROLLBACK == status
                        || ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT == status) {
                        log.warn("consumeMessage Orderly return not OK, Group: {} Msgs: {} MQ: {}",
                            ConsumeMessageOrderlyService.this.consumerGroup,
                            msgs,
                            messageQueue);
                    }

                    long consumeRT = System.currentTimeMillis() - beginTimestamp;
                    if (null == status) {
                        if (hasException) {
                            returnType = ConsumeReturnType.EXCEPTION;
                        } else {
                            returnType = ConsumeReturnType.RETURNNULL;
                        }
                    } else if (consumeRT >= defaultMQPushConsumer.getConsumeTimeout() * 60 * 1000) {
                        returnType = ConsumeReturnType.TIME_OUT;
                    } else if (ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT == status) {
                        returnType = ConsumeReturnType.FAILED;
                    } else if (ConsumeOrderlyStatus.SUCCESS == status) {
                        returnType = ConsumeReturnType.SUCCESS;
                    }

                    if (ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl.hasHook()) {
                        consumeMessageContext.getProps().put(MixAll.CONSUME_CONTEXT_TYPE, returnType.name());
                    }

                    if (null == status) {
                        status = ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
                    }

                    if (ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl.hasHook()) {
                        consumeMessageContext.setStatus(status.toString());
                        consumeMessageContext
                            .setSuccess(ConsumeOrderlyStatus.SUCCESS == status || ConsumeOrderlyStatus.COMMIT == status);
                        ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl.executeHookAfter(consumeMessageContext);
                    }

                    ConsumeMessageOrderlyService.this.getConsumerStatsManager()
                        .incConsumeRT(ConsumeMessageOrderlyService.this.consumerGroup, messageQueue.getTopic(), consumeRT);

                    continueConsume = ConsumeMessageOrderlyService.this.processConsumeResult(msgs, status, context, this);
                } else {
                    continueConsume = false;
                }
            }
        } else {
            if (this.processQueue.isDropped()) {
                log.warn("the message queue not be able to consume, because it's dropped. {}", this.messageQueue);
                return;
            }

            ConsumeMessageOrderlyService.this.tryLockLaterAndReconsume(this.messageQueue, this.processQueue, 100);
        }
    }
}

获取消息队列对应的消费锁，对消费队列进行锁定，主要是为了防止多个人针对一个消费队列进行消费，然后造成消费顺序可能不一致，虽然前面限制了如果执行队列中有消息的话就不开启新的消费请求任务，假如有个线程正在消费消息，consuming为false，但是消费失败了，需要重新消费，但是新的消息来了之后也会开始新的任务，所以当前面的消息消费失败后，有可能导致后面的消息先消费，因为是两个任务。

public Object fetchLockObject(final MessageQueue mq) {
    Object objLock = this.mqLockTable.get(mq);
    if (null == objLock) {
        objLock = new Object();
        Object prevLock = this.mqLockTable.putIfAbsent(mq, objLock);
        if (prevLock != null) {
            objLock = prevLock;
        }
    }

    return objLock;
}

判断消费模式或者执行队列的锁定状态是否有效，再次判断执行队列的状态，判断任务消费总时长是否超过限制，默认60s，如果不符合这些条件的话，就再次锁定这些消息队列，然后放进定时程序延迟执行


public void tryLockLaterAndReconsume(final MessageQueue mq, final ProcessQueue processQueue,
    final long delayMills) {
    this.scheduledExecutorService.schedule(new Runnable() {
        @Override
        public void run() {
            boolean lockOK = ConsumeMessageOrderlyService.this.lockOneMQ(mq);
            if (lockOK) {
                ConsumeMessageOrderlyService.this.submitConsumeRequestLater(processQueue, mq, 10);
            } else {
                ConsumeMessageOrderlyService.this.submitConsumeRequestLater(processQueue, mq, 3000);
            }
        }
    }, delayMills, TimeUnit.MILLISECONDS);
}

 private void submitConsumeRequestLater(
    final ProcessQueue processQueue,
    final MessageQueue messageQueue,
    final long suspendTimeMillis
) {
    long timeMillis = suspendTimeMillis;
    if (timeMillis == -1) {
        timeMillis = this.defaultMQPushConsumer.getSuspendCurrentQueueTimeMillis();
    }

    if (timeMillis < 10) {
        timeMillis = 10;
    } else if (timeMillis > 30000) {
        timeMillis = 30000;
    }

    this.scheduledExecutorService.schedule(new Runnable() {

        @Override
        public void run() {
            ConsumeMessageOrderlyService.this.submitConsumeRequest(null, processQueue, messageQueue, true);
        }
    }, timeMillis, TimeUnit.MILLISECONDS);
}

默认每次消费一个消息，取出消息，设置最近消费时间，把这次需要消费的消息放进新的消费集合中consumingMsgOrderlyTreeMap，判断总消息集合中是否还有，没有的话就置consuming = false。


public List<MessageExt> takeMessags(final int batchSize) {
    List<MessageExt> result = new ArrayList<MessageExt>(batchSize);
    final long now = System.currentTimeMillis();
    try {
        this.lockTreeMap.writeLock().lockInterruptibly();
        this.lastConsumeTimestamp = now;
        try {
            if (!this.msgTreeMap.isEmpty()) {
                for (int i = 0; i < batchSize; i++) {
                    Map.Entry<Long, MessageExt> entry = this.msgTreeMap.pollFirstEntry();
                    if (entry != null) {
                        result.add(entry.getValue());
                        consumingMsgOrderlyTreeMap.put(entry.getKey(), entry.getValue());
                    } else {
                        break;
                    }
                }
            }

            if (result.isEmpty()) {
                consuming = false;
            }
        } finally {
            this.lockTreeMap.writeLock().unlock();
        }
    } catch (InterruptedException e) {
        log.error("take Messages exception", e);
    }

    return result;
}

判断是否有消息需要被消费，执行钩子方法，对执行队列加消费锁，防止在消费端平衡消息队列时直接移除已经不属于本实例的消费队列对应的执行队列，消息监听器开始消费消息。解析消费结果，默认自动提交偏移量


public boolean processConsumeResult(
    final List<MessageExt> msgs,
    final ConsumeOrderlyStatus status,
    final ConsumeOrderlyContext context,
    final ConsumeRequest consumeRequest
) {
    boolean continueConsume = true;
    long commitOffset = -1L;
    if (context.isAutoCommit()) {
        switch (status) {
            case COMMIT:
            case ROLLBACK:
                log.warn("the message queue consume result is illegal, we think you want to ack these message {}",
                    consumeRequest.getMessageQueue());
            case SUCCESS:
                commitOffset = consumeRequest.getProcessQueue().commit();
                this.getConsumerStatsManager().incConsumeOKTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), msgs.size());
                break;
            case SUSPEND_CURRENT_QUEUE_A_MOMENT:
                this.getConsumerStatsManager().incConsumeFailedTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), msgs.size());
                if (checkReconsumeTimes(msgs)) {
                    consumeRequest.getProcessQueue().makeMessageToCosumeAgain(msgs);
                    this.submitConsumeRequestLater(
                        consumeRequest.getProcessQueue(),
                        consumeRequest.getMessageQueue(),
                        context.getSuspendCurrentQueueTimeMillis());
                    continueConsume = false;
                } else {
                    commitOffset = consumeRequest.getProcessQueue().commit();
                }
                break;
            default:
                break;
        }
    } else {
        switch (status) {
            case SUCCESS:
                this.getConsumerStatsManager().incConsumeOKTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), msgs.size());
                break;
            case COMMIT:
                commitOffset = consumeRequest.getProcessQueue().commit();
                break;
            case ROLLBACK:
                consumeRequest.getProcessQueue().rollback();
                this.submitConsumeRequestLater(
                    consumeRequest.getProcessQueue(),
                    consumeRequest.getMessageQueue(),
                    context.getSuspendCurrentQueueTimeMillis());
                continueConsume = false;
                break;
            case SUSPEND_CURRENT_QUEUE_A_MOMENT:
                this.getConsumerStatsManager().incConsumeFailedTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), msgs.size());
                if (checkReconsumeTimes(msgs)) {
                    consumeRequest.getProcessQueue().makeMessageToCosumeAgain(msgs);
                    this.submitConsumeRequestLater(
                        consumeRequest.getProcessQueue(),
                        consumeRequest.getMessageQueue(),
                        context.getSuspendCurrentQueueTimeMillis());
                    continueConsume = false;
                }
                break;
            default:
                break;
        }
    }

    if (commitOffset >= 0 && !consumeRequest.getProcessQueue().isDropped()) {
        this.defaultMQPushConsumerImpl.getOffsetStore().updateOffset(consumeRequest.getMessageQueue(), commitOffset, false);
    }

    return continueConsume;
}

 

当消费成功后，直接提交偏移量，获取消费的最大偏移量，加一后返回，代表之前偏移量的消息都已经消费了。

public long commit() {
    try {
        this.lockTreeMap.writeLock().lockInterruptibly();
        try {
            Long offset = this.consumingMsgOrderlyTreeMap.lastKey();
            msgCount.addAndGet(0 - this.consumingMsgOrderlyTreeMap.size());
            for (MessageExt msg : this.consumingMsgOrderlyTreeMap.values()) {
                msgSize.addAndGet(0 - msg.getBody().length);
            }
            this.consumingMsgOrderlyTreeMap.clear();
            if (offset != null) {
                return offset + 1;
            }
        } finally {
            this.lockTreeMap.writeLock().unlock();
        }
    } catch (InterruptedException e) {
        log.error("commit exception", e);
    }

    return -1;
}

当没有消费成功时，检查当前消息的消费次数是否已经到达上限，没有到达或者到达后重新发送失败就对消费次数加一后返回true继续消费。


private boolean checkReconsumeTimes(List<MessageExt> msgs) {
    boolean suspend = false;
    if (msgs != null && !msgs.isEmpty()) {
        for (MessageExt msg : msgs) {
            if (msg.getReconsumeTimes() >= getMaxReconsumeTimes()) {
                MessageAccessor.setReconsumeTime(msg, String.valueOf(msg.getReconsumeTimes()));
                if (!sendMessageBack(msg)) {
                    suspend = true;
                    msg.setReconsumeTimes(msg.getReconsumeTimes() + 1);
                }
            } else {
                suspend = true;
                msg.setReconsumeTimes(msg.getReconsumeTimes() + 1);
            }
        }
    }
    return suspend;
}

消费次数到达上限后发送重试消息，当然最后是发送到死信队列中。

public boolean sendMessageBack(final MessageExt msg) {
    try {
        // max reconsume times exceeded then send to dead letter queue.
        Message newMsg = new Message(MixAll.getRetryTopic(this.defaultMQPushConsumer.getConsumerGroup()), msg.getBody());
        String originMsgId = MessageAccessor.getOriginMessageId(msg);
        MessageAccessor.setOriginMessageId(newMsg, UtilAll.isBlank(originMsgId) ? msg.getMsgId() : originMsgId);
        newMsg.setFlag(msg.getFlag());
        MessageAccessor.setProperties(newMsg, msg.getProperties());
        MessageAccessor.putProperty(newMsg, MessageConst.PROPERTY_RETRY_TOPIC, msg.getTopic());
        MessageAccessor.setReconsumeTime(newMsg, String.valueOf(msg.getReconsumeTimes()));
        MessageAccessor.setMaxReconsumeTimes(newMsg, String.valueOf(getMaxReconsumeTimes()));
        newMsg.setDelayTimeLevel(3 + msg.getReconsumeTimes());

        this.defaultMQPushConsumer.getDefaultMQPushConsumerImpl().getmQClientFactory().getDefaultMQProducer().send(newMsg);
        return true;
    } catch (Exception e) {
        log.error("sendMessageBack exception, group: " + this.consumerGroup + " msg: " + msg.toString(), e);
    }

    return false;
}

 

ph3636
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RocketMQ源码分析之有序消息（2）
05-17 362
broker接收消息队列解锁请求 private RemotingCommand unlockBatchMQ(ChannelHandlerContext ctx, RemotingCommand request) throws RemotingCommandException { final RemotingCommand response = RemotingCommand....
RocketMQ 源码分析04消息发送
郭传志的博客
10-01 289
消息发送DefaulMQProducerImpl 一、start方法 对于start方法 1. 状态是CREATE_JUST，代表刚刚创建，没有运行 1.1 检查配置config 1.2 创建mqClientFactory 1.3 注册producer，也就是放入到本地缓存producerTable中 1.4 然后设置producer的主题topicKe...
12.rocketmq源代码学习---顺序消费
Fighting!
01-01 351
顺序消费
Rocketmq-顺序消息底层原理
帅帆的博客
05-14 775
Rocketmq只能保证局部顺序，不能保证全局顺序消息 在RocketMQ中提供了基于队列(分区)的顺序消费。 RocketMQ中顺序性主要指的是消息顺序消费。RocketMQ 中每一个消费组一个单独的线程池并发消费拉取到的消息，即消费端是多线程消费。而顺序消费的并发度等于该消费者分配到的队列数。 RokcetMQ的完成顺序性主要是由3把琐来实现的。下图是RocketMQ顺序消费的工作原理： 1、消费端在启动时首先会进行队列负载机制，遵循一个消费者可以分配多个队列，但一个队列只会被一个消..
顺序消息的实现-RocketMQ知识体系5
WJY_123456的专栏
07-23 194
我们知道，kafka 如果要保证顺序消费，必须保证消息保存到同一个patition上，而且为了有序性，只能有一个消费者进行消费。这种情况下，Kafka 就退化成了单一队列，毫无并发性可言，极大降低系统性能。那么对于对业务比较友好的RocketMQ 是如何实现的呢？首先，我们循序渐进的来了解下顺序消息的实现。顺序消息业务使用场景—1、电商场景中传递订单状态。2、同步mysql 的binlong 日志，数据库的操作是有顺序的。3、其他消息之间有先后的依赖关系，后一条消息需要依赖于前一条消息的处理结果的情况。等等
rocketmq消费失败重试源码分析。
yifouhu2947的博客
03-04 1661
啃了两天这个功能的源码，涉及了好几个模块，终于把这块逻辑啃完了。看完之后有种豁然开朗的感觉。 首先我们要知道一点 消息重试的功能是建立在延迟消费消息这个功能的前提条件之下的。这篇文章会穿插延迟发送消息的一些源码分析。 ① 当消费者（client）启动的时候，将会调用copySubscription()方法。 ②消费端拉取到消息后将拉取到的消息List（最多32条）扔给Cousum...
RocketMQ系列之顺序消息原理解析（八）
sharedCode源码交流
11-10 406
RocketMQ系列之顺序消息原理解析（八）
RocketMQ源码分析(七)之存储设计
jannal专栏
09-15 408
RocketMQ源码-存储设计
RocketMQ源码分析之NameServer（上）
04-20 402
前序 前面几篇是关于RocketMQ的介绍，从这篇开始就根据源码具体解析，分支是master，版本号是4.4.0。 实例化 注册中心的主方法在org/apache/rocketmq/namesrv/NamesrvStartup.java，通过命令行启动可以读取入参配置的具体文件，根据启动命令配置的-c属性读取文件，并设置到注册配置类namesrvConfig和服务端通信配置类nettySer...
深扒RocketMQ源码之后，我找出了RocketMQ消息重复消费的7种原因
最新发布
z1ztai的博客
03-21 288
总得来说，RocketMQ中还是存在很多种导致消息重读消费的情况，并且官方也说了，只是在大多数情况下消息不会重复所以如果你的业务场景中需要保证消息不能重复消费，那么就需要根据业务场景合理的设计幂等技术方案。
RocketMQ源码分析之顺序消费
1Q84emo的博客
02-13 724
概述RocketMQ按照顺序消费有两种顺序级别，一种是普通顺序消息。另外一种是更完全严格顺序 普通顺序消息指的是Producer将消息发送到相对应的消息队列上面 完全严格顺序：在普通顺序消息的基础上，Consumer严格进行顺序消费 在绝大部分情况下只需要用到普通顺序消息，大部分的应用都能容忍短暂的乱序；官方文档给出的说明中表示目前只有数据库的Binlog同步会强依赖完全严格顺序（要保证数据库事务
我要学RocketMQ啦-一文带你看懂普通消息与顺序消息消费逻辑
想好名字再改
08-09 179
首先先看看拉取消息的代码-入口，只有拉取到消息才能够有对应的普通/顺序消息的处理逻辑 public void pullMessage(final PullRequest pullRequest) { final ProcessQueue processQueue = pullRequest.getProcessQueue(); // 省略校验等代码.. 详细注释见我的github // 拉取到消息后的处理 后面会执行拉取 PullCallback pullCallback
RocketMQ-名词和架构
热门推荐
不是很懂
09-29 2万+
RocketMQ rocketMQ是做什么的我就不用解释了吧，以及他的背景。本文主要是为了让大家明白RocketMQ的工作原理。 主要名词解释 ProducerGroup由一组Producer组成 Topic Broker Queue ConsumerGroup
RocketMq重复消费问题排查
weixin_34202952的博客
05-04 1227
前情 出现了重复消费的问题，同一个消息被重复消费了多次，导致了用户端收到了多条重复的消息，最终排查发现，是因为消费者在处理消息的方法onMessage中有异常没有捕获到，导致异常上抛，被consumeMessage捕获并判定为消费失败，从而放到了重试队列当中进行重试，下面我们就来看看RocketMq中会引起消息重试的两种情况，内部异常和消费超时。 源码 在Consumer中处理消息时，会在消费完消...
RocketMQ源码深度解析五之Consumer篇
KilluaZoldyck的博客
08-09 4896
前言：RocketMQ 提供了两种消费模式， PUSH 和 PULL，大多数场景使用的是PUSH模式，这两种模式分别对应的是 DefaultMQPushConsumer 类和DefaultMQPullConsumer 类
rocketmq-深入消费源码
少爷
02-13 651
更多请移步我的博客 对比看两种消费方式的实现：顺序消费与并发消费。这里对顺序消费只关注消费端，不关心producer与broker怎么处理顺序消息，假设架构及策略已保证消息的全局或者局部顺序性。通过构建假定前提，我们可以忽略本次讨论的非重点内容。以下仍以Push方式为例。 消费方式 宏观上看rmq自身是一个生产-消费模式，在他各个角色的具体实现中也不乏生产-消费模式的使用。DefaultMQPus...
RocketMQ源码解析-PushConsumer(3)
不说话装高手
11-08 353
public boolean putMessage(final List&lt;MessageExt&gt; msgs) { boolean dispatchToConsume = false; try { this.lockTreeMap.writeLock().lockInterruptibly(); try { int...
RocketMQ源码深度剖析：消息中转内核机制详解
深入探索RocketMQ源码：透视消息中间件的内核机制 在本文中，作者带领读者走进RocketMQ的世界，从源码环境的搭建开始，逐步剖析其核心组件和功能。首先，搭建源码环境时，建议从Apache RocketMQ GitHub仓库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值