RocketMq4.7源码解析之七(消息消费)

浅浅的花香味﹌ 2022-12-03 05:22 174阅读 0赞

### 文章目录 ###

*  启动流程
 *  消息拉取
 *   *  消息消费客户端发送拉取消息请求
     *  消息服务端Broker处理拉取消息请求
     *  消息消费客户端消费消息
 *  消费消息
 *   *  并发消息
     *  顺序消息
     *   *  启动
         *  负载
         *  拉取
         *  消费
 *  针对业务方返回RECONSUME\_LATER,延迟消息处理
 *   *  broker端接收
 *  消息进度管理
 *   *  广播模式存储
     *  集群模式存储
 *  消息拉取长轮询机制分析
 *   *  PullRequestHoldService
     *  DefaultMessageStore
 *  消息队列负载机制
 *   *  总结
 *  定时消息
 *   *  load
     *  start

消息消费以组的模式开展， 一个消费组内可以包含多个消费者，每一个消费组可订阅多个主题，消费组之间有集群模式与广播模式两种消费模式。

1.  集群模式，主题下的同一条消息只允许被其中一个消费者消费。
2.  广播模式，主题下的同一条消息将被集群内的所有消费者消费一次。

消息服务器与消费者之间的消息传送也有两种方式：

1.  拉模式:消费端主动发起拉消息请求
2.  推模式:消息到达消息服务器后，推送给消息消费者.推模式的实现基于拉模式，在拉模式上包装一层，一个拉取任务完成后开始下一个拉取任务。

集群模式下，多个消费者如何对消息队列进行负载?  
一个消息队列同一时间只允许被一个消费者消费，一个消费者可以消费多个消息队列。

RocketMQ 支持局部顺序消息消费，也就是保证同一个消息队列上的消息顺序消费。不支持消息全局顺序消费， 如果要实现某一主题的全局顺序消息消费， 可以将该主题的队列数设置为1 ，牺牲高可用性。

RocketMQ 支持两种消息过滤模式：表达式（ TAG 、SQL92 ）与类过滤模式。

# 启动流程 #

订阅主题  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center]  
**DefaultMQPushConsumer**

public void subscribe(String topic, String subExpression) throws MQClientException {
        
            this.defaultMQPushConsumerImpl.subscribe(withNamespace(topic), subExpression);
        }

**DefaultMQPushConsumerImpl**

public void subscribe(String topic, String subExpression) throws MQClientException {
        
            try {
        
                //构建主题订阅信息SubscriptionData
                SubscriptionData subscriptionData = FilterAPI.buildSubscriptionData(this.defaultMQPushConsumer.getConsumerGroup(),
                    topic, subExpression);
                //加入到Rebalancelmpl的订阅消息中,以便Rebalancelmpl 进行消息队列负载
                this.rebalanceImpl.getSubscriptionInner().put(topic, subscriptionData);
                if (this.mQClientFactory != null) {
        
                    this.mQClientFactory.sendHeartbeatToAllBrokerWithLock();
                }
            } catch (Exception e) {
        
                throw new MQClientException("subscription exception", e);
            }
        }

**FilterAPI**

public static SubscriptionData buildSubscriptionData(final String consumerGroup, String topic,
            String subString) throws Exception {
        
            SubscriptionData subscriptionData = new SubscriptionData();
            subscriptionData.setTopic(topic);
            subscriptionData.setSubString(subString);
    
            if (null == subString || subString.equals(SubscriptionData.SUB_ALL) || subString.length() == 0) {
        
                //消费这个Topic的所有消息
                subscriptionData.setSubString(SubscriptionData.SUB_ALL);
            } else {
        
                String[] tags = subString.split("\\|\\|");
                if (tags.length > 0) {
        
                    for (String tag : tags) {
        
                        if (tag.length() > 0) {
        
                            String trimString = tag.trim();
                            if (trimString.length() > 0) {
        
                                subscriptionData.getTagsSet().add(trimString);
                                subscriptionData.getCodeSet().add(trimString.hashCode());
                            }
                        }
                    }
                } else {
        
                    throw new Exception("subString split error");
                }
            }
    
            return subscriptionData;
        }

启动  
![在这里插入图片描述][20200904085456440.png_pic_center]  
**DefaultMQPushConsumerImpl**

public synchronized void start() throws MQClientException {
        
            switch (this.serviceState) {
        
                case CREATE_JUST:
                    log.info("the consumer [{}] start beginning. messageModel={}, isUnitMode={}", this.defaultMQPushConsumer.getConsumerGroup(),
                        this.defaultMQPushConsumer.getMessageModel(), this.defaultMQPushConsumer.isUnitMode());
                    this.serviceState = ServiceState.START_FAILED;
                    //校验组为空,是否与默认组相同等
                    this.checkConfig();
    
                    //复制订阅消息,主要兼容setSubscription方法
                    this.copySubscription();
    
                    //同一台服务器部署2个应用程序,且instance为默认值DEFAULT的话,clientId设置为进程id
                    //但是同一jvm中不同消费者和生产者在启动时获取到的MQClientlnstance都是同一个
                    if (this.defaultMQPushConsumer.getMessageModel() == MessageModel.CLUSTERING) {
        
                        //改变生产者的instanceName 为进程ID
                        this.defaultMQPushConsumer.changeInstanceNameToPID();
                    }
                    //初始化MQClientlnstance
                    this.mQClientFactory = MQClientManager.getInstance().getOrCreateMQClientInstance(this.defaultMQPushConsumer, this.rpcHook);
    
                    //初始化Rebalancelmple(消息重新负载实现类)
                    this.rebalanceImpl.setConsumerGroup(this.defaultMQPushConsumer.getConsumerGroup());
                    this.rebalanceImpl.setMessageModel(this.defaultMQPushConsumer.getMessageModel());
                    this.rebalanceImpl.setAllocateMessageQueueStrategy(this.defaultMQPushConsumer.getAllocateMessageQueueStrategy());
                    this.rebalanceImpl.setmQClientFactory(this.mQClientFactory);
    
                    this.pullAPIWrapper = new PullAPIWrapper(
                        mQClientFactory,
                        this.defaultMQPushConsumer.getConsumerGroup(), isUnitMode());
                    this.pullAPIWrapper.registerFilterMessageHook(filterMessageHookList);
    
                    //初始化消息进度
                    if (this.defaultMQPushConsumer.getOffsetStore() != null) {
        
                        this.offsetStore = this.defaultMQPushConsumer.getOffsetStore();
                    } else {
        
                        switch (this.defaultMQPushConsumer.getMessageModel()) {
        
                            case BROADCASTING:
                                //如果是广播模式，那么消息消费进度存储在消费端
                                this.offsetStore = new LocalFileOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
                                break;
                            case CLUSTERING:
                                //如果消息消费是集群模式，那么消息进度保存在Broker 上
                                this.offsetStore = new RemoteBrokerOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
                                break;
                            default:
                                break;
                        }
                        this.defaultMQPushConsumer.setOffsetStore(this.offsetStore);
                    }
                    this.offsetStore.load();//空实现
    
                    //是否是顺序消费
                    if (this.getMessageListenerInner() instanceof MessageListenerOrderly) {
        
                        this.consumeOrderly = true;
                        //创建消费端消费线程服务,主要负责消息消费，内部维护一个线程池。
                        this.consumeMessageService =
                            new ConsumeMessageOrderlyService(this, (MessageListenerOrderly) this.getMessageListenerInner());
                    } else if (this.getMessageListenerInner() instanceof MessageListenerConcurrently) {
        
                        //并发消息
                        this.consumeOrderly = false;
                        this.consumeMessageService =
                            new ConsumeMessageConcurrentlyService(this, (MessageListenerConcurrently) this.getMessageListenerInner());
                    }
    
                    this.consumeMessageService.start();
    
                    //向MQClientlnstance 注册消费者
                    boolean registerOK = mQClientFactory.registerConsumer(this.defaultMQPushConsumer.getConsumerGroup(), this);
                    //注册失败处理
                    if (!registerOK) {
        
                        this.serviceState = ServiceState.CREATE_JUST;
                        this.consumeMessageService.shutdown(defaultMQPushConsumer.getAwaitTerminationMillisWhenShutdown());
                        throw new MQClientException("The consumer group[" + this.defaultMQPushConsumer.getConsumerGroup()
                            + "] has been created before, specify another name please." + FAQUrl.suggestTodo(FAQUrl.GROUP_NAME_DUPLICATE_URL),
                            null);
                    }
    
                    //启动MQClientlnstance
                    // 在一个JVM中的所有消费者、生产者持有同一个MQClientlnstance, MQClientlnstance 只会启动一次。
                    mQClientFactory.start();
                    log.info("the consumer [{}] start OK.", this.defaultMQPushConsumer.getConsumerGroup());
                    //更新状态
                    this.serviceState = ServiceState.RUNNING;
                    break;
                case RUNNING:
                case START_FAILED:
                case SHUTDOWN_ALREADY:
                    throw new MQClientException("The PushConsumer service state not OK, maybe started once, "
                        + this.serviceState
                        + FAQUrl.suggestTodo(FAQUrl.CLIENT_SERVICE_NOT_OK),
                        null);
                default:
                    break;
            }
    
            this.updateTopicSubscribeInfoWhenSubscriptionChanged();
            this.mQClientFactory.checkClientInBroker();
            this.mQClientFactory.sendHeartbeatToAllBrokerWithLock();
            this.mQClientFactory.rebalanceImmediately();
        }

复制订阅消息,主要兼容setSubscription方法  
**DefaultMQPushConsumerImpl**

private void copySubscription() throws MQClientException {
        
            try {
        
                //rebalanceImpl数据来源2个,第一个通过调用consumer.subscribe("TopicTest", "*");
                //第二个订阅重试主题消息
                //这里主要兼容setSubscription方法,现在已经不推荐使用了.
                Map<String, String> sub = this.defaultMQPushConsumer.getSubscription();
                if (sub != null) {
        
                    for (final Map.Entry<String, String> entry : sub.entrySet()) {
        
                        final String topic = entry.getKey();
                        final String subString = entry.getValue();
                        //构建主题订阅信息SubscriptionData
                        SubscriptionData subscriptionData = FilterAPI.buildSubscriptionData(this.defaultMQPushConsumer.getConsumerGroup(),
                            topic, subString);
                        //加入到Rebalancelmpl 的订阅消息中
                        this.rebalanceImpl.getSubscriptionInner().put(topic, subscriptionData);
                    }
                }
    
                if (null == this.messageListenerInner) {
        
                    this.messageListenerInner = this.defaultMQPushConsumer.getMessageListener();
                }
    
                switch (this.defaultMQPushConsumer.getMessageModel()) {
        
                    case BROADCASTING:
                        break;
                    case CLUSTERING:
                        //订阅重试主题消息
                        //RocketMQ 消息重试是以消费组为单位，而不是主题，
                        // 消息重试主题名为%RETRY%＋消费组名。
                        final String retryTopic = MixAll.getRetryTopic(this.defaultMQPushConsumer.getConsumerGroup());
                        SubscriptionData subscriptionData = FilterAPI.buildSubscriptionData(this.defaultMQPushConsumer.getConsumerGroup(),
                            retryTopic, SubscriptionData.SUB_ALL);
                        // 消费者在启动的时候会自动订阅该主题，参与该主题的消息队列负载。
                        this.rebalanceImpl.getSubscriptionInner().put(retryTopic, subscriptionData);
                        break;
                    default:
                        break;
                }
            } catch (Exception e) {
        
                throw new MQClientException("subscription exception", e);
            }
        }

构建订阅者信息  
**FilterAPI**

public static SubscriptionData buildSubscriptionData(final String consumerGroup, String topic,
            String subString) throws Exception {
        
            SubscriptionData subscriptionData = new SubscriptionData();
            subscriptionData.setTopic(topic);
            subscriptionData.setSubString(subString);
    
            if (null == subString || subString.equals(SubscriptionData.SUB_ALL) || subString.length() == 0) {
        
                //消费这个Topic的所有消息
                subscriptionData.setSubString(SubscriptionData.SUB_ALL);
            } else {
        
                //分割多个tag
                String[] tags = subString.split("\\|\\|");
                if (tags.length > 0) {
        
                    for (String tag : tags) {
        
                        if (tag.length() > 0) {
        
                            String trimString = tag.trim();
                            if (trimString.length() > 0) {
        
                                subscriptionData.getTagsSet().add(trimString);
                                subscriptionData.getCodeSet().add(trimString.hashCode());
                            }
                        }
                    }
                } else {
        
                    throw new Exception("subString split error");
                }
            }
    
            return subscriptionData;
        }

# 消息拉取 #

## 消息消费客户端发送拉取消息请求 ##

基于推模式进行分析.  
**MQClientInstance**

public void start() throws MQClientException {
        
    
            synchronized (this) {
        
                switch (this.serviceState) {
        
                        //默认当前状态
                    case CREATE_JUST:
                        this.serviceState = ServiceState.START_FAILED;
                        // If not specified,looking address from name server
                        if (null == this.clientConfig.getNamesrvAddr()) {
        
                            this.mQClientAPIImpl.fetchNameServerAddr();
                        }
                        // Start request-response channel
                        this.mQClientAPIImpl.start();
                        // Start various schedule tasks
                        this.startScheduledTask();
                        // Start pull service
                        //单独开启一个线程,负责消息的拉取
                        this.pullMessageService.start();
                        // Start rebalance service
                        this.rebalanceService.start();
                        // Start push service
                        this.defaultMQProducer.getDefaultMQProducerImpl().start(false);
                        log.info("the client factory [{}] start OK", this.clientId);
                        this.serviceState = ServiceState.RUNNING;
                        break;
                    case START_FAILED:
                        throw new MQClientException("The Factory object[" + this.getClientId() + "] has been created before, and failed.", null);
                    default:
                        break;
                }
            }
        }

**ServiceThread**

public void start() {
        
            log.info("Try to start service thread:{} started:{} lastThread:{}", getServiceName(), started.get(), thread);
            if (!started.compareAndSet(false, true)) {
        
                return;
            }
            //设置启动标识
            stopped = false;
            //新建一个线程
            this.thread = new Thread(this, getServiceName());
            this.thread.setDaemon(isDaemon);
            //运行当前类run方法
            this.thread.start();
        }

拉取消息  
**PullMessageService**

public void run() {
        
            log.info(this.getServiceName() + " service started");
    
            //是否停止
            while (!this.isStopped()) {
        
                try {
        
                    //获取一个pullRequest消息拉取任务,因为是阻塞队列,么有数据时会阻塞.
                    PullRequest pullRequest = this.pullRequestQueue.take();
                    //拉取消息
                    this.pullMessage(pullRequest);
                } catch (InterruptedException ignored) {
        
                } catch (Exception e) {
        
                    log.error("Pull Message Service Run Method exception", e);
                }
            }
    
            log.info(this.getServiceName() + " service end");
        }

这里可以看到pullRequestQueue为阻塞队列,也就是说当没有数据的时候他会阻塞.  
![在这里插入图片描述][20200904104251304.png_pic_center]  
那队列数据从哪儿来的了？  
RocketMQ分别提供了2种添加方式.将PullRequest放入pullRequestQueue.

/**
         * 延时添加消息拉取任务
         * @param pullRequest
         * @param timeDelay
         */
        public void executePullRequestLater(final PullRequest pullRequest, final long timeDelay) {
        
            if (!isStopped()) {
        
                this.scheduledExecutorService.schedule(new Runnable() {
        
                    @Override
                    public void run() {
        
                        PullMessageService.this.executePullRequestImmediately(pullRequest);
                    }
                }, timeDelay, TimeUnit.MILLISECONDS);
            } else {
        
                log.warn("PullMessageServiceScheduledThread has shutdown");
            }
        }
    
        public void executePullRequestImmediately(final PullRequest pullRequest) {
        
            try {
        
                //立即添加消息拉取任务
                this.pullRequestQueue.put(pullRequest);
            } catch (InterruptedException e) {
        
                log.error("executePullRequestImmediately pullRequestQueue.put", e);
            }
        }

在这里强转成DefaultMQPushConsumerImpl,说PullMessageService与DefaultMQPushConsumerImpl绑定.也就是PullMessageService只为推模式服务.这里实现了策略模式.如果采用拉的模式,那么也会开启一个针对拉服务的线程处理  
**PullMessageService**

private void pullMessage(final PullRequest pullRequest) {
        
            final MQConsumerInner consumer = this.mQClientFactory.selectConsumer(pullRequest.getConsumerGroup());
            if (consumer != null) {
        
                //在这里强转成DefaultMQPushConsumerImpl,说明PullMessageService与DefaultMQPushConsumerImpl绑定
                //也就是PullMessageService只为推模式服务.这里实现了策略模式.如果采用拉的模式,那么也会开启一个针对拉服务的线程处理
                DefaultMQPushConsumerImpl impl = (DefaultMQPushConsumerImpl) consumer;
                impl.pullMessage(pullRequest);
            } else {
        
                log.warn("No matched consumer for the PullRequest {}, drop it", pullRequest);
            }
        }

客户端封装拉取请求,发送broker  
**DefaultMQPushConsumerImpl**

public void pullMessage(final PullRequest pullRequest) {
        
            //从PullRequest中获取ProcessQueue
            final ProcessQueue processQueue = pullRequest.getProcessQueue();
            //处理队列当前状态是否被丢弃
            if (processQueue.isDropped()) {
        
                log.info("the pull request[{}] is dropped.", pullRequest.toString());
                return;
            }
    
            //更新ProcessQueue 的lastPullTimestamp 为当前时间戳
            pullRequest.getProcessQueue().setLastPullTimestamp(System.currentTimeMillis());
    
            try {
        
                //检测状态是否为RUNNING
                this.makeSureStateOK();
            } catch (MQClientException e) {
        
                log.warn("pullMessage exception, consumer state not ok", e);
                this.executePullRequestLater(pullRequest, pullTimeDelayMillsWhenException);
                return;
            }
    
            //如果当前消费者被挂起
            if (this.isPause()) {
        
                log.warn("consumer was paused, execute pull request later. instanceName={}, group={}", this.defaultMQPushConsumer.getInstanceName(), this.defaultMQPushConsumer.getConsumerGroup());
                //将拉取任务延迟ls 再次放入到PullMessageService 的拉取任务队列中，结束本次消息拉取
                this.executePullRequestLater(pullRequest, PULL_TIME_DELAY_MILLS_WHEN_SUSPEND);
                return;
            }
    
            //进行消息拉取流控
            long cachedMessageCount = processQueue.getMsgCount().get();
            long cachedMessageSizeInMiB = processQueue.getMsgSize().get() / (1024 * 1024);
    
            //如果ProcessQueue 当前处理的消息条数超过了PullThresholdForQueue=1000 将触发流控，放弃本次拉取任务
            if (cachedMessageCount > this.defaultMQPushConsumer.getPullThresholdForQueue()) {
        
                //该队列的下一次拉取任务将在50 毫秒后才加入到拉取任务队列中，
                this.executePullRequestLater(pullRequest, PULL_TIME_DELAY_MILLS_WHEN_FLOW_CONTROL);
                //每触发1000 次输出提示语
                if ((queueFlowControlTimes++ % 1000) == 0) {
        
                    log.warn(
                        "the cached message count exceeds the threshold {}, so do flow control, minOffset={}, maxOffset={}, count={}, size={} MiB, pullRequest={}, flowControlTimes={}",
                        this.defaultMQPushConsumer.getPullThresholdForQueue(), processQueue.getMsgTreeMap().firstKey(), processQueue.getMsgTreeMap().lastKey(), cachedMessageCount, cachedMessageSizeInMiB, pullRequest, queueFlowControlTimes);
                }
                return;
            }
    
            //缓存的大小超过阀值100M,否则触发流控，
            if (cachedMessageSizeInMiB > this.defaultMQPushConsumer.getPullThresholdSizeForQueue()) {
        
                this.executePullRequestLater(pullRequest, PULL_TIME_DELAY_MILLS_WHEN_FLOW_CONTROL);
                if ((queueFlowControlTimes++ % 1000) == 0) {
        
                    log.warn(
                        "the cached message size exceeds the threshold {} MiB, so do flow control, minOffset={}, maxOffset={}, count={}, size={} MiB, pullRequest={}, flowControlTimes={}",
                        this.defaultMQPushConsumer.getPullThresholdSizeForQueue(), processQueue.getMsgTreeMap().firstKey(), processQueue.getMsgTreeMap().lastKey(), cachedMessageCount, cachedMessageSizeInMiB, pullRequest, queueFlowControlTimes);
                }
                return;
            }
    
            //并发消息处理
            if (!this.consumeOrderly) {
        
                //ProcessQueue 中队列最大偏移量与最小偏离量的间距， 不能超过consumeConcurrentlyMaxSpan，否则触发流控，
                if (processQueue.getMaxSpan() > this.defaultMQPushConsumer.getConsumeConcurrentlyMaxSpan()) {
        
                    this.executePullRequestLater(pullRequest, PULL_TIME_DELAY_MILLS_WHEN_FLOW_CONTROL);
                    //每触发1000 次输出提示语
                    if ((queueMaxSpanFlowControlTimes++ % 1000) == 0) {
        
                        log.warn(
                            "the queue's messages, span too long, so do flow control, minOffset={}, maxOffset={}, maxSpan={}, pullRequest={}, flowControlTimes={}",
                            processQueue.getMsgTreeMap().firstKey(), processQueue.getMsgTreeMap().lastKey(), processQueue.getMaxSpan(),
                            pullRequest, queueMaxSpanFlowControlTimes);
                    }
                    return;
                }
            } else {
        
                //如果消息处理队列被锁定
                if (processQueue.isLocked()) {
        
                    if (!pullRequest.isLockedFirst()) {
        
                        final long offset = this.rebalanceImpl.computePullFromWhere(pullRequest.getMessageQueue());
                        boolean brokerBusy = offset < pullRequest.getNextOffset();
                        log.info("the first time to pull message, so fix offset from broker. pullRequest: {} NewOffset: {} brokerBusy: {}",
                            pullRequest, offset, brokerBusy);
                        if (brokerBusy) {
        
                            log.info("[NOTIFYME]the first time to pull message, but pull request offset larger than broker consume offset. pullRequest: {} NewOffset: {}",
                                pullRequest, offset);
                        }
    
                        pullRequest.setLockedFirst(true);
                        pullRequest.setNextOffset(offset);
                    }
                } else {
        
                    //如果消息处理队列未被锁定,延迟3s 后再将PullRequest 对象放入到拉取任务中
                    this.executePullRequestLater(pullRequest, pullTimeDelayMillsWhenException);
                    log.info("pull message later because not locked in broker, {}", pullRequest);
                    return;
                }
            }
    
            //拉取该主题订阅信息
            final SubscriptionData subscriptionData = this.rebalanceImpl.getSubscriptionInner().get(pullRequest.getMessageQueue().getTopic());
            //如果为空，结束本次消息拉取
            if (null == subscriptionData) {
        
                //关于该队列的下一次拉取任务延迟3s
                this.executePullRequestLater(pullRequest, pullTimeDelayMillsWhenException);
                log.warn("find the consumer's subscription failed, {}", pullRequest);
                return;
            }
    
            final long beginTimestamp = System.currentTimeMillis();
    
            //拉取消息回调函数,org.apache.rocketmq.client.impl.MQClientAPIImpl.pullMessageAsync调用
            PullCallback pullCallback = new PullCallback() {
        
                @Override
                public void onSuccess(PullResult pullResult) {
        
                    if (pullResult != null) {
        
                        //将消息字节数组解码成消息列表填充msgFoundList ，井对消息进行消息过滤（ TAG ）模式
                        pullResult = DefaultMQPushConsumerImpl.this.pullAPIWrapper.processPullResult(pullRequest.getMessageQueue(), pullResult,
                            subscriptionData);
    
                        //根据从Broker 返回的消息类型做相应的处理
                        switch (pullResult.getPullStatus()) {
        
                            case FOUND:
                                long prevRequestOffset = pullRequest.getNextOffset();
                                //更新PullRequest 的下一次拉取偏移量
                                pullRequest.setNextOffset(pullResult.getNextBeginOffset());
                                long pullRT = System.currentTimeMillis() - beginTimestamp;
                                DefaultMQPushConsumerImpl.this.getConsumerStatsManager().incPullRT(pullRequest.getConsumerGroup(),
                                    pullRequest.getMessageQueue().getTopic(), pullRT);
    
                                long firstMsgOffset = Long.MAX_VALUE;
                                //如果msgFoundList 为空
                                if (pullResult.getMsgFoundList() == null || pullResult.getMsgFoundList().isEmpty()) {
        
                                    //将PullReqeuest 放入到PullMessageService 的pullRequestQueue
                                    //以便PullMessageSerivce 能立即及时唤醒并再次执行消息拉取。
                                    //之所以会出现msgFoundList 为空的情况,
                                    //是因为在RocketMQ 根据TAG 消息过滤，
                                    //在服务端只是验证了TAG的hashcode ，在客户端再次对消息进行过滤
                                    DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                                } else {
        
                                    firstMsgOffset = pullResult.getMsgFoundList().get(0).getQueueOffset();
    
                                    DefaultMQPushConsumerImpl.this.getConsumerStatsManager().incPullTPS(pullRequest.getConsumerGroup(),
                                        pullRequest.getMessageQueue().getTopic(), pullResult.getMsgFoundList().size());
    
                                    //将拉取到的消息存入ProcessQueue
                                    boolean dispatchToConsume = processQueue.putMessage(pullResult.getMsgFoundList());
                                    //异步将拉取到的消息提交到ConsumeMessageService中供消费者消费
                                    DefaultMQPushConsumerImpl.this.consumeMessageService.submitConsumeRequest(
                                        pullResult.getMsgFoundList(),
                                        processQueue,
                                        pullRequest.getMessageQueue(),
                                        dispatchToConsume);
    
                                    if (DefaultMQPushConsumerImpl.this.defaultMQPushConsumer.getPullInterval() > 0) {
        
                                       /* 等待pulllnterval 毫秒后
                                        将PullRequest 对象放入到PullMessageService 的pullRequestQueue 中，
                                        该消息队列的下次拉取即将被激活，达到持续消息拉取，实现准实时拉取消息的效果。*/
                                        DefaultMQPushConsumerImpl.this.executePullRequestLater(pullRequest,
                                            DefaultMQPushConsumerImpl.this.defaultMQPushConsumer.getPullInterval());
                                    } else {
        
                                        DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                                    }
                                }
    
                                if (pullResult.getNextBeginOffset() < prevRequestOffset
                                    || firstMsgOffset < prevRequestOffset) {
        
                                    log.warn(
                                        "[BUG] pull message result maybe data wrong, nextBeginOffset: {} firstMsgOffset: {} prevRequestOffset: {}",
                                        pullResult.getNextBeginOffset(),
                                        firstMsgOffset,
                                        prevRequestOffset);
                                }
    
                                break;
                            case NO_NEW_MSG:
                                //NO_NEW_MSG ，对应GetMessageResult
    
                                //OFFSET_OVERFLOW_ONE:：待拉取offset 等于消息队列最大的偏移量，如果有新的
                                //消息到达， 此时会创建一个新的ConsumeQueue 文件，按照上一个ConsueQueue 的最大偏
                                //移量就是下一个文件的起始偏移量，所以如果按照该offset 第二次拉取消息时能成功。
    
                                //OFFSET_FOUND_ NULL:是根据Consumequeue 的偏移量没有找到内容，将偏移量
                                //定位到下一个ConsumeQueue ，其实就是offset ＋（ 一个ConsumeQueue 包含多少个条目=MappedFileSize/20 ） 。
                                pullRequest.setNextOffset(pullResult.getNextBeginOffset());
    
                                DefaultMQPushConsumerImpl.this.correctTagsOffset(pullRequest);
    
                                DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                                break;
                            case NO_MATCHED_MSG:
                                pullRequest.setNextOffset(pullResult.getNextBeginOffset());
    
                                DefaultMQPushConsumerImpl.this.correctTagsOffset(pullRequest);
    
                                DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                                break;
                            case OFFSET_ILLEGAL:
                                //如果拉取结果显示偏移量非法
                                log.warn("the pull request offset illegal, {} {}",
                                    pullRequest.toString(), pullResult.toString());
                                pullRequest.setNextOffset(pullResult.getNextBeginOffset());
    
                                //设置dropped 为ture ， 表示丢弃该消费队列，
                                /*
                                意味着ProcessQueue 中拉取的消息将停止消费，然后根据服务端下一次校
                                对的偏移量尝试更新消息消费进度（ 内存中），然后尝试持久化消息消费进度，并将该消
                                息队列从Rebalacnlmpl 的处理队列中移除，意味着暂停该消息队列的消息拉取，等待下
                                一次消息队列重新负载。
                                 */
                                pullRequest.getProcessQueue().setDropped(true);
                                DefaultMQPushConsumerImpl.this.executeTaskLater(new Runnable() {
        
    
                                    @Override
                                    public void run() {
        
                                        try {
        
                                            DefaultMQPushConsumerImpl.this.offsetStore.updateOffset(pullRequest.getMessageQueue(),
                                                pullRequest.getNextOffset(), false);
    
                                            DefaultMQPushConsumerImpl.this.offsetStore.persist(pullRequest.getMessageQueue());
    
                                            DefaultMQPushConsumerImpl.this.rebalanceImpl.removeProcessQueue(pullRequest.getMessageQueue());
    
                                            log.warn("fix the pull request offset, {}", pullRequest);
                                        } catch (Throwable e) {
        
                                            log.error("executeTaskLater Exception", e);
                                        }
                                    }
                                }, 10000);
                                break;
                            default:
                                break;
                        }
                    }
                }
    
                @Override
                public void onException(Throwable e) {
        
                    if (!pullRequest.getMessageQueue().getTopic().startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)) {
        
                        log.warn("execute the pull request exception", e);
                    }
    
                    DefaultMQPushConsumerImpl.this.executePullRequestLater(pullRequest, pullTimeDelayMillsWhenException);
                }
            };
    
            //从内存中读取的消费进度大于0 ，则设置该标记位。
            boolean commitOffsetEnable = false;
            long commitOffsetValue = 0L;
            if (MessageModel.CLUSTERING == this.defaultMQPushConsumer.getMessageModel()) {
        
                //从内存中读取消息消费进度
                commitOffsetValue = this.offsetStore.readOffset(pullRequest.getMessageQueue(), ReadOffsetType.READ_FROM_MEMORY);
                if (commitOffsetValue > 0) {
        
                    commitOffsetEnable = true;
                }
            }
    
            //消息过滤机制为表达式， 则设置该标记位。
            String subExpression = null;
            //消息过滤机制为类过滤模式。
            boolean classFilter = false;
            SubscriptionData sd = this.rebalanceImpl.getSubscriptionInner().get(pullRequest.getMessageQueue().getTopic());
            if (sd != null) {
        
                //是否每次拉取消息都更新订阅信息，默认为false
                if (this.defaultMQPushConsumer.isPostSubscriptionWhenPull() &&
                //是否是类过滤模式，默认为false 。
                        !sd.isClassFilterMode()) {
        
                    subExpression = sd.getSubString();
                }
    
                classFilter = sd.isClassFilterMode();
            }
    
            //根据订阅消息构建消息拉取标记，设置subExpression 、classFilter 消息过滤信息。
            int sysFlag = PullSysFlag.buildSysFlag(
                commitOffsetEnable, // commitOffset
                true, // suspend 表示消息拉取时支持挂起。
                subExpression != null, // subscription
                classFilter // class filter
            );
            try {
        
                //与服务端交互拉取数据
                this.pullAPIWrapper.pullKernelImpl(
                    pullRequest.getMessageQueue(),
                    subExpression,
                    subscriptionData.getExpressionType(),
                    subscriptionData.getSubVersion(),
                    pullRequest.getNextOffset(),
                    this.defaultMQPushConsumer.getPullBatchSize(),
                    sysFlag,
                    commitOffsetValue,
                    BROKER_SUSPEND_MAX_TIME_MILLIS,
                    CONSUMER_TIMEOUT_MILLIS_WHEN_SUSPEND,
                    CommunicationMode.ASYNC,
                    pullCallback
                );
            } catch (Exception e) {
        
                log.error("pullKernelImpl exception", e);
                this.executePullRequestLater(pullRequest, pullTimeDelayMillsWhenException);
            }
        }

从内存中读取消息消费进度  
**RemoteBrokerOffsetStore**

public long readOffset(final MessageQueue mq, final ReadOffsetType type) {
        
            if (mq != null) {
        
                switch (type) {
        
                    case MEMORY_FIRST_THEN_STORE:
                    case READ_FROM_MEMORY: {
        
                        //从内存中获取偏移数据
                        AtomicLong offset = this.offsetTable.get(mq);
                        if (offset != null) {
        
                            return offset.get();
                        } else if (ReadOffsetType.READ_FROM_MEMORY == type) {
        
                            return -1;
                        }
                    }
                    case READ_FROM_STORE: {
        
                        try {
        
                            long brokerOffset = this.fetchConsumeOffsetFromBroker(mq);
                            AtomicLong offset = new AtomicLong(brokerOffset);
                            this.updateOffset(mq, offset.get(), false);
                            return brokerOffset;
                        }
                        // No offset in broker
                        catch (MQBrokerException e) {
        
                            return -1;
                        }
                        //Other exceptions
                        catch (Exception e) {
        
                            log.warn("fetchConsumeOffsetFromBroker exception, " + mq, e);
                            return -2;
                        }
                    }
                    default:
                        break;
                }
            }
    
            return -1;
        }

与服务端交互拉取数据  
**PullAPIWrapper**

public PullResult pullKernelImpl(
                //从哪个消息消费队列拉取消息
            final MessageQueue mq,
                //消息过滤表达式
            final String subExpression,
            //消息表达式类型，分为TAG 、SQL92 。
            final String expressionType,
            final long subVersion,
            //消息拉取偏移量。
            final long offset,
            //本次拉取最大消息条数，默认32 条。
            final int maxNums,
            //拉取系统标记
            final int sysFlag,
            //当前M巳ssageQueue 的消费进度（内存中）
            final long commitOffset,
            //消息拉取过程中允许Broker 挂起时间，默认15s 。
            final long brokerSuspendMaxTimeMillis,
            //消息拉取超时时间。
            final long timeoutMillis,
            //消息拉取模式，默认为异步拉取。
            final CommunicationMode communicationMode,
            //从Broker 拉取到消息后的回调方法。
            final PullCallback pullCallback
        ) throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
        
            //根据brokerName 、BrokerId 从MQClientlnstance 中获取Broker 地址，
            FindBrokerResult findBrokerResult =
                this.mQClientFactory.findBrokerAddressInSubscribe(mq.getBrokerName(),
                    //重新计算从哪个节点获取
                    this.recalculatePullFromWhichNode(mq), false);
            if (null == findBrokerResult) {
        
                //更改topic路由信息,从nameServer
                this.mQClientFactory.updateTopicRouteInfoFromNameServer(mq.getTopic());
                findBrokerResult =
                    this.mQClientFactory.findBrokerAddressInSubscribe(mq.getBrokerName(),
                        this.recalculatePullFromWhichNode(mq), false);
            }
    
            if (findBrokerResult != null) {
        
                {
        
                    // check version 校验版本,是否根据TAG过滤
                    if (!ExpressionType.isTagType(expressionType)
                        && findBrokerResult.getBrokerVersion() < MQVersion.Version.V4_1_0_SNAPSHOT.ordinal()) {
        
                        throw new MQClientException("The broker[" + mq.getBrokerName() + ", "
                            + findBrokerResult.getBrokerVersion() + "] does not upgrade to support for filter message by " + expressionType, null);
                    }
                }
                int sysFlagInner = sysFlag;
    
                if (findBrokerResult.isSlave()) {
        
                    sysFlagInner = PullSysFlag.clearCommitOffsetFlag(sysFlagInner);
                }
    
                PullMessageRequestHeader requestHeader = new PullMessageRequestHeader();
                requestHeader.setConsumerGroup(this.consumerGroup);
                requestHeader.setTopic(mq.getTopic());
                requestHeader.setQueueId(mq.getQueueId());
                requestHeader.setQueueOffset(offset);
                requestHeader.setMaxMsgNums(maxNums);
                requestHeader.setSysFlag(sysFlagInner);
                requestHeader.setCommitOffset(commitOffset);
                //设置Broker 最长阻塞时间，默认设置是15 秒，注
                //意是Broker 在没有新消息的时候才阻塞，有消息会立刻返回。
                requestHeader.setSuspendTimeoutMillis(brokerSuspendMaxTimeMillis);
                requestHeader.setSubscription(subExpression);
                requestHeader.setSubVersion(subVersion);
                requestHeader.setExpressionType(expressionType);
    
                String brokerAddr = findBrokerResult.getBrokerAddr();
                //如果消息过滤模式为类过滤
                if (PullSysFlag.hasClassFilterFlag(sysFlagInner)) {
        
                    //则需要根据主题名称、broker 地址找到注册在Broker 上的FilterServer 地址，从FilterServer 上拉取消息，否则从Broker 上拉取消息。
                    brokerAddr = computPullFromWhichFilterServer(mq.getTopic(), brokerAddr);
                }
    
                //向Broker 拉取消息
                PullResult pullResult = this.mQClientFactory.getMQClientAPIImpl().pullMessage(
                    brokerAddr,
                    requestHeader,
                    timeoutMillis,
                    communicationMode,
                    pullCallback);
    
                return pullResult;
            }
    
            throw new MQClientException("The broker[" + mq.getBrokerName() + "] not exist", null);
        }

根据brokerName 、BrokerId 从MQClientlnstance 中获取Broker 地址  
**MQClientInstance**

public FindBrokerResult findBrokerAddressInSubscribe(
            final String brokerName,
            final long brokerId,
            final boolean onlyThisBroker
        ) {
        
            String brokerAddr = null;
            boolean slave = false;
            boolean found = false;
    
            HashMap<Long/* brokerId */, String/* address */> map = this.brokerAddrTable.get(brokerName);
            if (map != null && !map.isEmpty()) {
        
                brokerAddr = map.get(brokerId);
                //标记是否是slave
                slave = brokerId != MixAll.MASTER_ID;
                //标记是否找到
                found = brokerAddr != null;
    
                if (!found && !onlyThisBroker) {
        
                    Entry<Long, String> entry = map.entrySet().iterator().next();
                    brokerAddr = entry.getValue();
                    slave = entry.getKey() != MixAll.MASTER_ID;
                    found = true;
                }
            }
    
            //找到地址,则创建FindBrokerResult
            if (found) {
        
                return new FindBrokerResult(brokerAddr, slave, findBrokerVersion(brokerName, brokerAddr));
            }
    
            return null;
        }

向Broker 拉取消息

public PullResult pullMessage(
            final String addr,
            final PullMessageRequestHeader requestHeader,
            final long timeoutMillis,
            final CommunicationMode communicationMode,
            final PullCallback pullCallback
        ) throws RemotingException, MQBrokerException, InterruptedException {
        
            //执行PULL_MESSAGE拉取命令
            RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.PULL_MESSAGE, requestHeader);
    
            switch (communicationMode) {
        
                case ONEWAY:
                    assert false;
                    return null;
                case ASYNC:
                    //异步向Broker 拉取消息
                    this.pullMessageAsync(addr, request, timeoutMillis, pullCallback);
                    return null;
                case SYNC:
                    return this.pullMessageSync(addr, request, timeoutMillis);
                default:
                    assert false;
                    break;
            }
    
            return null;
        }

## 消息服务端Broker处理拉取消息请求 ##

**PullMessageProcessor**

/**
         * Brokder端处理消息拉取
         * @param channel  网络通道，通过该通道向消息拉取客户端发送响应结果。
         * @param request 消息、拉取请求
         * @param brokerAllowSuspend  Broker 端是否支持挂起，处理消息拉取时默认传入true,表示支持如果未找到消息则挂起，
         *                                      将响应对象response设置为null 将不会立即向客户端写入响应，
         *                                      hasSuspendFlag 参数在拉取消息时构建的拉取标记，默认为true 。
         *                                  如果该参数为false未找到消息时直接返回客户端消息未找到。
         *
         *                            根据是否开启长轮询来决定挂起方式， 如果支持长轮询模式， 挂起超时时间来源于请求参数，
         *                                 PUSH 模式默认为15s,
         *                                 PULL 模式通过DefaultMQPullConsumer#brokerSuspenMaxTimeMillis设置，默认20 s
         *                                 然后创建拉取任务PullRequest 并提交到PullRequestHoldService 线程中。
         *                            RocketMQ 轮询机制由两个线程共同来完成。
         *                              1 ) PullRequestHoldService ： 每隔Ss 重试一次。
         *                              2 ) DefaultMessageStore#ReputMessageService 每处理一次重新拉取Thread.sleep ( 1 ) ,继续下一次检查。
         * @return
         * @throws RemotingCommandException
         */
        private RemotingCommand processRequest(final Channel channel, RemotingCommand request, boolean brokerAllowSuspend)
            throws RemotingCommandException {
        
            RemotingCommand response = RemotingCommand.createResponseCommand(PullMessageResponseHeader.class);
            final PullMessageResponseHeader responseHeader = (PullMessageResponseHeader) response.readCustomHeader();
            final PullMessageRequestHeader requestHeader =
                (PullMessageRequestHeader) request.decodeCommandCustomHeader(PullMessageRequestHeader.class);
    
            response.setOpaque(request.getOpaque());
    
            log.debug("receive PullMessage request command, {}", request);
            //broker是否有读的权限
            if (!PermName.isReadable(this.brokerController.getBrokerConfig().getBrokerPermission())) {
        
                response.setCode(ResponseCode.NO_PERMISSION);
                response.setRemark(String.format("the broker[%s] pulling message is forbidden", this.brokerController.getBrokerConfig().getBrokerIP1()));
                return response;
            }
            //根据消息组查找订阅消息组信息
            SubscriptionGroupConfig subscriptionGroupConfig =
                this.brokerController.getSubscriptionGroupManager().findSubscriptionGroupConfig(requestHeader.getConsumerGroup());
                //未找到则返回订阅题组不存在
            if (null == subscriptionGroupConfig) {
        
                response.setCode(ResponseCode.SUBSCRIPTION_GROUP_NOT_EXIST);
                response.setRemark(String.format("subscription group [%s] does not exist, %s", requestHeader.getConsumerGroup(), FAQUrl.suggestTodo(FAQUrl.SUBSCRIPTION_GROUP_NOT_EXIST)));
                return response;
            }
            //是否能消费消息
            if (!subscriptionGroupConfig.isConsumeEnable()) {
        
                //不能消费消息,则返回没有权限
                response.setCode(ResponseCode.NO_PERMISSION);
                response.setRemark("subscription group no permission, " + requestHeader.getConsumerGroup());
                return response;
            }
    
            //消息拉取时支持挂起。
            final boolean hasSuspendFlag = PullSysFlag.hasSuspendFlag(requestHeader.getSysFlag());
            //表示从内存中读取的消费进度大于0
            final boolean hasCommitOffsetFlag = PullSysFlag.hasCommitOffsetFlag(requestHeader.getSysFlag());
            //消息过滤机制为表达式
            final boolean hasSubscriptionFlag = PullSysFlag.hasSubscriptionFlag(requestHeader.getSysFlag());
            //如果支持挂起,则设置挂起时间,默认15s
            final long suspendTimeoutMillisLong = hasSuspendFlag ? requestHeader.getSuspendTimeoutMillis() : 0;
            //根据topicName获取配置
            TopicConfig topicConfig = this.brokerController.getTopicConfigManager().selectTopicConfig(requestHeader.getTopic());
            if (null == topicConfig) {
        
                log.error("the topic {} not exist, consumer: {}", requestHeader.getTopic(), RemotingHelper.parseChannelRemoteAddr(channel));
                response.setCode(ResponseCode.TOPIC_NOT_EXIST);
                response.setRemark(String.format("topic[%s] not exist, apply first please! %s", requestHeader.getTopic(), FAQUrl.suggestTodo(FAQUrl.APPLY_TOPIC_URL)));
                return response;
            }
            //topic是否配置了可读权限
            if (!PermName.isReadable(topicConfig.getPerm())) {
        
                response.setCode(ResponseCode.NO_PERMISSION);
                response.setRemark("the topic[" + requestHeader.getTopic() + "] pulling message is forbidden");
                return response;
            }
            //队列Id上下边界检测
            if (requestHeader.getQueueId() < 0 || requestHeader.getQueueId() >= topicConfig.getReadQueueNums()) {
        
                String errorInfo = String.format("queueId[%d] is illegal, topic:[%s] topicConfig.readQueueNums:[%d] consumer:[%s]",
                    requestHeader.getQueueId(), requestHeader.getTopic(), topicConfig.getReadQueueNums(), channel.remoteAddress());
                log.warn(errorInfo);
                response.setCode(ResponseCode.SYSTEM_ERROR);
                response.setRemark(errorInfo);
                return response;
            }
    
            SubscriptionData subscriptionData = null;
            ConsumerFilterData consumerFilterData = null;
            //消息过滤机制是否为表达式
            if (hasSubscriptionFlag) {
        
                try {
        
                    //根据主题、消息过滤表达式构建订阅消息实体
                    subscriptionData = FilterAPI.build(
                        requestHeader.getTopic(), requestHeader.getSubscription(), requestHeader.getExpressionType()
                    );
                    //如果不是TAG过滤模式
                    if (!ExpressionType.isTagType(subscriptionData.getExpressionType())) {
        
                        //构建过滤数据
                        consumerFilterData = ConsumerFilterManager.build(
                            requestHeader.getTopic(), requestHeader.getConsumerGroup(), requestHeader.getSubscription(),
                            requestHeader.getExpressionType(), requestHeader.getSubVersion()
                        );
                        assert consumerFilterData != null;
                    }
                } catch (Exception e) {
        
                    log.warn("Parse the consumer's subscription[{}] failed, group: {}", requestHeader.getSubscription(),
                        requestHeader.getConsumerGroup());
                    response.setCode(ResponseCode.SUBSCRIPTION_PARSE_FAILED);
                    response.setRemark("parse the consumer's subscription failed");
                    return response;
                }
            } else {
        
                ConsumerGroupInfo consumerGroupInfo =
                    this.brokerController.getConsumerManager().getConsumerGroupInfo(requestHeader.getConsumerGroup());
                if (null == consumerGroupInfo) {
        
                    log.warn("the consumer's group info not exist, group: {}", requestHeader.getConsumerGroup());
                    response.setCode(ResponseCode.SUBSCRIPTION_NOT_EXIST);
                    response.setRemark("the consumer's group info not exist" + FAQUrl.suggestTodo(FAQUrl.SAME_GROUP_DIFFERENT_TOPIC));
                    return response;
                }
    
                if (!subscriptionGroupConfig.isConsumeBroadcastEnable()
                    && consumerGroupInfo.getMessageModel() == MessageModel.BROADCASTING) {
        
                    response.setCode(ResponseCode.NO_PERMISSION);
                    response.setRemark("the consumer group[" + requestHeader.getConsumerGroup() + "] can not consume by broadcast way");
                    return response;
                }
    
                subscriptionData = consumerGroupInfo.findSubscriptionData(requestHeader.getTopic());
                if (null == subscriptionData) {
        
                    log.warn("the consumer's subscription not exist, group: {}, topic:{}", requestHeader.getConsumerGroup(), requestHeader.getTopic());
                    response.setCode(ResponseCode.SUBSCRIPTION_NOT_EXIST);
                    response.setRemark("the consumer's subscription not exist" + FAQUrl.suggestTodo(FAQUrl.SAME_GROUP_DIFFERENT_TOPIC));
                    return response;
                }
    
                if (subscriptionData.getSubVersion() < requestHeader.getSubVersion()) {
        
                    log.warn("The broker's subscription is not latest, group: {} {}", requestHeader.getConsumerGroup(),
                        subscriptionData.getSubString());
                    response.setCode(ResponseCode.SUBSCRIPTION_NOT_LATEST);
                    response.setRemark("the consumer's subscription not latest");
                    return response;
                }
                if (!ExpressionType.isTagType(subscriptionData.getExpressionType())) {
        
                    consumerFilterData = this.brokerController.getConsumerFilterManager().get(requestHeader.getTopic(),
                        requestHeader.getConsumerGroup());
                    if (consumerFilterData == null) {
        
                        response.setCode(ResponseCode.FILTER_DATA_NOT_EXIST);
                        response.setRemark("The broker's consumer filter data is not exist!Your expression may be wrong!");
                        return response;
                    }
                    if (consumerFilterData.getClientVersion() < requestHeader.getSubVersion()) {
        
                        log.warn("The broker's consumer filter data is not latest, group: {}, topic: {}, serverV: {}, clientV: {}",
                            requestHeader.getConsumerGroup(), requestHeader.getTopic(), consumerFilterData.getClientVersion(), requestHeader.getSubVersion());
                        response.setCode(ResponseCode.FILTER_DATA_NOT_LATEST);
                        response.setRemark("the consumer's consumer filter data not latest");
                        return response;
                    }
                }
            }
    
            if (!ExpressionType.isTagType(subscriptionData.getExpressionType())
                && !this.brokerController.getBrokerConfig().isEnablePropertyFilter()) {
        
                response.setCode(ResponseCode.SYSTEM_ERROR);
                response.setRemark("The broker does not support consumer to filter message by " + subscriptionData.getExpressionType());
                return response;
            }
    
            //构建消息过滤对象
            MessageFilter messageFilter;
            if (this.brokerController.getBrokerConfig().isFilterSupportRetry()) {
        
                //支持对重试主题的过滤
                messageFilter = new ExpressionForRetryMessageFilter(subscriptionData, consumerFilterData,
                    this.brokerController.getConsumerFilterManager());
            } else {
        
                //不支持对重试主题的属性过滤，也就是如果是tag 模式，执行isMatchedByCommitLog 方法将直接返回true 。
                messageFilter = new ExpressionMessageFilter(subscriptionData, consumerFilterData,
                    this.brokerController.getConsumerFilterManager());
            }
    
            //查找消息
            final GetMessageResult getMessageResult =
                this.brokerController.getMessageStore().getMessage(requestHeader.getConsumerGroup(), requestHeader.getTopic(),
                    requestHeader.getQueueId(), requestHeader.getQueueOffset(), requestHeader.getMaxMsgNums(), messageFilter);
            if (getMessageResult != null) {
        
                //根据PullResult 填充responseHeader 的nextBegionOffset 、minOffset 、maxOffset 。
                response.setRemark(getMessageResult.getStatus().name());
                responseHeader.setNextBeginOffset(getMessageResult.getNextBeginOffset());
                responseHeader.setMinOffset(getMessageResult.getMinOffset());
                responseHeader.setMaxOffset(getMessageResult.getMaxOffset());
    
                //是否建议下一次从SLAVE拉取数据
                if (getMessageResult.isSuggestPullingFromSlave()) {
        
                    responseHeader.setSuggestWhichBrokerId(subscriptionGroupConfig.getWhichBrokerWhenConsumeSlowly());
                } else {
        
                    responseHeader.setSuggestWhichBrokerId(MixAll.MASTER_ID);
                }
    
                switch (this.brokerController.getMessageStoreConfig().getBrokerRole()) {
        
                    case ASYNC_MASTER:
                    case SYNC_MASTER:
                        break;
                    case SLAVE:
                        if (!this.brokerController.getBrokerConfig().isSlaveReadEnable()) {
        
                            response.setCode(ResponseCode.PULL_RETRY_IMMEDIATELY);
                            responseHeader.setSuggestWhichBrokerId(MixAll.MASTER_ID);
                        }
                        break;
                }
    
                if (this.brokerController.getBrokerConfig().isSlaveReadEnable()) {
        
                    // consume too slow ,redirect to another machine
                    if (getMessageResult.isSuggestPullingFromSlave()) {
        
                        responseHeader.setSuggestWhichBrokerId(subscriptionGroupConfig.getWhichBrokerWhenConsumeSlowly());
                    }
                    // consume ok
                    else {
        
                        responseHeader.setSuggestWhichBrokerId(subscriptionGroupConfig.getBrokerId());
                    }
                } else {
        
                    responseHeader.setSuggestWhichBrokerId(MixAll.MASTER_ID);
                }
    
                switch (getMessageResult.getStatus()) {
        
                    case FOUND:
                        response.setCode(ResponseCode.SUCCESS);
                        break;
                    case MESSAGE_WAS_REMOVING:
                        response.setCode(ResponseCode.PULL_RETRY_IMMEDIATELY);
                        break;
                    case NO_MATCHED_LOGIC_QUEUE:
                    case NO_MESSAGE_IN_QUEUE:
                        if (0 != requestHeader.getQueueOffset()) {
        
                            response.setCode(ResponseCode.PULL_OFFSET_MOVED);
    
                            // XXX: warn and notify me
                            log.info("the broker store no queue data, fix the request offset {} to {}, Topic: {} QueueId: {} Consumer Group: {}",
                                requestHeader.getQueueOffset(),
                                getMessageResult.getNextBeginOffset(),
                                requestHeader.getTopic(),
                                requestHeader.getQueueId(),
                                requestHeader.getConsumerGroup()
                            );
                        } else {
        
                            response.setCode(ResponseCode.PULL_NOT_FOUND);
                        }
                        break;
                    case NO_MATCHED_MESSAGE:
                        response.setCode(ResponseCode.PULL_RETRY_IMMEDIATELY);
                        break;
                    case OFFSET_FOUND_NULL:
                        response.setCode(ResponseCode.PULL_NOT_FOUND);
                        break;
                    case OFFSET_OVERFLOW_BADLY:
                        response.setCode(ResponseCode.PULL_OFFSET_MOVED);
                        // XXX: warn and notify me
                        log.info("the request offset: {} over flow badly, broker max offset: {}, consumer: {}",
                            requestHeader.getQueueOffset(), getMessageResult.getMaxOffset(), channel.remoteAddress());
                        break;
                    case OFFSET_OVERFLOW_ONE:
                        response.setCode(ResponseCode.PULL_NOT_FOUND);
                        break;
                    case OFFSET_TOO_SMALL:
                        response.setCode(ResponseCode.PULL_OFFSET_MOVED);
                        log.info("the request offset too small. group={}, topic={}, requestOffset={}, brokerMinOffset={}, clientIp={}",
                            requestHeader.getConsumerGroup(), requestHeader.getTopic(), requestHeader.getQueueOffset(),
                            getMessageResult.getMinOffset(), channel.remoteAddress());
                        break;
                    default:
                        assert false;
                        break;
                }
    
                if (this.hasConsumeMessageHook()) {
        
                    ConsumeMessageContext context = new ConsumeMessageContext();
                    context.setConsumerGroup(requestHeader.getConsumerGroup());
                    context.setTopic(requestHeader.getTopic());
                    context.setQueueId(requestHeader.getQueueId());
    
                    String owner = request.getExtFields().get(BrokerStatsManager.COMMERCIAL_OWNER);
    
                    switch (response.getCode()) {
        
                        case ResponseCode.SUCCESS:
                            int commercialBaseCount = brokerController.getBrokerConfig().getCommercialBaseCount();
                            int incValue = getMessageResult.getMsgCount4Commercial() * commercialBaseCount;
    
                            context.setCommercialRcvStats(BrokerStatsManager.StatsType.RCV_SUCCESS);
                            context.setCommercialRcvTimes(incValue);
                            context.setCommercialRcvSize(getMessageResult.getBufferTotalSize());
                            context.setCommercialOwner(owner);
    
                            break;
                        case ResponseCode.PULL_NOT_FOUND:
    
                            if (!brokerAllowSuspend) {
        
                                context.setCommercialRcvStats(BrokerStatsManager.StatsType.RCV_EPOLLS);
                                context.setCommercialRcvTimes(1);
                                context.setCommercialOwner(owner);
                            }
                            break;
                        case ResponseCode.PULL_RETRY_IMMEDIATELY:
                        case ResponseCode.PULL_OFFSET_MOVED:
                            context.setCommercialRcvStats(BrokerStatsManager.StatsType.RCV_EPOLLS);
                            context.setCommercialRcvTimes(1);
                            context.setCommercialOwner(owner);
                            break;
                        default:
                            assert false;
                            break;
                    }
    
                    this.executeConsumeMessageHookBefore(context);
                }
    
                switch (response.getCode()) {
        
                    case ResponseCode.SUCCESS:
    
                        this.brokerController.getBrokerStatsManager().incGroupGetNums(requestHeader.getConsumerGroup(), requestHeader.getTopic(),
                            getMessageResult.getMessageCount());
    
                        this.brokerController.getBrokerStatsManager().incGroupGetSize(requestHeader.getConsumerGroup(), requestHeader.getTopic(),
                            getMessageResult.getBufferTotalSize());
    
                        this.brokerController.getBrokerStatsManager().incBrokerGetNums(getMessageResult.getMessageCount());
                        if (this.brokerController.getBrokerConfig().isTransferMsgByHeap()) {
        
                            final long beginTimeMills = this.brokerController.getMessageStore().now();
                            final byte[] r = this.readGetMessageResult(getMessageResult, requestHeader.getConsumerGroup(), requestHeader.getTopic(), requestHeader.getQueueId());
                            this.brokerController.getBrokerStatsManager().incGroupGetLatency(requestHeader.getConsumerGroup(),
                                requestHeader.getTopic(), requestHeader.getQueueId(),
                                (int) (this.brokerController.getMessageStore().now() - beginTimeMills));
                            response.setBody(r);
                        } else {
        
                            try {
        
                                FileRegion fileRegion =
                                    new ManyMessageTransfer(response.encodeHeader(getMessageResult.getBufferTotalSize()), getMessageResult);
                                channel.writeAndFlush(fileRegion).addListener(new ChannelFutureListener() {
        
                                    @Override
                                    public void operationComplete(ChannelFuture future) throws Exception {
        
                                        getMessageResult.release();
                                        if (!future.isSuccess()) {
        
                                            log.error("transfer many message by pagecache failed, {}", channel.remoteAddress(), future.cause());
                                        }
                                    }
                                });
                            } catch (Throwable e) {
        
                                log.error("transfer many message by pagecache exception", e);
                                getMessageResult.release();
                            }
    
                            response = null;
                        }
                        break;
                    case ResponseCode.PULL_NOT_FOUND:
                        //消息拉取时服务端从Commitlog 未找到消息
    
                        //如果brokerAllowSuspend 为true ，表示支持挂起，则将响应对象response 设置为null ，将不会立即向客户端写入响应
                        // hasSuspendFlag 参数在拉取消息时构建的拉取标记，默认为true 。
                        if (brokerAllowSuspend && hasSuspendFlag) {
        
                            long pollingTimeMills = suspendTimeoutMillisLong;
                            if (!this.brokerController.getBrokerConfig().isLongPollingEnable()) {
        
                                pollingTimeMills = this.brokerController.getBrokerConfig().getShortPollingTimeMills();
                            }
    
                            String topic = requestHeader.getTopic();
                            long offset = requestHeader.getQueueOffset();
                            int queueId = requestHeader.getQueueId();
                            PullRequest pullRequest = new PullRequest(request, channel, pollingTimeMills,
                                this.brokerController.getMessageStore().now(), offset, subscriptionData, messageFilter);
    
                            //创建拉取任务PullRe quest 并提交到PullRequestHoldService 线程中。
                            this.brokerController.getPullRequestHoldService().suspendPullRequest(topic, queueId, pullRequest);
                            response = null;
                            break;
                        }
    
                    case ResponseCode.PULL_RETRY_IMMEDIATELY:
                        break;
                    case ResponseCode.PULL_OFFSET_MOVED:
                        if (this.brokerController.getMessageStoreConfig().getBrokerRole() != BrokerRole.SLAVE
                            || this.brokerController.getMessageStoreConfig().isOffsetCheckInSlave()) {
        
                            MessageQueue mq = new MessageQueue();
                            mq.setTopic(requestHeader.getTopic());
                            mq.setQueueId(requestHeader.getQueueId());
                            mq.setBrokerName(this.brokerController.getBrokerConfig().getBrokerName());
    
                            OffsetMovedEvent event = new OffsetMovedEvent();
                            event.setConsumerGroup(requestHeader.getConsumerGroup());
                            event.setMessageQueue(mq);
                            event.setOffsetRequest(requestHeader.getQueueOffset());
                            event.setOffsetNew(getMessageResult.getNextBeginOffset());
                            this.generateOffsetMovedEvent(event);
                            log.warn(
                                "PULL_OFFSET_MOVED:correction offset. topic={}, groupId={}, requestOffset={}, newOffset={}, suggestBrokerId={}",
                                requestHeader.getTopic(), requestHeader.getConsumerGroup(), event.getOffsetRequest(), event.getOffsetNew(),
                                responseHeader.getSuggestWhichBrokerId());
                        } else {
        
                            responseHeader.setSuggestWhichBrokerId(subscriptionGroupConfig.getBrokerId());
                            response.setCode(ResponseCode.PULL_RETRY_IMMEDIATELY);
                            log.warn("PULL_OFFSET_MOVED:none correction. topic={}, groupId={}, requestOffset={}, suggestBrokerId={}",
                                requestHeader.getTopic(), requestHeader.getConsumerGroup(), requestHeader.getQueueOffset(),
                                responseHeader.getSuggestWhichBrokerId());
                        }
    
                        break;
                    default:
                        assert false;
                }
            } else {
        
                response.setCode(ResponseCode.SYSTEM_ERROR);
                response.setRemark("store getMessage return null");
            }
    
            boolean storeOffsetEnable = brokerAllowSuspend;
            storeOffsetEnable = storeOffsetEnable && hasCommitOffsetFlag;
            //如果commitlog 标记可用并且当前节点为主节点
            storeOffsetEnable = storeOffsetEnable
                && this.brokerController.getMessageStoreConfig().getBrokerRole() != BrokerRole.SLAVE;
            if (storeOffsetEnable) {
        
                //第一次拉取消息时,不更新消费进度
                //更新消息消费进度
                this.brokerController.getConsumerOffsetManager().commitOffset(RemotingHelper.parseChannelRemoteAddr(channel),
                    requestHeader.getConsumerGroup(), requestHeader.getTopic(), requestHeader.getQueueId(), requestHeader.getCommitOffset());
            }
            return response;
        }

获取消息  
**DefaultMessageStore**

public GetMessageResult getMessage(final String group, final String topic, final int queueId, final long offset,
            final int maxMsgNums,
            final MessageFilter messageFilter) {
        
            if (this.shutdown) {
        
                log.warn("message store has shutdown, so getMessage is forbidden");
                return null;
            }
    
            if (!this.runningFlags.isReadable()) {
        
                log.warn("message store is not readable, so getMessage is forbidden " + this.runningFlags.getFlagBits());
                return null;
            }
    
            long beginTime = this.getSystemClock().now();
    
            GetMessageStatus status = GetMessageStatus.NO_MESSAGE_IN_QUEUE;
            //待查找的队列偏移量
            long nextBeginOffset = offset;
            //当前消息队列最小偏移量
            long minOffset = 0;
            //当前消息队列最大偏移量
            long maxOffset = 0;
    
            GetMessageResult getResult = new GetMessageResult();
    
            //当前commitlog 文件最大偏移量
            final long maxOffsetPy = this.commitLog.getMaxOffset();
            //根据主题名称与队列编号获取消息消费队列
            ConsumeQueue consumeQueue = findConsumeQueue(topic, queueId);
            if (consumeQueue != null) {
        
                minOffset = consumeQueue.getMinOffsetInQueue();
                maxOffset = consumeQueue.getMaxOffsetInQueue();
    
                //说明队列没消息
                if (maxOffset == 0) {
        
                    //返回状态
                    status = GetMessageStatus.NO_MESSAGE_IN_QUEUE;
                    //如果不为SLAVE,或者offsetChecklnSlave=true,设置下次拉取偏移量为0
                    nextBeginOffset = nextOffsetCorrection(offset, 0);
                } else if (offset < minOffset) {
        
                    //待拉取消息偏移量小于队列的起始偏移量
                    status = GetMessageStatus.OFFSET_TOO_SMALL;
                    nextBeginOffset = nextOffsetCorrection(offset, minOffset);
                } else if (offset == maxOffset) {
        
                    status = GetMessageStatus.OFFSET_OVERFLOW_ONE;
                    //下次拉取偏移量依然为offset
                    nextBeginOffset = nextOffsetCorrection(offset, offset);
                } else if (offset > maxOffset) {
        
                    //偏移量越界
                    status = GetMessageStatus.OFFSET_OVERFLOW_BADLY;
                    if (0 == minOffset) {
        
                        nextBeginOffset = nextOffsetCorrection(offset, minOffset);
                    } else {
        
                        nextBeginOffset = nextOffsetCorrection(offset, maxOffset);
                    }
                } else {
        
               /*     如果待拉取偏移量大于minOffset 并且小于max Offs时，
                    从当前offset 处尝试拉取32 条消息，根据消息队列偏移量（ ConsumeQueue ）从commitlog 文件中查找消息*/
                    SelectMappedBufferResult bufferConsumeQueue = consumeQueue.getIndexBuffer(offset);
                    if (bufferConsumeQueue != null) {
        
                        try {
        
                            status = GetMessageStatus.NO_MATCHED_MESSAGE;
    
                            long nextPhyFileStartOffset = Long.MIN_VALUE;
                            long maxPhyOffsetPulling = 0;
    
                            int i = 0;
                            final int maxFilterMessageCount = Math.max(16000, maxMsgNums * ConsumeQueue.CQ_STORE_UNIT_SIZE);
                            final boolean diskFallRecorded = this.messageStoreConfig.isDiskFallRecorded();
                            ConsumeQueueExt.CqExtUnit cqExtUnit = new ConsumeQueueExt.CqExtUnit();
                            //遍历每条消息
                            for (; i < bufferConsumeQueue.getSize() && i < maxFilterMessageCount; i += ConsumeQueue.CQ_STORE_UNIT_SIZE) {
        
                                long offsetPy = bufferConsumeQueue.getByteBuffer().getLong();
                                int sizePy = bufferConsumeQueue.getByteBuffer().getInt();
                                long tagsCode = bufferConsumeQueue.getByteBuffer().getLong();
    
                                maxPhyOffsetPulling = offsetPy;
    
                                if (nextPhyFileStartOffset != Long.MIN_VALUE) {
        
                                    if (offsetPy < nextPhyFileStartOffset)
                                        continue;
                                }
    
                                boolean isInDisk = checkInDiskByCommitOffset(offsetPy, maxOffsetPy);
    
                                if (this.isTheBatchFull(sizePy, maxMsgNums, getResult.getBufferTotalSize(), getResult.getMessageCount(),
                                    isInDisk)) {
        
                                    break;
                                }
    
                                boolean extRet = false, isTagsCodeLegal = true;
                                if (consumeQueue.isExtAddr(tagsCode)) {
        
                                    extRet = consumeQueue.getExt(tagsCode, cqExtUnit);
                                    if (extRet) {
        
                                        tagsCode = cqExtUnit.getTagsCode();
                                    } else {
        
                                        // can't find ext content.Client will filter messages by tag also.
                                        log.error("[BUG] can't find consume queue extend file content!addr={}, offsetPy={}, sizePy={}, topic={}, group={}",
                                            tagsCode, offsetPy, sizePy, topic, group);
                                        isTagsCodeLegal = false;
                                    }
                                }
    
                                if (messageFilter != null
                                     //根据ConsumeQueue 条目进行消息过滤，
                                    && !messageFilter.isMatchedByConsumeQueue(isTagsCodeLegal ? tagsCode : null, extRet ? cqExtUnit : null)) {
        
                                    if (getResult.getBufferTotalSize() == 0) {
        
                                        status = GetMessageStatus.NO_MATCHED_MESSAGE;
                                    }
                                    // 如果不匹配则直接跳过该条消息，继续拉取下一条消息。
                                    continue;
                                }
    
                                SelectMappedBufferResult selectResult = this.commitLog.getMessage(offsetPy, sizePy);
                                if (null == selectResult) {
        
                                    if (getResult.getBufferTotalSize() == 0) {
        
                                        status = GetMessageStatus.MESSAGE_WAS_REMOVING;
                                    }
    
                                    nextPhyFileStartOffset = this.commitLog.rollNextFile(offsetPy);
                                    continue;
                                }
    
                                if (messageFilter != null
                                //如果消息根据ConsumeQueue 条目通过过滤，则需要从CommitLog 文件中加载整个消息体，然后根据属性进行过滤
                                //如果过滤方式是TAG 模式，该方法默认返回true
                                    && !messageFilter.isMatchedByCommitLog(selectResult.getByteBuffer().slice(), null)) {
        
                                    if (getResult.getBufferTotalSize() == 0) {
        
                                        status = GetMessageStatus.NO_MATCHED_MESSAGE;
                                    }
                                    // release...
                                    selectResult.release();
                                    continue;
                                }
    
                                this.storeStatsService.getGetMessageTransferedMsgCount().incrementAndGet();
                                getResult.addMessage(selectResult);
                                status = GetMessageStatus.FOUND;
                                nextPhyFileStartOffset = Long.MIN_VALUE;
                            }
    
                            if (diskFallRecorded) {
        
                                long fallBehind = maxOffsetPy - maxPhyOffsetPulling;
                                brokerStatsManager.recordDiskFallBehindSize(group, topic, queueId, fallBehind);
                            }
    
                            nextBeginOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);
    
                            long diff = maxOffsetPy - maxPhyOffsetPulling;
                            long memory = (long) (StoreUtil.TOTAL_PHYSICAL_MEMORY_SIZE
                                * (this.messageStoreConfig.getAccessMessageInMemoryMaxRatio() / 100.0));
                            getResult.setSuggestPullingFromSlave(diff > memory);
                        } finally {
        
    
                            bufferConsumeQueue.release();
                        }
                    } else {
        
                        status = GetMessageStatus.OFFSET_FOUND_NULL;
                        nextBeginOffset = nextOffsetCorrection(offset, consumeQueue.rollNextFile(offset));
                        log.warn("consumer request topic: " + topic + "offset: " + offset + " minOffset: " + minOffset + " maxOffset: "
                            + maxOffset + ", but access logic queue failed.");
                    }
                }
            } else {
        
                status = GetMessageStatus.NO_MATCHED_LOGIC_QUEUE;
                nextBeginOffset = nextOffsetCorrection(offset, 0);
            }
    
            if (GetMessageStatus.FOUND == status) {
        
                //累加消息找到的次数
                this.storeStatsService.getGetMessageTimesTotalFound().incrementAndGet();
            } else {
        
                //累加消息没找到的次数
                this.storeStatsService.getGetMessageTimesTotalMiss().incrementAndGet();
            }
            long elapsedTime = this.getSystemClock().now() - beginTime;
            this.storeStatsService.setGetMessageEntireTimeMax(elapsedTime);
    
            getResult.setStatus(status);
            getResult.setNextBeginOffset(nextBeginOffset);
            getResult.setMaxOffset(maxOffset);
            getResult.setMinOffset(minOffset);
            return getResult;
        }

根据ConsumeQueue 条目进行消息过滤  
**ExpressionMessageFilter**

@Override
        public boolean isMatchedByConsumeQueue(Long tagsCode, ConsumeQueueExt.CqExtUnit cqExtUnit) {
        
            //如果订阅消息为空，
            if (null == subscriptionData) {
        
                //表示不过滤
                return true;
            }
            //如果是类过滤模式
            if (subscriptionData.isClassFilterMode()) {
        
                return true;
            }
    
            // by tags code.
            //tag过滤模式处理
            if (ExpressionType.isTagType(subscriptionData.getExpressionType())) {
        
    
                //如果tagsCode为空或tagsCode小于0 ，返回true
                //说明消息在发送时没有设置tag
                if (tagsCode == null) {
        
                    return true;
                }
    
                //全匹配,直接true
                if (subscriptionData.getSubString().equals(SubscriptionData.SUB_ALL)) {
        
                    return true;
                }
                //订阅消息的TAG hashcodes 集合中包含消息的tagsCode，返回true
                return subscriptionData.getCodeSet().contains(tagsCode.intValue());
            } else {
        
                // no expression or no bloom
                if (consumerFilterData == null || consumerFilterData.getExpression() == null
                    || consumerFilterData.getCompiledExpression() == null || consumerFilterData.getBloomFilterData() == null) {
        
                    return true;
                }
    
                // message is before consumer
                if (cqExtUnit == null || !consumerFilterData.isMsgInLive(cqExtUnit.getMsgStoreTime())) {
        
                    log.debug("Pull matched because not in live: {}, {}", consumerFilterData, cqExtUnit);
                    return true;
                }
    
                byte[] filterBitMap = cqExtUnit.getFilterBitMap();
                BloomFilter bloomFilter = this.consumerFilterManager.getBloomFilter();
                if (filterBitMap == null || !this.bloomDataValid
                    || filterBitMap.length * Byte.SIZE != consumerFilterData.getBloomFilterData().getBitNum()) {
        
                    return true;
                }
    
                BitsArray bitsArray = null;
                try {
        
                    bitsArray = BitsArray.create(filterBitMap);
                    boolean ret = bloomFilter.isHit(consumerFilterData.getBloomFilterData(), bitsArray);
                    log.debug("Pull {} by bit map:{}, {}, {}", ret, consumerFilterData, bitsArray, cqExtUnit);
                    return ret;
                } catch (Throwable e) {
        
                    log.error("bloom filter error, sub=" + subscriptionData
                        + ", filter=" + consumerFilterData + ", bitMap=" + bitsArray, e);
                }
            }
    
            return true;
        }

根据存储在commitlog 文件中的内容判断消息是否匹配。

public boolean isMatchedByCommitLog(ByteBuffer msgBuffer, Map<String, String> properties) {
        
            //订阅信息为空，返回true
            if (subscriptionData == null) {
        
                return true;
            }
    
            //如果是类过滤模式，返回true
            if (subscriptionData.isClassFilterMode()) {
        
                return true;
            }
    
            //如果是TAG 模式，返回true
            if (ExpressionType.isTagType(subscriptionData.getExpressionType())) {
        
                return true;
            }
    
            ConsumerFilterData realFilterData = this.consumerFilterData;
            Map<String, String> tempProperties = properties;
    
            // no expression
            if (realFilterData == null || realFilterData.getExpression() == null
                || realFilterData.getCompiledExpression() == null) {
        
                return true;
            }
    
            if (tempProperties == null && msgBuffer != null) {
        
                tempProperties = MessageDecoder.decodeProperties(msgBuffer);
            }
    
            Object ret = null;
            try {
        
                MessageEvaluationContext context = new MessageEvaluationContext(tempProperties);
    
                //该方法主要是为表达式模式SQL92 服务的,根据消息属性实现类似于数据库SQLwhere 条件过滤方式
                ret = realFilterData.getCompiledExpression().evaluate(context);
            } catch (Throwable e) {
        
                log.error("Message Filter error, " + realFilterData + ", " + tempProperties, e);
            }
    
            log.debug("Pull eval result: {}, {}, {}", ret, realFilterData, tempProperties);
    
            if (ret == null || !(ret instanceof Boolean)) {
        
                return false;
            }
    
            return (Boolean) ret;
        }

## 消息消费客户端消费消息 ##

**MQClientAPIImpl**

private void pullMessageAsync(
            final String addr,
            final RemotingCommand request,
            final long timeoutMillis,
            final PullCallback pullCallback
        ) throws RemotingException, InterruptedException {
        
            this.remotingClient.invokeAsync(addr, request, timeoutMillis, new InvokeCallback() {
        
                @Override
                public void operationComplete(ResponseFuture responseFuture) {
        
                    RemotingCommand response = responseFuture.getResponseCommand();
                    if (response != null) {
        
                        try {
        
                            //根据响应结果解码成PullResultExt 对象
                            PullResult pullResult = MQClientAPIImpl.this.processPullResponse(response);
                            assert pullResult != null;
                            //NettyRemotingClient在收到服务端响应结构后会回调
                            pullCallback.onSuccess(pullResult);
                        } catch (Exception e) {
        
                            pullCallback.onException(e);
                        }
                    } else {
        
                        if (!responseFuture.isSendRequestOK()) {
        
                            pullCallback.onException(new MQClientException("send request failed to " + addr + ". Request: " + request, responseFuture.getCause()));
                        } else if (responseFuture.isTimeout()) {
        
                            pullCallback.onException(new MQClientException("wait response from " + addr + " timeout :" + responseFuture.getTimeoutMillis() + "ms" + ". Request: " + request,
                                responseFuture.getCause()));
                        } else {
        
                            pullCallback.onException(new MQClientException("unknown reason. addr: " + addr + ", timeoutMillis: " + timeoutMillis + ". Request: " + request, responseFuture.getCause()));
                        }
                    }
                }
            });
        }

**MQClientAPIImpl**

private PullResult processPullResponse(
            final RemotingCommand response) throws MQBrokerException, RemotingCommandException {
        
            PullStatus pullStatus = PullStatus.NO_NEW_MSG;
            switch (response.getCode()) {
        
                case ResponseCode.SUCCESS:
                    pullStatus = PullStatus.FOUND;
                    break;
                case ResponseCode.PULL_NOT_FOUND:
                    pullStatus = PullStatus.NO_NEW_MSG;
                    break;
                case ResponseCode.PULL_RETRY_IMMEDIATELY:
                    pullStatus = PullStatus.NO_MATCHED_MSG;
                    break;
                case ResponseCode.PULL_OFFSET_MOVED:
                    pullStatus = PullStatus.OFFSET_ILLEGAL;
                    break;
    
                default:
                    throw new MQBrokerException(response.getCode(), response.getRemark());
            }
    
            PullMessageResponseHeader responseHeader =
                (PullMessageResponseHeader) response.decodeCommandCustomHeader(PullMessageResponseHeader.class);
    
            //根据响应结果解码成PullResultExt 对象
            return new PullResultExt(pullStatus, responseHeader.getNextBeginOffset(), responseHeader.getMinOffset(),
                responseHeader.getMaxOffset(), null, responseHeader.getSuggestWhichBrokerId(), response.getBody());
        }

拉取消息回调函数  
**DefaultMQPushConsumerImpl.PullCallback**

//拉取消息回调函数,org.apache.rocketmq.client.impl.MQClientAPIImpl.pullMessageAsync调用
            PullCallback pullCallback = new PullCallback() {
        
                @Override
                public void onSuccess(PullResult pullResult) {
        
                    if (pullResult != null) {
        
                        //将消息字节数组解码成消息列表填充msgFoundList ，井对消息进行消息过滤（ TAG ）模式
                        pullResult = DefaultMQPushConsumerImpl.this.pullAPIWrapper.processPullResult(pullRequest.getMessageQueue(), pullResult,
                            subscriptionData);
    
                        //根据从Broker 返回的消息类型做相应的处理
                        switch (pullResult.getPullStatus()) {
        
                            case FOUND://获取上一次偏移量
                                long prevRequestOffset = pullRequest.getNextOffset();
                                //更新PullRequest 的下一次拉取偏移量
                                pullRequest.setNextOffset(pullResult.getNextBeginOffset());
                                long pullRT = System.currentTimeMillis() - beginTimestamp;
                                DefaultMQPushConsumerImpl.this.getConsumerStatsManager().incPullRT(pullRequest.getConsumerGroup(),
                                    pullRequest.getMessageQueue().getTopic(), pullRT);
    
                                long firstMsgOffset = Long.MAX_VALUE;
                                //如果msgFoundList 为空
                                if (pullResult.getMsgFoundList() == null || pullResult.getMsgFoundList().isEmpty()) {
        
                                    //将PullReqeuest 放入到PullMessageService 的pullRequestQueue
                                    //以便PullMessageSerivce 能立即及时唤醒并再次执行消息拉取。
                                    //之所以会出现msgFoundList 为空的情况,
                                    //是因为在RocketMQ 根据TAG 消息过滤，
                                    //在服务端只是验证了TAG的hashcode ，在客户端再次对消息进行过滤
                                    DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                                } else {
        
                                    firstMsgOffset = pullResult.getMsgFoundList().get(0).getQueueOffset();
    
                                    DefaultMQPushConsumerImpl.this.getConsumerStatsManager().incPullTPS(pullRequest.getConsumerGroup(),
                                        pullRequest.getMessageQueue().getTopic(), pullResult.getMsgFoundList().size());
    
                                    //将拉取到的消息存入ProcessQueue
                                    boolean dispatchToConsume = processQueue.putMessage(pullResult.getMsgFoundList());
                                    //异步将拉取到的消息提交到ConsumeMessageService中供消费者消费
                                    DefaultMQPushConsumerImpl.this.consumeMessageService.submitConsumeRequest(
                                        pullResult.getMsgFoundList(),
                                        processQueue,
                                        pullRequest.getMessageQueue(),
                                        dispatchToConsume);
    
                                    if (DefaultMQPushConsumerImpl.this.defaultMQPushConsumer.getPullInterval() > 0) {
        
                                       /* 等待pulllnterval 毫秒后
                                        将PullRequest 对象放入到PullMessageService 的pullRequestQueue 中，
                                        该消息队列的下次拉取即将被激活，达到持续消息拉取，实现准实时拉取消息的效果。*/
                                        DefaultMQPushConsumerImpl.this.executePullRequestLater(pullRequest,
                                            DefaultMQPushConsumerImpl.this.defaultMQPushConsumer.getPullInterval());
                                    } else {
        
                                        DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                                    }
                                }
    
                                if (pullResult.getNextBeginOffset() < prevRequestOffset//下次开始的偏移<上一次的偏移,
                                    || firstMsgOffset < prevRequestOffset) {
         //从broker获得的第一个消息的偏移<上一次的偏移,
                                    log.warn( //提示bug
                                        "[BUG] pull message result maybe data wrong, nextBeginOffset: {} firstMsgOffset: {} prevRequestOffset: {}",
                                        pullResult.getNextBeginOffset(),
                                        firstMsgOffset,
                                        prevRequestOffset);
                                }
    
                                break;
                            case NO_NEW_MSG:
                                //NO_NEW_MSG ，对应GetMessageResult
    
                                //OFFSET_OVERFLOW_ONE:：待拉取offset 等于消息队列最大的偏移量，如果有新的
                                //消息到达， 此时会创建一个新的ConsumeQueue 文件，按照上一个ConsueQueue 的最大偏
                                //移量就是下一个文件的起始偏移量，所以如果按照该offset 第二次拉取消息时能成功。
    
                                //OFFSET_FOUND_ NULL:是根据Consumequeue 的偏移量没有找到内容，将偏移量
                                //定位到下一个ConsumeQueue ，其实就是offset ＋（ 一个ConsumeQueue 包含多少个条目=MappedFileSize/20 ） 。
                                pullRequest.setNextOffset(pullResult.getNextBeginOffset());
    
                                DefaultMQPushConsumerImpl.this.correctTagsOffset(pullRequest);
    
                                DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                                break;
                            case NO_MATCHED_MSG:
                                pullRequest.setNextOffset(pullResult.getNextBeginOffset());
    
                                DefaultMQPushConsumerImpl.this.correctTagsOffset(pullRequest);
    
                                DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                                break;
                            case OFFSET_ILLEGAL:
                                //如果拉取结果显示偏移量非法
                                log.warn("the pull request offset illegal, {} {}",
                                    pullRequest.toString(), pullResult.toString());
                                pullRequest.setNextOffset(pullResult.getNextBeginOffset());
    
                                //设置dropped 为ture ， 表示丢弃该消费队列，
                                /*
                                意味着ProcessQueue 中拉取的消息将停止消费，然后根据服务端下一次校
                                对的偏移量尝试更新消息消费进度（ 内存中），然后尝试持久化消息消费进度，并将该消
                                息队列从Rebalacnlmpl 的处理队列中移除，意味着暂停该消息队列的消息拉取，等待下
                                一次消息队列重新负载。
                                 */
                                pullRequest.getProcessQueue().setDropped(true);
                                DefaultMQPushConsumerImpl.this.executeTaskLater(new Runnable() {
        
    
                                    @Override
                                    public void run() {
        
                                        try {
        
                                            DefaultMQPushConsumerImpl.this.offsetStore.updateOffset(pullRequest.getMessageQueue(),
                                                pullRequest.getNextOffset(), false);
    
                                            DefaultMQPushConsumerImpl.this.offsetStore.persist(pullRequest.getMessageQueue());
    
                                            DefaultMQPushConsumerImpl.this.rebalanceImpl.removeProcessQueue(pullRequest.getMessageQueue());
    
                                            log.warn("fix the pull request offset, {}", pullRequest);
                                        } catch (Throwable e) {
        
                                            log.error("executeTaskLater Exception", e);
                                        }
                                    }
                                }, 10000);
                                break;
                            default:
                                break;
                        }
                    }
                }
    
                @Override
                public void onException(Throwable e) {
        
                    if (!pullRequest.getMessageQueue().getTopic().startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)) {
        
                        log.warn("execute the pull request exception", e);
                    }
    
                    DefaultMQPushConsumerImpl.this.executePullRequestLater(pullRequest, pullTimeDelayMillsWhenException);
                }
            };

# 消费消息 #

异步将拉取到的消息提交到ConsumeMessageService中供消费者消费  
在这里有二种提交方式  
并发消息,这里以此为例  
顺序消息

## 并发消息 ##

**ConsumeMessageConcurrentlyService**

//提交消费请求
        @Override
        public void submitConsumeRequest(
            final List<MessageExt> msgs,
            final ProcessQueue processQueue,
            final MessageQueue messageQueue,
            final boolean dispatchToConsume) {
        
            //消息批次，一次消息消费任务ConsumeRequest中包含的消息条数，默认为1 ,
            final int consumeBatchSize = this.defaultMQPushConsumer.getConsumeMessageBatchMaxSize();
            //msgs.size（）默认最多为32 条，受DefaultMQPushConsumer.pullBatchSize 属性控制
            if (msgs.size() <= consumeBatchSize) {
        
                //将拉取到的消息放入到ConsumeRequest 中
                ConsumeRequest consumeRequest = new ConsumeRequest(msgs, processQueue, messageQueue);
                try {
        
                    //提交到消息消费者线程池中
                    this.consumeExecutor.submit(consumeRequest);
                } catch (RejectedExecutionException e) {
        
                    //出现拒绝提交异常则延迟5s 再提交
                    //由于消费者线程池使用的任务队列为LinkedBlockingQueue 无界队列，故不会出现拒绝提交异常。
                    this.submitConsumeRequestLater(consumeRequest);
                }
            } else {
        
                for (int total = 0; total < msgs.size(); ) {
        
                    //对拉取消息进行分页，每页consumeMessageBatchMaxSize 条消息
                    List<MessageExt> msgThis = new ArrayList<MessageExt>(consumeBatchSize);
                    for (int i = 0; i < consumeBatchSize; i++, total++) {
        
                        if (total < msgs.size()) {
        
                            msgThis.add(msgs.get(total));
                        } else {
        
                            break;
                        }
                    }
    
                    ConsumeRequest consumeRequest = new ConsumeRequest(msgThis, processQueue, messageQueue);
                    try {
        
                        //创建多个ConsumeRequest 任务并提交到消费线程池
                        this.consumeExecutor.submit(consumeRequest);
                    } catch (RejectedExecutionException e) {
        
                        for (; total < msgs.size(); total++) {
        
                            msgThis.add(msgs.get(total));//使用total=msgs.size,从而直接退出.
                        }
                        //提交过程中出现拒绝提交异常则延迟5s 再提交
                        this.submitConsumeRequestLater(consumeRequest);
                    }
                }
            }
        }

执行消费请求  
**ConsumeMessageConcurrentlyService.ConsumeRequest**

public void run() {
        
                if (this.processQueue.isDropped()) {
        
                    //停止该队列的消费
                    /*在进行消息重新负载时如果该消息队列被分配给消费组内其他消费者后，
                    需要droped 设置为true ， 阻止消费者继续消费不属于自己的消息队列。*/
                    log.info("the message queue not be able to consume, because it's dropped. group={} {}", ConsumeMessageConcurrentlyService.this.consumerGroup, this.messageQueue);
                    return;
                }
    
                MessageListenerConcurrently listener = ConsumeMessageConcurrentlyService.this.messageListener;
                ConsumeConcurrentlyContext context = new ConsumeConcurrentlyContext(messageQueue);
                ConsumeConcurrentlyStatus status = null;
                //恢复重试消息主题名
                defaultMQPushConsumerImpl.resetRetryAndNamespace(msgs, defaultMQPushConsumer.getConsumerGroup());
    
                ConsumeMessageContext consumeMessageContext = null;
                if (ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.hasHook()) {
        
                    consumeMessageContext = new ConsumeMessageContext();
                    consumeMessageContext.setNamespace(defaultMQPushConsumer.getNamespace());
                    consumeMessageContext.setConsumerGroup(defaultMQPushConsumer.getConsumerGroup());
                    consumeMessageContext.setProps(new HashMap<String, String>());
                    consumeMessageContext.setMq(messageQueue);
                    consumeMessageContext.setMsgList(msgs);
                    consumeMessageContext.setSuccess(false);
                    //执行消息消费钩子函数
                    ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.executeHookBefore(consumeMessageContext);
                }
    
                long beginTimestamp = System.currentTimeMillis();
                boolean hasException = false;
                ConsumeReturnType returnType = ConsumeReturnType.SUCCESS;
                try {
        
                    if (msgs != null && !msgs.isEmpty()) {
        
                        for (MessageExt msg : msgs) {
        
                            MessageAccessor.setConsumeStartTimeStamp(msg, String.valueOf(System.currentTimeMillis()));
                        }
                    }
                    //进入到具体的消息消费业务逻辑,也就是用户自定义的消费逻辑
                    //返回该批消息的消费结果
                    //如果由于由新的消费者加入或原先的消费者出现若机导致原先分给消费者的队列
                    //在负载之后分配给别的消费者，那么在应用程序的角度来看的话，消息会被重复消费。
                    status = listener.consumeMessage(Collections.unmodifiableList(msgs), context);
                } catch (Throwable e) {
        
                    log.warn("consumeMessage exception: {} Group: {} Msgs: {} MQ: {}",
                        RemotingHelper.exceptionSimpleDesc(e),
                        ConsumeMessageConcurrentlyService.this.consumerGroup,
                        msgs,
                        messageQueue);
                    hasException = true;
                }
                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 (ConsumeConcurrentlyStatus.RECONSUME_LATER == status) {
        //需要重新消费
                    returnType = ConsumeReturnType.FAILED;
                } else if (ConsumeConcurrentlyStatus.CONSUME_SUCCESS == status) {
        //消费成功
                    returnType = ConsumeReturnType.SUCCESS;
                }
    
                if (ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.hasHook()) {
        
                    consumeMessageContext.getProps().put(MixAll.CONSUME_CONTEXT_TYPE, returnType.name());
                }
    
                if (null == status) {
        
                    log.warn("consumeMessage return null, Group: {} Msgs: {} MQ: {}",
                        ConsumeMessageConcurrentlyService.this.consumerGroup,
                        msgs,
                        messageQueue);
                    status = ConsumeConcurrentlyStatus.RECONSUME_LATER;
                }
    
                if (ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.hasHook()) {
        
                    consumeMessageContext.setStatus(status.toString());
                    consumeMessageContext.setSuccess(ConsumeConcurrentlyStatus.CONSUME_SUCCESS == status);
                    //执行消息消费钩子函数
                    ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.executeHookAfter(consumeMessageContext);
                }
    
                ConsumeMessageConcurrentlyService.this.getConsumerStatsManager()
                    .incConsumeRT(ConsumeMessageConcurrentlyService.this.consumerGroup, messageQueue.getTopic(), consumeRT);
    
                //执行业务消息消费后，在处理结果前再次验证一下ProcessQueue的isDroped状态值，如果设置为true，将不对结果进行处理
                if (!processQueue.isDropped()) {
        
                    ConsumeMessageConcurrentlyService.this.processConsumeResult(status, context, this);
                } else {
        
                    log.warn("processQueue is dropped without process consume result. messageQueue={}, msgs={}", messageQueue, msgs);
                }
            }

消费结果验证  
**ConsumeMessageConcurrentlyService**

public void processConsumeResult(
            final ConsumeConcurrentlyStatus status,
            final ConsumeConcurrentlyContext context,
            final ConsumeRequest consumeRequest
        ) {
        
            int ackIndex = context.getAckIndex();
    
            if (consumeRequest.getMsgs().isEmpty())
                return;
    
            switch (status) {
        
                case CONSUME_SUCCESS:
                    if (ackIndex >= consumeRequest.getMsgs().size()) {
        
                        ackIndex = consumeRequest.getMsgs().size() - 1;
                    }
                    int ok = ackIndex + 1;
                    int failed = consumeRequest.getMsgs().size() - ok;
                    this.getConsumerStatsManager().incConsumeOKTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), ok);
                    this.getConsumerStatsManager().incConsumeFailedTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), failed);
                    break;
                case RECONSUME_LATER:
                    //失败消费，以后再尝试消费
                    ackIndex = -1;
                    this.getConsumerStatsManager().incConsumeFailedTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(),
                        consumeRequest.getMsgs().size());
                    break;
                default:
                    break;
            }
    
            switch (this.defaultMQPushConsumer.getMessageModel()) {
        
                case BROADCASTING:
                    //若广播形式,业务方返回RECONSUME_LATER,则只是打印每条msg消息
                    for (int i = ackIndex + 1; i < consumeRequest.getMsgs().size(); i++) {
        
                        MessageExt msg = consumeRequest.getMsgs().get(i);
                        log.warn("BROADCASTING, the message consume failed, drop it, {}", msg.toString());
                    }
                    break;
                case CLUSTERING:
                    List<MessageExt> msgBackFailed = new ArrayList<MessageExt>(consumeRequest.getMsgs().size());
                    //若集群形式
                    //业务方返回CONSUME_SUCCESS,则ackIndex + 1其实就是consumeRequest.getMsgs().size(),不会进入循环体执行
                    //业务方返回RECONSUME_LATER
                    for (int i = ackIndex + 1; i < consumeRequest.getMsgs().size(); i++) {
        
                        MessageExt msg = consumeRequest.getMsgs().get(i);
                        //该批消息都需要发ACK消息
                        boolean result = this.sendMessageBack(msg, context);
                        //如果消息发送ACK失败
                         //消息发送给Broker延迟消息
                        if (!result) {
        
                            //将本批ACK 消费发送失败的消息再次封装为ConsumeRequest ，
                            msg.setReconsumeTimes(msg.getReconsumeTimes() + 1);
                            msgBackFailed.add(msg);
                        }
                    }
    
                    if (!msgBackFailed.isEmpty()) {
        
                        consumeRequest.getMsgs().removeAll(msgBackFailed);
                        //延迟5s 后重新消费
                        this.submitConsumeRequestLater(msgBackFailed, consumeRequest.getProcessQueue(), consumeRequest.getMessageQueue());
                    }
                    break;
                default:
                    break;
            }
    
            //从ProcessQueue中移除这批消息,返回移除该批消息后最小的偏移量
            long offset = consumeRequest.getProcessQueue().removeMessage(consumeRequest.getMsgs());
            if (offset >= 0 && !consumeRequest.getProcessQueue().isDropped()) {
        
                //用该偏移量更新消息消费进度,
                //以便在消费者重启后能从上一次的消费进度开始消费，避免消息重复消费
                /*
                值得重点注意的是当消息监听器返回RECONSUME
                LATER ，消息消费进度也会向前推进，用Proces sQueue 中最小的队列偏移量调用消息消费
                进度存储器OffsetStore 更新消费进度，这是因为当返回RECONSUME_LATER, RocketMQ
                会创建一条与原先消息属性相同的消息，拥有一个唯一的新msgld ，并存储原消息ID ，该
                消息会存入到commitlog 文件中，与原先的消息没有任何关联，那该消息当然也会进入到
                ConsuemeQueue 队列中，将拥有一个全新的队列偏移量。
                 */
                this.defaultMQPushConsumerImpl.getOffsetStore().updateOffset(consumeRequest.getMessageQueue(), offset, true);
            }
        }

## 顺序消息 ##

RocketMQ 支持局部消息顺序消费，可以确保同一个消息消费队列中的消息被顺序消费，如果需要做到全局顺序消费则可以将主题配置成一个队列.  
而且需要注意的是,一个消费者可以负载多个消息队列,但是一个消息队列同一时刻只能被一个消费者消费.也就是说消息队列个数<消费者时,会造成有些消费者无消息队列情况.

消息消费者内的线程池中的线程对消息消费队列只能串行消费。与并发消息消费最本质的区别是消费消息时必须成功锁定消息消费队列，在Broker 端会存储消息消费队列的锁占用情况。

### 启动 ###

消费者注册一个有序监听  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 1]  
在启动DefaultMQPushConsumerImpl时,会根据消息类型,标记是否是有序消息  
**DefaultMQPushConsumerImpl\#start**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 2]

紧接着启动消息消费服务,对分配给自己的消息队列进行自动加锁操作，从而消费加锁成功的消息消费队列

public void start() {
        
            //如果消费模式为集群模式
            if (MessageModel.CLUSTERING.equals(ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl.messageModel())) {
        
                //启动定时任务，默认每隔20s 执行一次锁定分配给自己的消息消费队列
                //通过－Drocketmq. client.rebalance. locklnterval=20000 设置间隔，该值建议与一次消息负载频率设置相同
               /* 集群模式下顺序消息消费在创建拉取任务时并未将ProcessQueue的locked 状态设置为true ，
                在未锁定消息队列之前无法执行消息拉取任务， ConsumeM巳ssageOrderlyService 以每20s 的频率对分配给自己的消息队列进行自动加锁操作，
                从而消费加锁成功的消息消费队列。*/
                this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
        
                    @Override
                    public void run() {
        
                        ConsumeMessageOrderlyService.this.lockMQPeriodically();
                    }
                }, 1000 * 1, ProcessQueue.REBALANCE_LOCK_INTERVAL, TimeUnit.MILLISECONDS);
            }
        }

加锁所有MQ  
**RebalanceImpl**

public void lockAll() {
        //将ConcurrentMap<MessageQueue, ProcessQueue>构造成Map < String/*brokerName* , Set<MessageQueue＞＞
            HashMap<String, Set<MessageQueue>> brokerMqs = this.buildProcessQueueTableByBrokerName();
    
            Iterator<Entry<String, Set<MessageQueue>>> it = brokerMqs.entrySet().iterator();
            while (it.hasNext()) {
        
                Entry<String, Set<MessageQueue>> entry = it.next();
                final String brokerName = entry.getKey();
                final Set<MessageQueue> mqs = entry.getValue();
    
                if (mqs.isEmpty())
                    continue;
                //查询MASTER addr
                FindBrokerResult findBrokerResult = this.mQClientFactory.findBrokerAddressInSubscribe(brokerName, MixAll.MASTER_ID, true);
                if (findBrokerResult != null) {
        
                    LockBatchRequestBody requestBody = new LockBatchRequestBody();
                    requestBody.setConsumerGroup(this.consumerGroup);
                    requestBody.setClientId(this.mQClientFactory.getClientId());
                    requestBody.setMqSet(mqs);
    
                    try {
        
                        //向Broker ( Master 主节点）发送锁定消息队列，
                        //该方法返回成功被当前消费者锁定的消息消费队列。
                        Set<MessageQueue> lockOKMQSet =
                            this.mQClientFactory.getMQClientAPIImpl().lockBatchMQ(findBrokerResult.getBrokerAddr(), requestBody, 1000);
    
                        for (MessageQueue mq : lockOKMQSet) {
        
                            ProcessQueue processQueue = this.processQueueTable.get(mq);
                            if (processQueue != null) {
        
                                if (!processQueue.isLocked()) {
        
                                    log.info("the message queue locked OK, Group: {} {}", this.consumerGroup, mq);
                                }
    
                                //将成功锁定的消息消费队列相对应的处理队列设置为锁定状态
                                processQueue.setLocked(true);
                                //更新加锁时间
                                processQueue.setLastLockTimestamp(System.currentTimeMillis());
                            }
                        }
                        //遍历当前处理队列中的消息消费队列，
                        for (MessageQueue mq : mqs) {
        
                        //如果当前消费者不持有该消息队列的锁，
                            if (!lockOKMQSet.contains(mq)) {
        
                                ProcessQueue processQueue = this.processQueueTable.get(mq);
                                if (processQueue != null) {
        
                                    //将处理队列锁状态设置为false ，暂停该消息消费队列的消息拉取与消息消费。
                                    processQueue.setLocked(false);
                                    log.warn("the message queue locked Failed, Group: {} {}", this.consumerGroup, mq);
                                }
                            }
                        }
                    } catch (Exception e) {
        
                        log.error("lockBatchMQ exception, " + mqs, e);
                    }
                }
            }
        }

### 负载 ###

在异步线程Rebalance更新进程队列表,如果是新增的队列,会判断是否是顺序消息,如果是的,在创建消息队列拉取任务时会通知Broker 服务器锁定该消息队列。  
**RebalanceImpl\#updateProcessQueueTableInRebalance**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 3]

### 拉取 ###

在客户端封装拉取请求,发送broker时  
**DefaultMQPushConsumerImpl\#pullMessage**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 4]

### 消费 ###

当拉取到消息后调用PullCallback\#onSuccess提交消息消费  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 5]  
提交给ConsumeMessageOrderlyService线程池处理  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 6]

@Override
            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;
                }
                //根据消息队列获取一个对象。然后消息消费时先申请独占objLock 。
                //顺序消息消费的并发度为消息队列。也就是一个消息消费队列同一时刻只会被一个消费线程池中一个线程消费。
                final Object objLock = messageQueueLock.fetchLockObject(this.messageQueue);
                synchronized (objLock) {
        
                    //如果是广播模式  如果是集群模式，消息消费的前提条件是proceessQueue被锁定并且锁未超时。
                    /*
                    集群模式下,是如何保证顺序消息的了?
                    当一个新的消费队列分配给消费者时， 在添加其拉取任务之前必须先向Broker 发送对该消息队列加锁请求，只
                    有加锁成功后，才能添加拉取消息，否则等到下一次负载后，只有消费队列被原先占有的
                    消费者释放后，才能开始新的拉取任务。集群模式下，如果未锁定处理队列，则延迟该队
                    列的消息消费。*/
                    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;
                            }
    
                            //每一个ConsumeRequest 消费任务不是以消费消息条数来计算的，而是根据消费时间
                            long interval = System.currentTimeMillis() - beginTime;
                            //默认当消费时长大于MAX_TIME_CONSUME_CONTINUOUSLY ，默认60s 后
                            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.takeMessages(consumeBatchSize);
                            defaultMQPushConsumerImpl.resetRetryAndNamespace(msgs, defaultMQPushConsumer.getConsumerGroup());
                            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.setNamespace(defaultMQPushConsumer.getNamespace());
                                    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;
                                    }
    
                                    //执行消息消费监听器
                                    //调用业务方具体消息监听器执行真正的消息消费处理逻辑，并通知RocketMQ 消息消费结果。
                                    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;
                        }
                        //集群模式下
                        //消息消费的前提条件是proceessQueue被锁定并且锁未超时。
                        ConsumeMessageOrderlyService.this.tryLockLaterAndReconsume(this.messageQueue, this.processQueue, 100);
                    }
                }
            }

处理消费结果  
**ConsumeMessageOrderlyService**

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)) {
        
                            //如果这批消息中有任意一条消息的重试次数小于允许的最大重试次数，将
                            //返回true ，执行消息重试。
                            consumeRequest.getProcessQueue().makeMessageToCosumeAgain(msgs);
                            this.submitConsumeRequestLater(
                                consumeRequest.getProcessQueue(),
                                consumeRequest.getMessageQueue(),
                                context.getSuspendCurrentQueueTimeMillis());
                            continueConsume = false;
                        } else {
        
                            //如果消息重试次数大于或等于允许的最大重试次数
                            //将该消息发送到Broker 端， 该消息在消息服务端最终会进入到DLQ （死信队列），
                            //也就是RocketMQ 不会再次消费，需要人工干预
                            //消息成功进入到DLQ 队列
                            //该批消息将直接调用ProcessQueue#commit 提交， 表示消息消费成功，
                            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;
        }

将consumingMsgOrderlyTreeMap 中的消息清除，表示成功处理该批消息。  
**ProcessQueue**

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);
                    }
                    //将该批消息从ProceeQueue中移除
                    this.consumingMsgOrderlyTreeMap.clear();
                    if (offset != null) {
        
                        //返回待保存的消息消费进度（ offset+ 1 ）
                        return offset + 1;
                    }
                } finally {
        
                    this.lockTreeMap.writeLock().unlock();
                }
            } catch (InterruptedException e) {
        
                log.error("commit exception", e);
            }
    
            return -1;
        }

# 针对业务方返回RECONSUME\_LATER,延迟消息处理 #

当返回RECONSUME\_LATER, RocketMQ会创建一条与原先消息属性相同的消息，拥有一个唯一的新msgld ，并存储原消息ID ，该消息会存入到commitlog 文件中，与原先的消息没有任何关联，那该消息当然也会进入到ConsuemeQueue 队列中，将拥有一个全新的队列偏移量。  
这也是当消息监听器返回RECONSUMELATER ，消息消费进度也会向前推进，用Proces sQueue 中最小的队列偏移量调用消息消费进度存储器OffsetStore 更新消费进度的原因  
**ConsumeMessageConcurrentlyService**  
注意这里获取消息消费重试策略  
\-1，不重试，直接放入DLQ  
0，broker控制重试频率,当设置为0时,broker默认延迟3个延迟级别.  
大于0 客户端控制重试频率  
**SendMessageProcessor\#asyncConsumerSendMsgBack**  
![在这里插入图片描述][20200906190101535.png_pic_center]

public boolean sendMessageBack(final MessageExt msg, final ConsumeConcurrentlyContext context) {
        
            int delayLevel = context.getDelayLevelWhenNextConsume();//获取消息消费重试策略,
    
            // Wrap topic with namespace before sending back message.
            msg.setTopic(this.defaultMQPushConsumer.withNamespace(msg.getTopic()));
            try {
        
                //消息发送给Broker延迟消息
                this.defaultMQPushConsumerImpl.sendMessageBack(msg, delayLevel, context.getMessageQueue().getBrokerName());
                return true;
            } catch (Exception e) {
        
                log.error("sendMessageBack exception, group: " + this.consumerGroup + " msg: " + msg.toString(), e);
            }
    
            return false;
        }

**DefaultMQPushConsumerImpl**

public void sendMessageBack(MessageExt msg, int delayLevel, final String brokerName)
            throws RemotingException, MQBrokerException, InterruptedException, MQClientException {
        
            try {
        //获取master地址,如果没有则解析msg保存的地址
                String brokerAddr = (null != brokerName) ? this.mQClientFactory.findBrokerAddressInPublish(brokerName)
                    : RemotingHelper.parseSocketAddressAddr(msg.getStoreHost());
                //消息发送给Broker延迟消息
                this.mQClientFactory.getMQClientAPIImpl().consumerSendMessageBack(brokerAddr, msg,
                    this.defaultMQPushConsumer.getConsumerGroup(), delayLevel, 5000, getMaxReconsumeTimes());
            } catch (Exception e) {
        
                log.error("sendMessageBack Exception, " + this.defaultMQPushConsumer.getConsumerGroup(), e);
    
                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() + 1));
                MessageAccessor.setMaxReconsumeTimes(newMsg, String.valueOf(getMaxReconsumeTimes()));
                MessageAccessor.clearProperty(newMsg, MessageConst.PROPERTY_TRANSACTION_PREPARED);
                newMsg.setDelayTimeLevel(3 + msg.getReconsumeTimes());
    
                this.mQClientFactory.getDefaultMQProducer().send(newMsg);
            } finally {
        
                msg.setTopic(NamespaceUtil.withoutNamespace(msg.getTopic(), this.defaultMQPushConsumer.getNamespace()));
            }
        }

消息发送给Broker延迟消息  
**MQClientAPIImpl**

//ACK消息发送的网络客户端人口
        public void consumerSendMessageBack(
            final String addr,
            final MessageExt msg,
            final String consumerGroup,
            final int delayLevel,
            final long timeoutMillis,
            final int maxConsumeRetryTimes
        ) throws RemotingException, MQBrokerException, InterruptedException {
        
            ConsumerSendMsgBackRequestHeader requestHeader = new ConsumerSendMsgBackRequestHeader();
            RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.CONSUMER_SEND_MSG_BACK, requestHeader);
    
            //消费组名
            requestHeader.setGroup(consumerGroup);
            requestHeader.setOriginTopic(msg.getTopic());
            //消息物理偏移量
            requestHeader.setOffset(msg.getCommitLogOffset());
            //延迟级别
            requestHeader.setDelayLevel(delayLevel);
            //消息ID
            requestHeader.setOriginMsgId(msg.getMsgId());
            //最大重新消费次数，默认为16 次
            requestHeader.setMaxReconsumeTimes(maxConsumeRetryTimes);
    
            RemotingCommand response = this.remotingClient.invokeSync(MixAll.brokerVIPChannel(this.clientConfig.isVipChannelEnabled(), addr),
                request, timeoutMillis);
            assert response != null;
            switch (response.getCode()) {
        
                case ResponseCode.SUCCESS: {
        
                    return;
                }
                default:
                    break;
            }
    
            throw new MQBrokerException(response.getCode(), response.getRemark());
        }

## broker端接收 ##

**SendMessageProcessor**

public CompletableFuture<RemotingCommand> asyncProcessRequest(ChannelHandlerContext ctx,
                                                                      RemotingCommand request) throws RemotingCommandException {
        
            final SendMessageContext mqtraceContext;
            switch (request.getCode()) {
        
                case RequestCode.CONSUMER_SEND_MSG_BACK:
                    //延时消息处理
                    return this.asyncConsumerSendMsgBack(ctx, request);
                default:
                    SendMessageRequestHeader requestHeader = parseRequestHeader(request);
                    if (requestHeader == null) {
        
                        return CompletableFuture.completedFuture(null);
                    }
                    mqtraceContext = buildMsgContext(ctx, requestHeader);
                    this.executeSendMessageHookBefore(ctx, request, mqtraceContext);
                    if (requestHeader.isBatch()) {
        
                        return this.asyncSendBatchMessage(ctx, request, mqtraceContext, requestHeader);
                    } else {
        
                        return this.asyncSendMessage(ctx, request, mqtraceContext, requestHeader);
                    }
            }
        }

SendMessageProcessor

private CompletableFuture<RemotingCommand> asyncConsumerSendMsgBack(ChannelHandlerContext ctx,
                                                                            RemotingCommand request) throws RemotingCommandException {
        
            final RemotingCommand response = RemotingCommand.createResponseCommand(null);
            final ConsumerSendMsgBackRequestHeader requestHeader =
                    (ConsumerSendMsgBackRequestHeader)request.decodeCommandCustomHeader(ConsumerSendMsgBackRequestHeader.class);
            String namespace = NamespaceUtil.getNamespaceFromResource(requestHeader.getGroup());
            if (this.hasConsumeMessageHook() && !UtilAll.isBlank(requestHeader.getOriginMsgId())) {
        
                ConsumeMessageContext context = buildConsumeMessageContext(namespace, requestHeader, request);
                this.executeConsumeMessageHookAfter(context);
            }
            //获取消费组的订阅配置信息
            SubscriptionGroupConfig subscriptionGroupConfig =
                this.brokerController.getSubscriptionGroupManager().findSubscriptionGroupConfig(requestHeader.getGroup());
            if (null == subscriptionGroupConfig) {
        
                //返回配置组信息不存在错误
                response.setCode(ResponseCode.SUBSCRIPTION_GROUP_NOT_EXIST);
                response.setRemark("subscription group not exist, " + requestHeader.getGroup() + " "
                    + FAQUrl.suggestTodo(FAQUrl.SUBSCRIPTION_GROUP_NOT_EXIST));
                return CompletableFuture.completedFuture(response);
            }
            if (!PermName.isWriteable(this.brokerController.getBrokerConfig().getBrokerPermission())) {
        
                response.setCode(ResponseCode.NO_PERMISSION);
                response.setRemark("the broker[" + this.brokerController.getBrokerConfig().getBrokerIP1() + "] sending message is forbidden");
                return CompletableFuture.completedFuture(response);
            }
    
            //如果重试队列数量小于l ，则直接返回成功,说明该消费组不支持重试。
            if (subscriptionGroupConfig.getRetryQueueNums() <= 0) {
        
                response.setCode(ResponseCode.SUCCESS);
                response.setRemark(null);
                return CompletableFuture.completedFuture(response);
            }
    
            //创建重试主题，重试主题名称： %RETRY%＋消费组名称
            String newTopic = MixAll.getRetryTopic(requestHeader.getGroup());
            //从重试队列中随机选择一个队列，并构建TopicConfig 主题配置信息
            int queueIdInt = Math.abs(this.random.nextInt() % 99999999) % subscriptionGroupConfig.getRetryQueueNums();
            int topicSysFlag = 0;
            if (requestHeader.isUnitMode()) {
        
                topicSysFlag = TopicSysFlag.buildSysFlag(false, true);
            }
            //根据重试topic,创建topicConfig
            TopicConfig topicConfig = this.brokerController.getTopicConfigManager().createTopicInSendMessageBackMethod(
                newTopic,
                subscriptionGroupConfig.getRetryQueueNums(),
                PermName.PERM_WRITE | PermName.PERM_READ, topicSysFlag);
            if (null == topicConfig) {
        
                response.setCode(ResponseCode.SYSTEM_ERROR);
                response.setRemark("topic[" + newTopic + "] not exist");
                return CompletableFuture.completedFuture(response);
            }
            //是否有写权限,默认是有的
            if (!PermName.isWriteable(topicConfig.getPerm())) {
        
                response.setCode(ResponseCode.NO_PERMISSION);
                response.setRemark(String.format("the topic[%s] sending message is forbidden", newTopic));
                return CompletableFuture.completedFuture(response);
            }
            //根据消息物理偏移量从commitlog 文件中获取消息
            MessageExt msgExt = this.brokerController.getMessageStore().lookMessageByOffset(requestHeader.getOffset());
            if (null == msgExt) {
        
                response.setCode(ResponseCode.SYSTEM_ERROR);
                response.setRemark("look message by offset failed, " + requestHeader.getOffset());
                return CompletableFuture.completedFuture(response);
            }
    
            final String retryTopic = msgExt.getProperty(MessageConst.PROPERTY_RETRY_TOPIC);
            if (null == retryTopic) {
        
                //将消息的主题存入属性中。
                MessageAccessor.putProperty(msgExt, MessageConst.PROPERTY_RETRY_TOPIC, msgExt.getTopic());
            }
            //消息发送时是否等消息存储完成后再返回
            msgExt.setWaitStoreMsgOK(false);
            //获取延迟级别
            int delayLevel = requestHeader.getDelayLevel();
    
            //设置消息最大重试次数,默认16次
            int maxReconsumeTimes = subscriptionGroupConfig.getRetryMaxTimes();
            if (request.getVersion() >= MQVersion.Version.V3_4_9.ordinal()) {
        
                maxReconsumeTimes = requestHeader.getMaxReconsumeTimes();
            }
    
            //如果消息已重试次数超过maxReconsumeTimes
            if (msgExt.getReconsumeTimes() >= maxReconsumeTimes 
                || delayLevel < 0) {
        
                //改变newTopic 主题为DLQ （” %DLQ%”）
                newTopic = MixAll.getDLQTopic(requestHeader.getGroup());
                queueIdInt = Math.abs(this.random.nextInt() % 99999999) % DLQ_NUMS_PER_GROUP;
    
                topicConfig = this.brokerController.getTopicConfigManager().createTopicInSendMessageBackMethod(newTopic,
                        DLQ_NUMS_PER_GROUP,
                        //该主题的权限为只写,说明消息一旦进入到DLQ 队列中， RocketMQ 将不负责再次调度进行消费了，需要人工干预。
                        PermName.PERM_WRITE, 0);
                if (null == topicConfig) {
        
                    response.setCode(ResponseCode.SYSTEM_ERROR);
                    response.setRemark("topic[" + newTopic + "] not exist");
                    return CompletableFuture.completedFuture(response);
                }
            } else {
        
                //如果延迟级别为0，则设置为消息已重试次数+3
                if (0 == delayLevel) {
        
                    delayLevel = 3 + msgExt.getReconsumeTimes();
                }
                //重新设置延迟级别
                msgExt.setDelayTimeLevel(delayLevel);
            }
    
            //根据原先的消息创建一个新的消息对象
            MessageExtBrokerInner msgInner = new MessageExtBrokerInner();
            msgInner.setTopic(newTopic);
            msgInner.setBody(msgExt.getBody());
            msgInner.setFlag(msgExt.getFlag());
            MessageAccessor.setProperties(msgInner, msgExt.getProperties());
            msgInner.setPropertiesString(MessageDecoder.messageProperties2String(msgExt.getProperties()));
            msgInner.setTagsCode(MessageExtBrokerInner.tagsString2tagsCode(null, msgExt.getTags()));
    
            msgInner.setQueueId(queueIdInt);
            msgInner.setSysFlag(msgExt.getSysFlag());
            msgInner.setBornTimestamp(msgExt.getBornTimestamp());
            msgInner.setBornHost(msgExt.getBornHost());
            msgInner.setStoreHost(msgExt.getStoreHost());
            msgInner.setReconsumeTimes(msgExt.getReconsumeTimes() + 1);
            //设置消息ORIGIN_MESSAGE_ID
            String originMsgId = MessageAccessor.getOriginMessageId(msgExt);
            MessageAccessor.setOriginMessageId(msgInner, UtilAll.isBlank(originMsgId) ? msgExt.getMsgId() : originMsgId);
            /*
            重试消息会拥有自己的唯一消息ID
            ( msgld ）并存人到commitlog 文件中，并不会去更新原先消息， 而是会将原先的主题、消息
            ID 存入消息的属性中， 主题名称为重试主题， 其他属性与原先消息保持相同
             */
            CompletableFuture<PutMessageResult> putMessageResult = this.brokerController.getMessageStore().asyncPutMessage(msgInner);
            return putMessageResult.thenApply((r) -> {
        
                if (r != null) {
        
                    switch (r.getPutMessageStatus()) {
        
                        case PUT_OK:
                            String backTopic = msgExt.getTopic();
                            String correctTopic = msgExt.getProperty(MessageConst.PROPERTY_RETRY_TOPIC);
                            if (correctTopic != null) {
        
                                backTopic = correctTopic;
                            }
                            this.brokerController.getBrokerStatsManager().incSendBackNums(requestHeader.getGroup(), backTopic);
                            response.setCode(ResponseCode.SUCCESS);
                            response.setRemark(null);
                            return response;
                        default:
                            break;
                    }
                    response.setCode(ResponseCode.SYSTEM_ERROR);
                    response.setRemark(r.getPutMessageStatus().name());
                    return response;
                }
                response.setCode(ResponseCode.SYSTEM_ERROR);
                response.setRemark("putMessageResult is null");
                return response;
            });
        }

根据消息物理偏移量从commitlog 文件中获取消息  
**DefaultMessageStore**

public MessageExt lookMessageByOffset(long commitLogOffset) {
        
            SelectMappedBufferResult sbr = this.commitLog.getMessage(commitLogOffset, 4);
            if (null != sbr) {
        
                try {
        
                    // 1 TOTALSIZE
                    int size = sbr.getByteBuffer().getInt();
                    //根据偏移和size,读取一条消息
                    return lookMessageByOffset(commitLogOffset, size);
                } finally {
        
                    sbr.release();
                }
            }
    
            return null;
        }

存延时消息到log  
**DefaultMessageStore**

@Override
        public CompletableFuture<PutMessageResult> asyncPutMessage(MessageExtBrokerInner msg) {
        
            //是否可写入
            PutMessageStatus checkStoreStatus = this.checkStoreStatus();
            if (checkStoreStatus != PutMessageStatus.PUT_OK) {
        
                return CompletableFuture.completedFuture(new PutMessageResult(checkStoreStatus, null));
            }
    
            //校验消息
            PutMessageStatus msgCheckStatus = this.checkMessage(msg);
            if (msgCheckStatus == PutMessageStatus.MESSAGE_ILLEGAL) {
        
                return CompletableFuture.completedFuture(new PutMessageResult(msgCheckStatus, null));
            }
    
            long beginTime = this.getSystemClock().now();
            //写入消息到commitLog
            CompletableFuture<PutMessageResult> putResultFuture = this.commitLog.asyncPutMessage(msg);
    
            putResultFuture.thenAccept((result) -> {
        
                long elapsedTime = this.getSystemClock().now() - beginTime;
                if (elapsedTime > 500) {
        
                    log.warn("putMessage not in lock elapsed time(ms)={}, bodyLength={}", elapsedTime, msg.getBody().length);
                }
                this.storeStatsService.setPutMessageEntireTimeMax(elapsedTime);
    
                if (null == result || !result.isOk()) {
        
                    this.storeStatsService.getPutMessageFailedTimes().incrementAndGet();
                }
            });
    
            return putResultFuture;
        }

写入消息到commitLog  
注意这里,队列ID为延迟级别-1  
**CommitLog**

//若是普通消息
            if (tranType == MessageSysFlag.TRANSACTION_NOT_TYPE
                //事务消息
                    || tranType == MessageSysFlag.TRANSACTION_COMMIT_TYPE) {
        
                // Delay Delivery 若消息的延迟级别大于0
                if (msg.getDelayTimeLevel() > 0) {
        
                    //若>MessageStoreConfig#messageDelayLevel 中最大消息延迟级别,则最大延迟级别
                    if (msg.getDelayTimeLevel() > this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel()) {
        
                        msg.setDelayTimeLevel(this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel());
                    }
    
                    //替换消息的主题与队列为定时任务主题“ SCHEDULE TOPIC XXXX ”，
                    topic = TopicValidator.RMQ_SYS_SCHEDULE_TOPIC;
                    //队列ID 为延迟级别减1
                    queueId = ScheduleMessageService.delayLevel2QueueId(msg.getDelayTimeLevel());
    
                    // Backup real topic, queueId
                    /*
                    将消息主题、队列存入消息的属性中，键分别为： PROPERTY_REAL_TOPIC 、PROPERTY_REAL_QUEUE_ID 。
                     */
                    MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_TOPIC, msg.getTopic());
                    MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_QUEUE_ID, String.valueOf(msg.getQueueId()));
                    msg.setPropertiesString(MessageDecoder.messageProperties2String(msg.getProperties()));
    
                    msg.setTopic(topic);
                    msg.setQueueId(queueId);
                }
            }

# 消息进度管理 #

消息进度文件可分别存储如下:

1.  广播模式：  
    同一个消费组的所有消息消费者都需要消费主题下的所有消息，也就是同组内的消费者的消息消费行为是对立的，互相不影响，故消息进度需要独立存储，最理想的存储地方应该是与消费者绑定。
2.  集群模式：同一个消费组内的所有消息消费者共享消息主题下的所有消息，  
    同一条消息（同一个消息消费队列）在同一时间只会被消费组内的一个消费者消费，并且随着消费队列的动态变化重新负载，所以消费进度需要保存在一个每个消费者都能访问到的地方。

在启动DefaultMQPushConsumerImpl的时候,会分别根据模式不同,创建进度保存对象.默认创建集群模式  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 7]  
注意

1.  每次更新进度的时候,默认最小的进度更新,若最大的进度更新,在最大进度之前的消息出现死锁,将导致消息消费,从而进度无法推进.
2.  在重新负载队列时,将ProceeQueue状态设置为true,持久化该消息队列的消费进度，并从内存中移除。

## 广播模式存储 ##

先看看 **LocalFileOffsetStore\#load**  
**LocalFileOffsetStore**

public void load() throws MQClientException {
        
            //尝试从storePath或storePath.bak加载json数据,并解析成OffsetSerializeWrapper
            OffsetSerializeWrapper offsetSerializeWrapper = this.readLocalOffset();
            if (offsetSerializeWrapper != null && offsetSerializeWrapper.getOffsetTable() != null) {
        
                offsetTable.putAll(offsetSerializeWrapper.getOffsetTable());
                //打印组名,mq和进度
                for (MessageQueue mq : offsetSerializeWrapper.getOffsetTable().keySet()) {
        
                    AtomicLong offset = offsetSerializeWrapper.getOffsetTable().get(mq);
                    log.info("load consumer's offset, {} {} {}",
                        this.groupName,
                        mq,
                        offset.get());
                }
            }
        }

会分别尝试从从storePath或storePath.bak加载json数据,并解析成OffsetSerializeWrapper  
![在这里插入图片描述][20200908104814432.png_pic_center]

![在这里插入图片描述][20200908104840150.png_pic_center]  
在启动MQClientInstance\#startScheduledTask时,会启动一个定时任务定时持久化进度,默认5秒![在这里插入图片描述][20200908110352953.png_pic_center]  
持久化所有消费者进入刷入磁盘  
**MQClientInstance**

private void persistAllConsumerOffset() {
        
            Iterator<Entry<String, MQConsumerInner>> it = this.consumerTable.entrySet().iterator();
            while (it.hasNext()) {
        
                Entry<String, MQConsumerInner> entry = it.next();
                MQConsumerInner impl = entry.getValue();
                impl.persistConsumerOffset();//持久化所有消费者进入刷入磁盘
            }
        }

**DefaultMQPushConsumerImpl**

public void persistConsumerOffset() {
        
            try {
        
                //查看状态是否为RUNNING
                this.makeSureStateOK();
                Set<MessageQueue> mqs = new HashSet<MessageQueue>();
                //获取所有分配的MQ
                Set<MessageQueue> allocateMq = this.rebalanceImpl.getProcessQueueTable().keySet();
                mqs.addAll(allocateMq);
                //刷入进度到磁盘
                this.offsetStore.persistAll(mqs);
            } catch (Exception e) {
        
                log.error("group: " + this.defaultMQPushConsumer.getConsumerGroup() + " persistConsumerOffset exception", e);
            }
        }

刷入进度到磁盘  
**LocalFileOffsetStore**

public void persistAll(Set<MessageQueue> mqs) {
        
            if (null == mqs || mqs.isEmpty())
                return;
            //获取偏移封装到OffsetSerializeWrapper,并解析成JSON
            OffsetSerializeWrapper offsetSerializeWrapper = new OffsetSerializeWrapper();
            for (Map.Entry<MessageQueue, AtomicLong> entry : this.offsetTable.entrySet()) {
        
                if (mqs.contains(entry.getKey())) {
        
                    AtomicLong offset = entry.getValue();
                    offsetSerializeWrapper.getOffsetTable().put(entry.getKey(), offset);
                }
            }
    
            String jsonString = offsetSerializeWrapper.toJson(true);
            if (jsonString != null) {
        
                try {
        
                    //将ConcurrentMap <MessageQueue, AtomicLong> offsetTable 序列化到磁盘文件中
                    MixAll.string2File(jsonString, this.storePath);
                } catch (IOException e) {
        
                    log.error("persistAll consumer offset Exception, " + this.storePath, e);
                }
            }
        }

## 集群模式存储 ##

load为空  
更新进度数据  
**ConsumeMessageConcurrentlyService**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 8]

从ProcessQueue中移除这批消息,返回移除该批消息后最小的偏移量

public long removeMessage(final List<MessageExt> msgs) {
        
            long result = -1;
            final long now = System.currentTimeMillis();
            try {
        
                this.lockTreeMap.writeLock().lockInterruptibly();
                this.lastConsumeTimestamp = now;
                try {
        
                    if (!msgTreeMap.isEmpty()) {
        
                        result = this.queueOffsetMax + 1;
                        int removedCnt = 0;
                        for (MessageExt msg : msgs) {
        
                            MessageExt prev = msgTreeMap.remove(msg.getQueueOffset());
                            if (prev != null) {
        
                                removedCnt--;
                                msgSize.addAndGet(0 - msg.getBody().length);//重新计算消息体总个数
                            }
                        }
                        msgCount.addAndGet(removedCnt);//重新计算减去的个数
    
                        if (!msgTreeMap.isEmpty()) {
        //若msg还有值,则重新计算最小偏移为第一个key
                            result = msgTreeMap.firstKey();
                        }
                    }
                } finally {
        
                    this.lockTreeMap.writeLock().unlock();
                }
            } catch (Throwable t) {
        
                log.error("removeMessage exception", t);
            }
    
            return result;
        }

**RemoteBrokerOffsetStore**

public void updateOffset(MessageQueue mq, long offset, boolean increaseOnly) {
        
            if (mq != null) {
        
                AtomicLong offsetOld = this.offsetTable.get(mq);
                //第一次新增
                if (null == offsetOld) {
        
                    offsetOld = this.offsetTable.putIfAbsent(mq, new AtomicLong(offset));
                }
                if (null != offsetOld) {
        
                    //是否只增加
                    if (increaseOnly) {
        
                        //CAS增加
                        MixAll.compareAndIncreaseOnly(offsetOld, offset);
                    } else {
        
                        //赋值
                        offsetOld.set(offset);
                    }
                }
            }
        }

定时5秒后刷broker  
**RemoteBrokerOffsetStore**

@Override
        public void persistAll(Set<MessageQueue> mqs) {
        
            if (null == mqs || mqs.isEmpty())
                return;
    
            final HashSet<MessageQueue> unusedMQ = new HashSet<MessageQueue>();
    
            for (Map.Entry<MessageQueue, AtomicLong> entry : this.offsetTable.entrySet()) {
        
                MessageQueue mq = entry.getKey();
                AtomicLong offset = entry.getValue();
                if (offset != null) {
        
                    if (mqs.contains(mq)) {
        
                        try {
        //刷broker
                            this.updateConsumeOffsetToBroker(mq, offset.get());
                            log.info("[persistAll] Group: {} ClientId: {} updateConsumeOffsetToBroker {} {}",
                                this.groupName,
                                this.mQClientFactory.getClientId(),
                                mq,
                                offset.get());
                        } catch (Exception e) {
        
                            log.error("updateConsumeOffsetToBroker exception, " + mq.toString(), e);
                        }
                    } else {
        
                        unusedMQ.add(mq);//记录没有用的MQ
                    }
                }
            }
            //删除没有用的MQ
            if (!unusedMQ.isEmpty()) {
        
                for (MessageQueue mq : unusedMQ) {
        
                    this.offsetTable.remove(mq);
                    log.info("remove unused mq, {}, {}", mq, this.groupName);
                }
            }
        }

剩下的就是和本地存差不多了.不概述了

# 消息拉取长轮询机制分析 #

RocketMQ 并没有真正实现推模式，而是消费者主动向消息服务器拉取消息， RocketMQ推模式是循环向消息服务端发送消息拉取请求，如果消息消费者向RocketMQ 发送消息拉取时，消息并未到达消费队列

*  不启用长轮询机制，则会在服务端等待shortPollingTimeMills时间后（挂起）再去判断消息是否已到达消息队列，如果消息未到达则提示消息拉取客户端PULL\_NOT\_FOUND （消息不存在）
 *  开启长轮询模式， RocketMQ 一方面会每5s 轮询检查一次消息是否可达， 同时一有新消息到达后立马通知挂起线程再次验证新消息是否是自己感兴趣的消息，如果是则从commitlog 文件提取消息返回给消息拉取客户端，否则直到挂起超时

根据是否开启长轮询来决定挂起方式， 如果支持长轮询模式， 挂起超时时间来源于请求参数，

1.  PUSH 模式默认为15s,
2.  PULL 模式通过DefaultMQPullConsumer\#brokerSuspenMaxTimeMillis设置，默认20 s然后创建拉取任务PullRequest 并提交到PullRequestHoldService 线程中

RocketMQ 轮询机制由两个线程共同来完成。

1.  PullRequestHoldService ： 每隔5s 重试一次。
2.  DefaultMessageStore\#ReputMessageService 每处理一次重新拉取Thread.sleep ( 1 ) ,继续下一次检查。

## PullRequestHoldService ##

每隔5s 被唤醒去尝试检测是否有新消息的到来直到超时， 如果被挂起， 需要等待5S。

**PullMessageProcessor**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 9]  
创建拉取任务PullRequest 并提交到PullRequestHoldService 线程中。  
**PullRequestHoldService**

public void suspendPullRequest(final String topic, final int queueId, final PullRequest pullRequest) {
        
            //根据消息主题与消息队列构建key
            String key = this.buildKey(topic, queueId);
            //获取该主题＠ 队列对应的ManyPullRequest
            ManyPullRequest mpr = this.pullRequestTable.get(key);
            if (null == mpr) {
        
                mpr = new ManyPullRequest();
                ManyPullRequest prev = this.pullRequestTable.putIfAbsent(key, mpr);
                if (prev != null) {
        
                    mpr = prev;
                }
            }
    
            //将PullRequest 放入ManyPullRequest
            mpr.addPullRequest(pullRequest);
        }

**PullRequestHoldService**

public void run() {
        
            log.info("{} service started", this.getServiceName());
            //“长轮询”服务端代码片段
            /*
            如果队列里没有
            新消息，并不急于返回，通过一个循环不断查看状态，每次waitForRunning
            一段时间（默认是5 秒）， 然后后再Check a 默认情况下当Broker 一直没
            有新消息， 第三次Check 的时候， 等待时间超过Request 里面的BrokerSuspen
            dMaxTimeMi11is ， 就返回空结果。在等待的过程中， Broker 收到了新的
            消息后会直接调用notifyMessageArriving 函数返回请求结果。“长轮询”的核
            心是， Broker 端HOLD 住客户端过来的请求一小段时间，在这个时间内有新
            消息到达，就利用现有的连接立刻返回消息给Consumer 。
    
            如果未开启长轮询，则默认等待ls 再次尝试，可以通过BrokerConfig#shortPollingTimeMills 改变等待时间
             */
            while (!this.isStopped()) {
        
                try {
        
                    //判断是否开启长轮询
                    if (this.brokerController.getBrokerConfig().isLongPollingEnable()) {
        
                        //若开启,则每5s尝试一次，判断新消息是否到达
                        this.waitForRunning(5 * 1000);
                    } else {
        
                        //默认等待ls 再次尝试
                        this.waitForRunning(this.brokerController.getBrokerConfig().getShortPollingTimeMills());
                    }
    
                    long beginLockTimestamp = this.systemClock.now();
                    this.checkHoldRequest();
                    long costTime = this.systemClock.now() - beginLockTimestamp;
                    if (costTime > 5 * 1000) {
        
                        log.info("[NOTIFYME] check hold request cost {} ms.", costTime);
                    }
                } catch (Throwable e) {
        
                    log.warn(this.getServiceName() + " service has exception. ", e);
                }
            }
    
            log.info("{} service end", this.getServiceName());
        }

触发消息拉取  
**PullRequestHoldService**

private void checkHoldRequest() {
        
            //遍历拉取任务表
            for (String key : this.pullRequestTable.keySet()) {
        
                String[] kArray = key.split(TOPIC_QUEUEID_SEPARATOR);
                if (2 == kArray.length) {
        
                    String topic = kArray[0];
                    int queueId = Integer.parseInt(kArray[1]);
                    //根据主题与队列获取消息消费队列最大偏移量，如果该偏移量大于待拉取偏移量， 说明有新的消息到达
                    final long offset = this.brokerController.getMessageStore().getMaxOffsetInQueue(topic, queueId);
                    try {
        
                        //触发消息拉取
                        this.notifyMessageArriving(topic, queueId, offset);
                    } catch (Throwable e) {
        
                        log.error("check hold request failed. topic={}, queueId={}", topic, queueId, e);
                    }
                }
            }
        }

**PullRequestHoldService**

public void notifyMessageArriving(final String topic, final int queueId, final long maxOffset) {
        
            notifyMessageArriving(topic, queueId, maxOffset, null, 0, null, null);
        }

public void notifyMessageArriving(final String topic, final int queueId, final long maxOffset, final Long tagsCode,
            long msgStoreTime, byte[] filterBitMap, Map<String, String> properties) {
        
            String key = this.buildKey(topic, queueId);
            //获取同一主题＠队列的累积拉取消息任务
            ManyPullRequest mpr = this.pullRequestTable.get(key);
            if (mpr != null) {
        
                List<PullRequest> requestList = mpr.cloneListAndClear();
                if (requestList != null) {
        
                    List<PullRequest> replayList = new ArrayList<PullRequest>();
                    //遍历同一主题＠队列的累积拉取消息任务
                    for (PullRequest request : requestList) {
        
                        //当前队列最大偏移<请求拉取的起始偏移
                        long newestOffset = maxOffset;
                        if (newestOffset <= request.getPullFromThisOffset()) {
        
                            //再次获取队列最大偏移
                            newestOffset = this.brokerController.getMessageStore().getMaxOffsetInQueue(topic, queueId);
                        }
    
                        //如果消息队列的最大偏移量大于待拉取偏移量
                        if (newestOffset > request.getPullFromThisOffset()) {
        
                            //根据ConsumeQueue 判断消息是否匹配。
                            boolean match = request.getMessageFilter().isMatchedByConsumeQueue(tagsCode,
                                new ConsumeQueueExt.CqExtUnit(tagsCode, msgStoreTime, filterBitMap));
                            // match by bit map, need eval again when properties is not null.
                            //属性不为空,则再次匹配
                            if (match && properties != null) {
        
                                match = request.getMessageFilter().isMatchedByCommitLog(null, properties);
                            }
    
                            if (match) {
        
                            //如果消息匹配
                                try {
        
                                    //将消息返回给消息拉取客户端，否则等待下一次尝试。
                                    this.brokerController.getPullMessageProcessor().executeRequestWhenWakeup(request.getClientChannel(),
                                        request.getRequestCommand());
                                } catch (Throwable e) {
        
                                    log.error("execute request when wakeup failed.", e);
                                }
                                continue;
                            }
                        }
    
                        //如果挂起超时时间超时
                        if (System.currentTimeMillis() >= (request.getSuspendTimestamp() + request.getTimeoutMillis())) {
        
                            try {
        
                                //不继续等待将直接返回客户消息未找到。
                                this.brokerController.getPullMessageProcessor().executeRequestWhenWakeup(request.getClientChannel(),
                                    request.getRequestCommand());
                            } catch (Throwable e) {
        
                                log.error("execute request when wakeup failed.", e);
                            }
                            continue;
                        }
    
                        replayList.add(request);
                    }
                     //记录失败请求.
                    if (!replayList.isEmpty()) {
        
                        mpr.addPullRequest(replayList);
                    }
                }
            }
        }

执行长轮询入口代码,并设置不支持拉取线程挂起  
**PullMessageProcessor**

public void executeRequestWhenWakeup(final Channel channel,
            final RemotingCommand request) throws RemotingCommandException {
        
            Runnable run = new Runnable() {
        
                @Override
                public void run() {
        
                    try {
        
                        //brokerAllowSuspend 为false ， 表示不支持拉取线程挂起，
                        //即当根据偏移量无法获取消息时将不挂起线程等待新消息到来，而是直接返回告诉客户端本次消息拉取未找到消息。
                        final RemotingCommand response = PullMessageProcessor.this.processRequest(channel, request, false);
    
                        if (response != null) {
        
                            response.setOpaque(request.getOpaque());
                            response.markResponseType();
                            try {
        
                                channel.writeAndFlush(response).addListener(new ChannelFutureListener() {
        
                                    @Override
                                    public void operationComplete(ChannelFuture future) throws Exception {
        
                                        if (!future.isSuccess()) {
        
                                            log.error("processRequestWrapper response to {} failed",
                                                future.channel().remoteAddress(), future.cause());
                                            log.error(request.toString());
                                            log.error(response.toString());
                                        }
                                    }
                                });
                            } catch (Throwable e) {
        
                                log.error("processRequestWrapper process request over, but response failed", e);
                                log.error(request.toString());
                                log.error(response.toString());
                            }
                        }
                    } catch (RemotingCommandException e1) {
        
                        log.error("excuteRequestWhenWakeup run", e1);
                    }
                }
            };
            this.brokerController.getPullMessageExecutor().submit(new RequestTask(run, channel, request));
        }

## DefaultMessageStore ##

当消息到达时唤醒挂起线程触发一次检查  
根据Commitlog 将消息转发到ConsumeQueue 、Index等文件，同时唤醒挂起线程触发一次检查.  
**DefaultMessageStore.ReputMessageService**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 10]

# 消息队列负载机制 #

MQClientInstance启动时,会启动一个rebalanceService,主要负责列负载与重新分布

public void start() throws MQClientException {
        
    
            synchronized (this) {
        
                switch (this.serviceState) {
        
                        //默认当前状态
                    case CREATE_JUST:
                        this.serviceState = ServiceState.START_FAILED;
                        // If not specified,looking address from name server
                        if (null == this.clientConfig.getNamesrvAddr()) {
        
                            this.mQClientAPIImpl.fetchNameServerAddr();
                        }
                        // Start request-response channel
                        this.mQClientAPIImpl.start();
                        // Start various schedule tasks
                        this.startScheduledTask();
                        // Start pull service
                        //单独开启一个线程,负责消息的拉取
                        this.pullMessageService.start();
                        // Start rebalance service
                        //负责队列负载与重新分布
                        this.rebalanceService.start();
                        // Start push service
                        this.defaultMQProducer.getDefaultMQProducerImpl().start(false);
                        log.info("the client factory [{}] start OK", this.clientId);
                        this.serviceState = ServiceState.RUNNING;
                        break;
                    case START_FAILED:
                        throw new MQClientException("The Factory object[" + this.getClientId() + "] has been created before, and failed.", null);
                    default:
                        break;
                }
            }
        }

启动RebalanceService,间隔20S执行一次.使用－Drocketmq.client.rebalance.waitInterval=interval来改变默认值。  
**RebalanceService**

public void run() {
        
            log.info(this.getServiceName() + " service started");
    
            while (!this.isStopped()) {
        
                //间隔20S执行一次.使用－Drocketmq.client.rebalance.waitInterval=interval来改变默认值。
                this.waitForRunning(waitInterval);
                this.mqClientFactory.doRebalance();
            }
    
            log.info(this.getServiceName() + " service end");
        }

**MQClientInstance**

public void doRebalance() {
        
            //遍历巳注册的消费者
            for (Map.Entry<String, MQConsumerInner> entry : this.consumerTable.entrySet()) {
        
                MQConsumerInner impl = entry.getValue();
                if (impl != null) {
        
                    try {
        
                        //消费者执行doRebalance
                        impl.doRebalance();
                    } catch (Throwable e) {
        
                        log.error("doRebalance exception", e);
                    }
                }
            }
        }

**DefaultMQPushConsumerImpl**

public void doRebalance() {
        
            //如果当前消费者没被挂起
            if (!this.pause) {
        
                this.rebalanceImpl.doRebalance(this.isConsumeOrderly());//是否有序消费
            }
        }

对每个主题的队列进行重新负载  
**RebalanceImpl**

public void doRebalance(final boolean isOrder) {
        
            Map<String, SubscriptionData> subTable = this.getSubscriptionInner();
            if (subTable != null) {
        
                //遍历订阅信息
                for (final Map.Entry<String, SubscriptionData> entry : subTable.entrySet()) {
        
                    final String topic = entry.getKey();
                    try {
        
                        //对每个主题的队列进行重新负载
                        this.rebalanceByTopic(topic, isOrder);
                    } catch (Throwable e) {
        
                        if (!topic.startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)) {
        
                            log.warn("rebalanceByTopic Exception", e);
                        }
                    }
                }
            }
            //截断在processQueueTable中,但是不在getSubscriptionInnerProcessQueue
            this.truncateMessageQueueNotMyTopic();
        }

对主题的队列进行重新负载  
**RebalanceImpl**

private void rebalanceByTopic(final String topic, final boolean isOrder) {
        
            switch (messageModel) {
        
                case BROADCASTING: {
        
                    Set<MessageQueue> mqSet = this.topicSubscribeInfoTable.get(topic);
                    if (mqSet != null) {
        
                        boolean changed = this.updateProcessQueueTableInRebalance(topic, mqSet, isOrder);
                        if (changed) {
        
                            this.messageQueueChanged(topic, mqSet, mqSet);
                            log.info("messageQueueChanged {} {} {} {}",
                                consumerGroup,
                                topic,
                                mqSet,
                                mqSet);
                        }
                    } else {
        
                        log.warn("doRebalance, {}, but the topic[{}] not exist.", consumerGroup, topic);
                    }
                    break;
                }
                case CLUSTERING: {
        
                    //从主题订阅信息缓存表中获取主题的队列信息
                    Set<MessageQueue> mqSet = this.topicSubscribeInfoTable.get(topic);
                    //发送请求给broker,从中获取该消费组内当前所有消费者客户端ID
                    List<String> cidAll = this.mQClientFactory.findConsumerIdList(topic, consumerGroup);
                    if (null == mqSet) {
        
                        if (!topic.startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)) {
        
                            log.warn("doRebalance, {}, but the topic[{}] not exist.", consumerGroup, topic);
                        }
                    }
    
                    if (null == cidAll) {
        
                        log.warn("doRebalance, {} {}, get consumer id list failed", consumerGroup, topic);
                    }
    
                    if (mqSet != null && cidAll != null) {
        
                        List<MessageQueue> mqAll = new ArrayList<MessageQueue>();
                        mqAll.addAll(mqSet);
    
                        //排序,确保同一个消费组内看到的视图保持一致
                        //确保同一个消费队列不会被多个消费者分配
                        Collections.sort(mqAll);
                        Collections.sort(cidAll);
    
                        AllocateMessageQueueStrategy strategy = this.allocateMessageQueueStrategy;
    
                        List<MessageQueue> allocateResult = null;
                        try {
        
                            //RocketMQ 消息队列分配
                            allocateResult = strategy.allocate(
                                this.consumerGroup,
                                this.mQClientFactory.getClientId(),
                                mqAll,
                                cidAll);
                        } catch (Throwable e) {
        
                            log.error("AllocateMessageQueueStrategy.allocate Exception. allocateMessageQueueStrategyName={}", strategy.getName(),
                                e);
                            return;
                        }
    
                        Set<MessageQueue> allocateResultSet = new HashSet<MessageQueue>();
                        if (allocateResult != null) {
        
                            allocateResultSet.addAll(allocateResult);
                        }
                        //更新进程队列表
                        boolean changed = this.updateProcessQueueTableInRebalance(topic, allocateResultSet, isOrder);
                        if (changed) {
        
                            log.info(
                                "rebalanced result changed. allocateMessageQueueStrategyName={}, group={}, topic={}, clientId={}, mqAllSize={}, cidAllSize={}, rebalanceResultSize={}, rebalanceResultSet={}",
                                strategy.getName(), consumerGroup, topic, this.mQClientFactory.getClientId(), mqSet.size(), cidAll.size(),
                                allocateResultSet.size(), allocateResultSet);
                            this.messageQueueChanged(topic, mqSet, allocateResultSet);
                        }
                    }
                    break;
                }
                default:
                    break;
            }
        }

发送请求给broker,从中获取该消费组内当前所有消费者客户端ID  
**MQClientInstance**

public List<String> findConsumerIdList(final String topic, final String group) {
        
            //根据topic获取broker MASTER地址
            String brokerAddr = this.findBrokerAddrByTopic(topic);
            //地址为空
            if (null == brokerAddr) {
        
                //从name更新
                this.updateTopicRouteInfoFromNameServer(topic);
                //再次查找
                brokerAddr = this.findBrokerAddrByTopic(topic);
            }
    
            if (null != brokerAddr) {
        
                try {
        
                    return this.mQClientAPIImpl.getConsumerIdListByGroup(brokerAddr, group, 3000);
                } catch (Exception e) {
        
                    log.warn("getConsumerIdListByGroup exception, " + brokerAddr + " " + group, e);
                }
            }
    
            return null;
        }

根据topic获取broker MASTER地址  
**MQClientInstance**

public String findBrokerAddrByTopic(final String topic) {
        
            TopicRouteData topicRouteData = this.topicRouteTable.get(topic);
            if (topicRouteData != null) {
        
                //获取broker信息
                List<BrokerData> brokers = topicRouteData.getBrokerDatas();
                if (!brokers.isEmpty()) {
        
                    //随机获取一个brokerDate
                    int index = random.nextInt(brokers.size());
                    BrokerData bd = brokers.get(index % brokers.size());
                    //返回Master地址
                    return bd.selectBrokerAddr();
                }
            }
    
            return null;
        }

RocketMQ 消息队列分配  
有6种分配策略

1.  AllocateMessageQueueAveragely:平均分配
2.  AllocateMessageQueueAveragelyByCircle:平均轮询分配
3.  AllocateMessageQueueConsistentHash:一致性hash  
    等等  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 11]  
    重新分配后,更新进程队列表  
    如果缓存表中的MessageQueue 不包含在mqSet 中,说明经过本次消息队列负载后，该mq**之前**被分配给其他消费者.  
    将该mq从缓存表中删除.然后在遍历本次负载分配到的队列集合时,新建ProcessQueue并加入缓存表,随后新建PullRequest,唤醒PullMessageService 线程，拉取消息.  
    **RebalanceImpl**

private boolean updateProcessQueueTableInRebalance(final String topic, final Set<MessageQueue> mqSet,
            final boolean isOrder) {
        
            boolean changed = false;
    
            //获取当前消费者负载的消息队列缓存表
            Iterator<Entry<MessageQueue, ProcessQueue>> it = this.processQueueTable.entrySet().iterator();
            while (it.hasNext()) {
        
                Entry<MessageQueue, ProcessQueue> next = it.next();
                MessageQueue mq = next.getKey();
                ProcessQueue pq = next.getValue();
    
                if (mq.getTopic().equals(topic)) {
        
                    //如果缓存表中的MessageQueue 不包含在mqSet 中
                    //说明经过本次消息队列负载后，该mq 被分配给其他消费者
                    if (!mqSet.contains(mq)) {
        
                        //暂停该消息队列消息的消费
                        pq.setDropped(true);
                        //持久化待移除MessageQueue 消息消费进度
                        if (this.removeUnnecessaryMessageQueue(mq, pq)) {
        
                        //将MessageQueue 、ProccessQueue从缓存表中移除
                            it.remove();
                            changed = true;
                            log.info("doRebalance, {}, remove unnecessary mq, {}", consumerGroup, mq);
                        }
                    } else if (pq.isPullExpired()) {
        
                        switch (this.consumeType()) {
        
                            case CONSUME_ACTIVELY:
                                break;
                            case CONSUME_PASSIVELY:
                                pq.setDropped(true);
                                if (this.removeUnnecessaryMessageQueue(mq, pq)) {
        
                                    it.remove();
                                    changed = true;
                                    log.error("[BUG]doRebalance, {}, remove unnecessary mq, {}, because pull is pause, so try to fixed it",
                                        consumerGroup, mq);
                                }
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
    
            List<PullRequest> pullRequestList = new ArrayList<PullRequest>();
            //遍历本次负载分配到的队列集合
            for (MessageQueue mq : mqSet) {
        
                //如果processQueueTable 中没有包含该消息队列
                //表明这是本次新增加的消息队列，
                if (!this.processQueueTable.containsKey(mq)) {
        
                    if (isOrder && !this.lock(mq)) {
        
                        log.warn("doRebalance, {}, add a new mq failed, {}, because lock failed", consumerGroup, mq);
                        continue;
                    }
    
                    //从内存中移除该消息队列的消费进度
                    this.removeDirtyOffset(mq);
                    ProcessQueue pq = new ProcessQueue();
                    //从磁盘中读取该消息队列的消费进度
                    long nextOffset = this.computePullFromWhere(mq);
                    if (nextOffset >= 0) {
        
                        ProcessQueue pre = this.processQueueTable.putIfAbsent(mq, pq);
                        if (pre != null) {
        
                            log.info("doRebalance, {}, mq already exists, {}", consumerGroup, mq);
                        } else {
        
                            log.info("doRebalance, {}, add a new mq, {}", consumerGroup, mq);
                            PullRequest pullRequest = new PullRequest();
                            pullRequest.setConsumerGroup(consumerGroup);
                            pullRequest.setNextOffset(nextOffset);
                            pullRequest.setMessageQueue(mq);
                            pullRequest.setProcessQueue(pq);
                            pullRequestList.add(pullRequest);
                            changed = true;
                        }
                    } else {
        
                        log.warn("doRebalance, {}, add new mq failed, {}", consumerGroup, mq);
                    }
                }
            }
            //唤醒PullMessageService 线程，拉取消息
            this.dispatchPullRequest(pullRequestList);
    
            return changed;
        }

从磁盘中读取该消息队列的消费进度  
**RebalancePushImpl**

public long computePullFromWhere(MessageQueue mq) {
        
            /*
            如果读取到的消费进度小于0 ，则需要校对消费进度。
            RocketMQ 提供CONSUME_FROM_LAST_OFFSET 、CONSUME_FROM_F IRST OFFSET 、CONSUME_FROM_TIMESTAMP 方式，
            在创建消费者时可以通过调用DefaultMQPushConsumer#s etConsumeFromWhere 方法设置。
             */
            long result = -1;
            final ConsumeFromWhere consumeFromWhere = this.defaultMQPushConsumerImpl.getDefaultMQPushConsumer().getConsumeFromWhere();
            final OffsetStore offsetStore = this.defaultMQPushConsumerImpl.getOffsetStore();
            //只有在lastOffset=-1才会校正.
            //如果从消息进度存储文件中返回的消费进度小于一l ， 表示偏移量非法， 则使用偏移量－ 1 去拉取消息，
            //第一次去消息服务器拉取消息时无法取到消息， 但是会用一l 去更新消费进度，
            //然后将消息消费队列丢弃， 在下一次消息队列负载时会再次消费。
            switch (consumeFromWhere) {
        
                case CONSUME_FROM_LAST_OFFSET_AND_FROM_MIN_WHEN_BOOT_FIRST:
                case CONSUME_FROM_MIN_OFFSET:
                case CONSUME_FROM_MAX_OFFSET:
                    //从队列最新偏移量开始消费。
                case CONSUME_FROM_LAST_OFFSET: {
        
                    //从磁盘中读取到消息队列的消费进度，
                    long lastOffset = offsetStore.readOffset(mq, ReadOffsetType.READ_FROM_STORE);
                    if (lastOffset >= 0) {
        
                        result = lastOffset;
                    }
                    // First start,no offset
                    else if (-1 == lastOffset) {
        
                        //该消息队列刚创建
                        if (mq.getTopic().startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)) {
        
                            result = 0L;
                        } else {
        
                            try {
        
                                //获取该消息队列当前最大的偏移量
                                result = this.mQClientFactory.getMQAdminImpl().maxOffset(mq);
                            } catch (MQClientException e) {
        
                                result = -1;
                            }
                        }
                    } else {
        
                        //表示该消息进度文件中存储了错误的偏移量， 返回－ 1 。
                        result = -1;
                    }
                    break;
                }
                case CONSUME_FROM_FIRST_OFFSET: {
        
                    //从队列当前最小偏移量开始消费
                    long lastOffset = offsetStore.readOffset(mq, ReadOffsetType.READ_FROM_STORE);
                    if (lastOffset >= 0) {
        
                        result = lastOffset;
                    } else if (-1 == lastOffset) {
        
                        //返回0 ，从头开始
                        result = 0L;
                    } else {
        
                        //该消息进度文件中存储了错误的偏移量，返回一l 。
                        result = -1;
                    }
                    break;
                }
                case CONSUME_FROM_TIMESTAMP: {
        
                    //从消费者启动的时间戳对应的消费进度开始消费
                    //从磁盘中读取到消息队列的消费进度
                    long lastOffset = offsetStore.readOffset(mq, ReadOffsetType.READ_FROM_STORE);
                    if (lastOffset >= 0) {
        
                        result = lastOffset;
                    } else if (-1 == lastOffset) {
        
                        if (mq.getTopic().startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)) {
        
                            try {
        
                                result = this.mQClientFactory.getMQAdminImpl().maxOffset(mq);
                            } catch (MQClientException e) {
        
                                result = -1;
                            }
                        } else {
        
                            try {
        
                                 //尝试去操作消息存储时间戳为消费者启动的时间戳
                                long timestamp = UtilAll.parseDate(this.defaultMQPushConsumerImpl.getDefaultMQPushConsumer().getConsumeTimestamp(),
                                    UtilAll.YYYYMMDDHHMMSS).getTime();
                                //如果能找到则返回找到的偏移量，否则返回0
                                result = this.mQClientFactory.getMQAdminImpl().searchOffset(mq, timestamp);
                            } catch (MQClientException e) {
        
                                result = -1;
                            }
                        }
                    } else {
        
                        result = -1;
                    }
                    break;
                }
    
                default:
                    break;
            }
    
            return result;
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 12]

## 总结 ##

消费者注册的topic,在topicSubscribeInfoTable并不会添加.这个数据主要从  
![在这里插入图片描述][20200905220518765.png_pic_center]  
当执行**updateTopicRouteInfoFromNameServer**方法会从broker拉取TopicRouteData,从而更新topicSubscribeInfoTable.

# 定时消息 #

RocketMQ为了性能的考量,没有支持任意时刻的时间精度.  
只支持特定级别的延迟消息.  
消息延迟级别在Broker 端通过messageDelayLevel 配置

属性

//第一次调度时延迟的时间，默认为ls
        private static final long FIRST_DELAY_TIME = 1000L;
        //每一延时级别调度一次后延迟该时间间隔后再放入调度池。
        private static final long DELAY_FOR_A_WHILE = 100L;
        //发送异常后延迟该时间后再继续参与调度。
        private static final long DELAY_FOR_A_PERIOD = 10000L;
    
        //延迟级别，将” ls 5s 10s 30s lm 2m 3m 4m Sm 6m 7m 8m 9m 10m 20m 30m lh 2h ”字符串解析
        //成delayLevelTable ， 转换后的数据结构类似｛ 1: 1000 ,2 :5000,3:30000, . . . ｝ 。
        private final ConcurrentMap<Integer /* level */, Long/* delay timeMillis */> delayLevelTable =
            new ConcurrentHashMap<Integer, Long>(32);
    
        //延迟级别消息消费进度。
        private final ConcurrentMap<Integer /* level */, Long/* offset */> offsetTable =
            new ConcurrentHashMap<Integer, Long>(32);
        //默认消息存储器
        private final DefaultMessageStore defaultMessageStore;
        private final AtomicBoolean started = new AtomicBoolean(false);
        private Timer timer;
        private MessageStore writeMessageStore;
        //MessageStoreConfig#messageDelayLevel 中最大消息延迟级别
        private int maxDelayLevel;

## load ##

在执行DefaultMessageStore\#load时候,会加载延时消息服务.  
![在这里插入图片描述][20200908124925785.png_pic_center]  
**ScheduleMessageService**

public boolean load() {
        
            //加载延迟消息消费队列消息进度
            boolean result = super.load();
            //解析MessagestoreConfig#messageDelayLevel 定义的延迟级别转换为Map
            result = result && this.parseDelayLevel();
            return result;
        }

调用父类方法,会从$\{ROCKET\_HOME\}/store\\config\\delayOffset.json加载JSON,并解析

public boolean load() {
        
            String fileName = null;
            try {
        
                fileName = this.configFilePath();
                String jsonString = MixAll.file2String(fileName);
    
                if (null == jsonString || jsonString.length() == 0) {
        
                    return this.loadBak();
                } else {
        
                    this.decode(jsonString);
                    log.info("load " + fileName + " OK");
                    return true;
                }
            } catch (Exception e) {
        
                log.error("load " + fileName + " failed, and try to load backup file", e);
                return this.loadBak();
            }
        }

随后解析MessagestoreConfig\#messageDelayLevel 定义的延迟级别转换为Map

public boolean parseDelayLevel() {
        
            HashMap<String, Long> timeUnitTable = new HashMap<String, Long>();
            timeUnitTable.put("s", 1000L);
            timeUnitTable.put("m", 1000L * 60);
            timeUnitTable.put("h", 1000L * 60 * 60);
            timeUnitTable.put("d", 1000L * 60 * 60 * 24);
    
            String levelString = this.defaultMessageStore.getMessageStoreConfig().getMessageDelayLevel();
            try {
        
                String[] levelArray = levelString.split(" ");
                for (int i = 0; i < levelArray.length; i++) {
        
                    String value = levelArray[i];
                    String ch = value.substring(value.length() - 1);
                    Long tu = timeUnitTable.get(ch);
    
                    int level = i + 1;
                    if (level > this.maxDelayLevel) {
        
                        this.maxDelayLevel = level;
                    }
                    long num = Long.parseLong(value.substring(0, value.length() - 1));
                    long delayTimeMillis = tu * num;
                    this.delayLevelTable.put(level, delayTimeMillis);
                }
            } catch (Exception e) {
        
                log.error("parseDelayLevel exception", e);
                log.info("levelString String = {}", levelString);
                return false;
            }
    
            return true;
        }

结果如下:<延迟级别：对应延迟毫秒>  
默认为” ls 5s 10s 30s lm 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h"对应的delayLevel=1,表示延迟1s  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 13]

## start ##

**DefaultMessageStore**

public void handleScheduleMessageService(final BrokerRole brokerRole) {
        
            if (this.scheduleMessageService != null) {
        
                if (brokerRole == BrokerRole.SLAVE) {
        
                    this.scheduleMessageService.shutdown();
                } else {
        //只有主才能启动定时延迟任务?
                    this.scheduleMessageService.start();
                }
            }
    
        }

RocketMQ会为每个延时队列创建一个公有的主题SCHEDULE\_TOPIC\_XXXX,然后根据延迟级别不同,创建不同的消息队列.  
根据延迟级别创建对应的定时任务，启动定时任务持久化延迟消息队列进度存储  
**ScheduleMessageService**

public void start() {
        
            if (started.compareAndSet(false, true)) {
        
                this.timer = new Timer("ScheduleMessageTimerThread", true);
                //遍历延时级别
                for (Map.Entry<Integer, Long> entry : this.delayLevelTable.entrySet()) {
        
                    Integer level = entry.getKey();
                    Long timeDelay = entry.getValue();
                    //根据延迟级别level 从offsetTable中获取消费队列的消费进度
                    //也就是说每一个延迟级别对应一个消息消费队列。
                    //延迟级别与消息消费队列的映射关系为：消息队列ID ＝延迟级别-l 。
                    Long offset = this.offsetTable.get(level);
                    //如果不存在， 则使用0
                    if (null == offset) {
        
                        offset = 0L;
                    }
    
                    if (timeDelay != null) {
        
                        //创建定时任务，每一个定时任务第一次启动时默认延迟ls 先执行一次定时任务，第二次调度开始才使用相应的延迟时间
                        this.timer.schedule(new DeliverDelayedMessageTimerTask(level, offset), FIRST_DELAY_TIME);
                    }
                }
                //创建定时任务，每隔10s 持久化一次延迟队列的消息消费进度（延迟消息调进度）
                //持久化频率可以通过flushDelayOffsetlnterval配置属性进行设置。
                this.timer.scheduleAtFixedRate(new TimerTask() {
        
    
                    @Override
                    public void run() {
        
                        try {
        
                            if (started.get()) ScheduleMessageService.this.persist();
                        } catch (Throwable e) {
        
                            log.error("scheduleAtFixedRate flush exception", e);
                        }
                    }
                }, 10000, this.defaultMessageStore.getMessageStoreConfig().getFlushDelayOffsetInterval());
            }
        }

**ScheduleMessageService.DeliverDelayedMessageTimerTask**

public void run() {
        
                try {
        
                    if (isStarted()) {
        //延迟执行
                        this.executeOnTimeup();
                    }
                } catch (Exception e) {
        
                    // XXX: warn and notify me
                    log.error("ScheduleMessageService, executeOnTimeup exception", e);
                    ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(
                        this.delayLevel, this.offset), DELAY_FOR_A_PERIOD);
                }
            }

消息存储时如果消息的延迟级别属性delay Level 大于0 ，则会各份原主题、原队列到消息属性中，其键分别为PROPERTY . REAL TOPIC 、PROPERTY\_ REAL\_ QUEUE\_ ID ， 通过为不同的延迟级别创建不同的调度任务， 当时间到达后执行调度任务， 调度任务主要就是根据延迟拉取消息消费进度从延迟队列中拉取消息，然后从comm itl og 中加载完整消息，清除延迟级别属性并恢复原先的主题、队列，再次创建一条新的消息存入到commitlog 中并转发到消息消费队列供消息消费者消费。

public void executeOnTimeup() {
        
                //根据队列ID 与延迟主题查找消息消费队列
                ConsumeQueue cq =
                    ScheduleMessageService.this.defaultMessageStore.findConsumeQueue(TopicValidator.RMQ_SYS_SCHEDULE_TOPIC,
                        delayLevel2QueueId(delayLevel));
    
                long failScheduleOffset = offset;
    
                if (cq != null) {
        
                    //根据offset 从消息消费队列中获取当前队列中所有有效的消息
                    SelectMappedBufferResult bufferCQ = cq.getIndexBuffer(this.offset);
                    if (bufferCQ != null) {
        
                        try {
        
                            long nextOffset = offset;
                            int i = 0;
                            ConsumeQueueExt.CqExtUnit cqExtUnit = new ConsumeQueueExt.CqExtUnit();
                            //遍历ConsumeQueue
                            for (; i < bufferCQ.getSize(); i += ConsumeQueue.CQ_STORE_UNIT_SIZE) {
        
                                //解析每个消息信息
                                long offsetPy = bufferCQ.getByteBuffer().getLong();
                                int sizePy = bufferCQ.getByteBuffer().getInt();
                                long tagsCode = bufferCQ.getByteBuffer().getLong();
    
                                if (cq.isExtAddr(tagsCode)) {
        
                                    if (cq.getExt(tagsCode, cqExtUnit)) {
        
                                        tagsCode = cqExtUnit.getTagsCode();
                                    } else {
        
                                        //can't find ext content.So re compute tags code.
                                        log.error("[BUG] can't find consume queue extend file content!addr={}, offsetPy={}, sizePy={}",
                                            tagsCode, offsetPy, sizePy);
                                        long msgStoreTime = defaultMessageStore.getCommitLog().pickupStoreTimestamp(offsetPy, sizePy);
                                        tagsCode = computeDeliverTimestamp(delayLevel, msgStoreTime);
                                    }
                                }
    
                                long now = System.currentTimeMillis();
                                long deliverTimestamp = this.correctDeliverTimestamp(now, tagsCode);
    
                                nextOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);
    
                                long countdown = deliverTimestamp - now;
    
                                if (countdown <= 0) {
        
                                    //根据消息物理偏移量与消息大小从commitlog 文件中查找消息
                                    MessageExt msgExt =
                                        ScheduleMessageService.this.defaultMessageStore.lookMessageByOffset(
                                            offsetPy, sizePy);
    
                                    if (msgExt != null) {
        
                                        try {
        
                                            //解析属性
                                            MessageExtBrokerInner msgInner = this.messageTimeup(msgExt);
                                            if (TopicValidator.RMQ_SYS_TRANS_HALF_TOPIC.equals(msgInner.getTopic())) {
        
                                                log.error("[BUG] the real topic of schedule msg is {}, discard the msg. msg={}",
                                                        msgInner.getTopic(), msgInner);
                                                continue;
                                            }
                                            //将消息再次存入到commitlog ，并转发到主题对应的消息队列上，供消费者再次消费。
                                            PutMessageResult putMessageResult =
                                                ScheduleMessageService.this.writeMessageStore
                                                    .putMessage(msgInner);
    
                                            if (putMessageResult != null
                                                && putMessageResult.getPutMessageStatus() == PutMessageStatus.PUT_OK) {
        
                                                continue;
                                            } else {
        
                                                // XXX: warn and notify me
                                                log.error(
                                                    "ScheduleMessageService, a message time up, but reput it failed, topic: {} msgId {}",
                                                    msgExt.getTopic(), msgExt.getMsgId());
                                                ScheduleMessageService.this.timer.schedule(
                                                    new DeliverDelayedMessageTimerTask(this.delayLevel,
                                                        nextOffset), DELAY_FOR_A_PERIOD);
                                                ScheduleMessageService.this.updateOffset(this.delayLevel,
                                                    nextOffset);
                                                return;
                                            }
                                        } catch (Exception e) {
        
                                            /*
                                             * XXX: warn and notify me
    
    
    
                                             */
                                            log.error(
                                                "ScheduleMessageService, messageTimeup execute error, drop it. msgExt="
                                                    + msgExt + ", nextOffset=" + nextOffset + ",offsetPy="
                                                    + offsetPy + ",sizePy=" + sizePy, e);
                                        }
                                    }
                                } else {
        
                                    ScheduleMessageService.this.timer.schedule(
                                        new DeliverDelayedMessageTimerTask(this.delayLevel, nextOffset),
                                        countdown);
                                    ScheduleMessageService.this.updateOffset(this.delayLevel, nextOffset);
                                    return;
                                }
                            } // end of for
    
                            nextOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);
                            ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(
                                this.delayLevel, nextOffset), DELAY_FOR_A_WHILE);
                            //更新延迟队列拉取进度。
                            ScheduleMessageService.this.updateOffset(this.delayLevel, nextOffset);
                            return;
                        } finally {
        
    
                            bufferCQ.release();
                        }
                    } // end of if (bufferCQ != null)
                    else {
        
                        long cqMinOffset = cq.getMinOffsetInQueue();
                        if (offset < cqMinOffset) {
        
                            //更新一下延迟队列定时拉取进度,为队列最小偏移
                            failScheduleOffset = cqMinOffset;
                            log.error("schedule CQ offset invalid. offset=" + offset + ", cqMinOffset="
                                + cqMinOffset + ", queueId=" + cq.getQueueId());
                        }
                    }
                } // end of if (cq != null)
    
                //根据延时级别创建下一次调度任务
                ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(this.delayLevel,
                    failScheduleOffset), DELAY_FOR_A_WHILE);
            }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/22fc64d5f21f4afeb65668b67aa86671.png
[20200904085456440.png_pic_center]: /images/20221123/3cfc6582a1c74d65805929bd8e0376b3.png
[20200904104251304.png_pic_center]: /images/20221123/f5a6faf2d9b94edd89ea990619a28488.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/6c563b9559a447d4a02fa8997ec8a83d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/a3d24baf644e45cba582dead4b351c9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/23f6c2c630f14e8690921e36fc823c45.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/c77ad0f4691449269fcba1b886625354.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/00b4476372914913bc7f34992d09842f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/e60c49ef1da24f63adbb5a4e6d30bf28.png
[20200906190101535.png_pic_center]: /images/20221123/6c7349ef1cb5468ca1ddf2705aedf53a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/29b3a98d4d5a43f9bc2f3ac8efa5bd3e.png
[20200908104814432.png_pic_center]: /images/20221123/2906aaef07ca4638806a880c37d830cf.png
[20200908104840150.png_pic_center]: /images/20221123/68f8ac34dda94001a5ddc35c0aa0f671.png
[20200908110352953.png_pic_center]: /images/20221123/fd656570a819423586f53b79c1f9fd9d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/50132b2cc18c4103bdcddb858c649088.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/00c5a15c6f2a453d8538896e1d40df3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221123/bc7608b607ab469d9349e681efd5f8ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221123/fc8fb55a9dc0410fa45dc7829f737a40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221123/3086c31d31324419905ee4fefab16238.png
[20200905220518765.png_pic_center]: /images/20221123/1caa4b41056a40e39b39c77f5ea5fea1.png
[20200908124925785.png_pic_center]: /images/20221123/8abc510eb9564d88812e18aed92ad1d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221123/f6664d09655643db984f1d8d01af3b61.png