rocketmq--push消费过程

Rocketmq消费分为push和pull两种方式，push为被动消费类型，pull为主动消费类型，push方式最终还是会从broker中pull消息。不同于pull的是，push首先要注册消费监听器，当监听器处触发后才开始消费消息，所以被称为“被动”消费。

 

 具体地，以pushConsumer的测试例子展开介绍，通常使用push消费的过程如下：

public class PushConsumer {

    public static void main(String[] args) throws InterruptedException, MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("CID_JODIE_1");
        consumer.subscribe("Jodie_topic_1023", "*");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        //wrong time format 2017_0422_221800
        consumer.setConsumeTimestamp("20170422221800");
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                System.out.printf(Thread.currentThread().getName() + " Receive New Messages: " + msgs + "%n");
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        consumer.start();
        System.out.printf("Consumer Started.%n");
    }
}

 

上述过程背后设计到的点如下： 

 

I. checkConfig 检查内容：

1.消费组 -- （不能与默认DEFAULT_CONSUMER同名）

2.消费模型 -- （默认CLUSTERING）

3.从何处开始消费 -- （默认CONSUME_FROM_LAST_OFFSET）

4.消费时间戳 -- （消息回溯，默认Default backtracking consumption time Half an hour ago）

5.消费负载均衡策略 -- （默认AllocateMessageQueueAveragely）

6.订阅关系 --（map类型，即可订阅多个topic；key=Topic, value=订阅描述）

7.消费监听 --（必须为orderly or concurrently类型之一）

8.消费消息的线程数量控制 -- （消费线程池最大、最小数量）

9.检查单队列并行消费允许的最大跨度 --（consumeConcurrentlyMaxSpan）

10.检查拉消息本地队列缓存消息最大数 --（pullThresholdForQueue）（processQueue.getMsgCount()记数）

11.检查拉取时间间隔 --（拉消息间隔，由于是长轮询，所以默认为0）

12.检查批量消费的个数 --（一次消费多少条消息）

13.检查批量拉取消息的个数 --（一次最多拉多少条）

 

II. copySubscription：

将订阅信息设置到rebalanceImpl的map中用于负载。另外，如果该消费者的消费模式为集群消费，则会将retry的topic一并放到rebalanceImpl的map中用于负载。

 

III. 设置rebanlance信息

IV. 实例化pull消息的包装类型

 

V. 如果不存在offsetStore对象，实例化offsetStore

广播模式：

public class LocalFileOffsetStore implements OffsetStore {...}

注：load()函数体不为空

集群模式：

public class RemoteBrokerOffsetStore implements OffsetStore {...}

注：load()函数体为空

 

VI. 获取监听器，实例化consumeMessageService服务并启动

ConsumeMessageOrderlyService启动后会对拉取下来的消息进行处理。ConsumeMessageOrderlyService有两种类型：ConsumeMessageOrderlyService和ConsumeMessageConcurrentlyService。

1). 如果消息监听器是orderly类型，则创建ConsumeMessageOrderlyService实例

ConsumeMessageOrderlyService.start()只处理消息模式为CLUSTERING的消息消费。

public void start() {
        if (MessageModel.CLUSTERING.equals(ConsumeMessageOrderlyService.this.defaultMQPushConsumerImpl
            .messageModel())) {
            this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    ConsumeMessageOrderlyService.this.lockMQPeriodically();
                }
            }, 1000 * 1, ProcessQueue.RebalanceLockInterval, TimeUnit.MILLISECONDS);
        }
    }

线程启动后会每隔20s执行lockMQPeriodicallys()，lockMQPeriodicallys()会将消费的队列上锁，然后处理，具体过程，有机会单独成文分析。

 

2). 如果消息监听器是concurrently类型，则创建ConsumeMessageConcurrentlyService实例

ConsumeMessageConcurrentlyService.start()会定时清除过期消息 --> cleanExpireMsg()。

 

VII. 注册消费组

将group和consumer注册到MQClientInstance实例。

与生产者注册生产者组类似，一个客户端进程中一个consumerGroup只能有一个实例。

MQConsumerInner prev = this.consumerTable.putIfAbsent(group, consumer);
if (prev != null) {
    log.warn("the consumer group[" + group + "] exist already.");
    return false;
}

如果没有注册成功，则关闭消费服务，consumeMessageService.shutdown()。

 

VIII. 启动mQClientFactory及MQClientInstance

1). 获取client实例对象MQClientInstance -- getAndCreateMQClientInstance。一个进程只能产生一个MQClientInstance实例对象, 某个客户端的生产者与消费者共用这个实例对象。

2). 启动客户端实例的个各种服务：

public void start() throws MQClientException {
        synchronized (this) {
            switch (this.serviceState) {
                case CREATE_JUST:
                    this.serviceState = ServiceState.START_FAILED;
                    // 1.判断NamesrvAddr是否为空，为空去远程http服务拉去地址
                    if (null == this.clientConfig.getNamesrvAddr()) {
                        this.clientConfig.setNamesrvAddr(this.mQClientAPIImpl.fetchNameServerAddr());
                    }
                    // 2.开启通信服务
                    this.mQClientAPIImpl.start();
                    // 3.启动各种定时任务
                    this.startScheduledTask();
                    // 4.启动消息拉取服务，循环拉取阻塞队列pullRequestQueue
                    this.pullMessageService.start();
                    // 5. 启动负载均衡服务
                    this.rebalanceService.start();
                    // 6.启动消息生产服务
                    this.defaultMQProducer.getDefaultMQProducerImpl().start(false);
                    log.info("the client factory [{}] start OK", this.clientId);
                    this.serviceState = ServiceState.RUNNING;
                    break;
                case RUNNING:
                    break;
                case SHUTDOWN_ALREADY:
                    break;
                case START_FAILED:
                    throw new MQClientException("The Factory object[" + this.getClientId()
                            + "] has been created before, and failed.", null);
                default:
                    break;
            }
        }
    }

分析push消费的过程，需对上述过程第3点、第4点、第5点依次介绍。

第3点、启动各种定时任务过程：

编号	任务	周期	启动时延
1	获取namesrv地址	每隔2分钟	0.01s
2	更新路由信息	每隔3分钟	001s
3	向所有broker发送心跳包，并清除无效broker	每隔30s	1s
4	持久化消费位置offset	每隔5s	10s
5	调整消费线程池大小	每隔1分钟	1min

注：编号3中，客户端会通过心跳消息，向broker注册消费信息。Broker收到该心跳消息，把它维护在一个叫做ConsumerManager的对象里面，为之后做消费的负载均衡提供数据，负载均衡在消费端做，消费端在负载均衡时首先要从broker那获取这份全局信息。

 

第4点 启动pullMessageService服务

初始化客户端实例时，创建PullMessageService服务对象。

this.pullMessageService = new PullMessageService(this)，其中PullMessageService继承于ServiceThread，是一个线程对象。启动消息拉取服务线程后，在线程没有阻塞的情况下会不断地从循环阻塞队列pullRequestQueue拉取PullRequest对象，然后执行this.pullMessage(pullRequest)。

 

那么pullRequestQueue的数据如何put进去的?核心是doRebalance ，负载均衡具体细节可以参考：http://www.cnblogs.com/chenjunjie12321/p/7913323.html。

例如当前有N个客户端同时消费一个topic下的消息队列（如上图），当前客户端( clientId = currentCId)，经过负载均衡处理后得到分配给当前消费者的消息队列（如上图的qM、qN），之后将这些队列与processQueueTable中的队列进行比对分析，见下面第五点。

 

第5点 RebalancePushImpl 负载均衡，分发pullRequest到pullRequestQueue。

负载均衡处理后得到分配给当前消费者的消息队列，然后将这些队列进行updateProcessQueueTableInRebalance 处理。updateProcessQueueTableInRebalance 的大致逻辑为如下 I、II 两步：

 

 

I. 首先检查当前RebalancePushImpl实例processQueueTable中与mqSet的包含关系

（1）如图中processQueueTable的灰色部分，表示与mqSet集合不互不包含的队列，对这些队列首先设置Dropped为true，然后看这些队列是否可以移除出processQueueTable--removeUnnecessaryMessageQueue，即每隔1s 看是否可以拿到当前队列的消费锁（tryLock()），拿到后返回true, 如果等待1s后仍然拿不到当前队列的消费锁则返回false，如果返回true则从processQueueTable移除对应的Entry<MessageQueue, ProcessQueue>；

 

（2） 如图中processQueueTable的白色部分，表示与mqSet集合的交集队列，对于这些队列，如果是消费类型是pull型，则不用管，如果是push型，看这些队列是否isPullExpired，如果是这些队列首先设置Dropped为true，则可以移除出processQueueTable--removeUnnecessaryMessageQueue。

 

II. 经过 I 处理，processQueueTable更新之后， 将processQueueTable集合与mqSet的的相对补集: processQueueTable(mq) - mqSet 里的消息队列依次封装成pullRequest，然后dispatchPullRequest到pullRequestQueue中。

 

经过上述处理后，待消费的队列放在了pullRequestList中，之后遍历pullRequestList，对遍历的每个队列进行消费，代码如下：

 @Override
    public void dispatchPullRequest(List<PullRequest> pullRequestList) {
        for (PullRequest pullRequest : pullRequestList) {
            this.defaultMQPushConsumerImpl.executePullRequestImmediately(pullRequest);
            log.info("doRebalance, {}, add a new pull request {}", consumerGroup, pullRequest);
        }
    }

executePullRequestImmediately的逻辑功能：

 public void executePullRequestImmediately(final PullRequest pullRequest) {
        try {
            this.pullRequestQueue.put(pullRequest);
        } catch (InterruptedException e) {
            log.error("executePullRequestImmediately pullRequestQueue.put", e);
        }
    }

总之，最终会将负载均衡得到的队列存放到pullRequestQueue。

 

回过来继续分析第4点，pullMessageService线程涉及到消费的核心过程DefaultMQPushConsumerImpl.pullMessage，pullMessageService线程线程体源码如下：

 @Override
    public void run() {
        log.info(this.getServiceName() + " service started");

        while (!this.isStopped()) {
            try {
                PullRequest pullRequest = this.pullRequestQueue.take();
                if (pullRequest != null) {
                    this.pullMessage(pullRequest);
                }
            } catch (InterruptedException e) {
            } catch (Exception e) {
                log.error("Pull Message Service Run Method exception", e);
            }
        }

        log.info(this.getServiceName() + " service end");
    }

调用DefaultMQPushConsumerImpl.pullMessage方法：

 private void pullMessage(final PullRequest pullRequest) {
        final MQConsumerInner consumer = this.mQClientFactory.selectConsumer(pullRequest.getConsumerGroup());
        if (consumer != null) {
            DefaultMQPushConsumerImpl impl = (DefaultMQPushConsumerImpl) consumer;
            impl.pullMessage(pullRequest);
        } else {
            log.warn("No matched consumer for the PullRequest {}, drop it", pullRequest);
        } 

pullMessage具体体拉流程如下图所示：

 

 

下面对并发消费模型（concurrently）的消费代码进行展示：

class ConsumeRequest implements Runnable ，其线程体方法如下：

@Override
        public void run() {
            if (this.processQueue.isDropped()) {
                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;

            ConsumeMessageContext consumeMessageContext = null;
            if (ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.hasHook()) {
                consumeMessageContext = new ConsumeMessageContext();
                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 {
                ConsumeMessageConcurrentlyService.this.resetRetryTopic(msgs);
                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);

            if (!processQueue.isDropped()) {
                ConsumeMessageConcurrentlyService.this.processConsumeResult(status, context, this);
            } else {
                log.warn("processQueue is dropped without process consume result. messageQueue={}, msgs={}", messageQueue, msgs);
            }
        }

consumerRequest逻辑：

 

processConsumeResult -- 对消费结果进行处理：

 重试队列发消息逻辑：

生成一个重试队列，重试队列topic =  %RETRY% + consumerGroup的形式。

 

 

 附：

值得注意的是每次消费pullRequest上的一条数据后上更新消费到达的 offset，然后将pullRequest.setNextOffset(offset);

//这里的 this 为一个 DefaultMQPushConsumerImpl 实例对象
final long offset = this.rebalanceImpl.computePullFromWhere(pullRequest.getMessageQueue());
...
pullRequest.setNextOffset(offset);

其中 computePullFromWhere采用的策略有如下三种（另外还有几个已经被弃用的（@Deprecated））：

CONSUME_FROM_LAST_OFFSET（默认）： 一个新的消费集群第一次启动从队列的最后位置开始消费。后续再启动接着上次消费的进度开始消费。
CONSUME_FROM_FIRST_OFFSET： 一个新的消费集群第一次启动从队列的最前位置开始消费。后续再启动接着上次消费的进度开始消费。
CONSUME_FROM_TIMESTAMP： 一个新的消费集群第一次启动从指定时间点开始消费。后续再启动接着上次消费的进度开始消费。

DefaultMQPushConsumer 中默认采用 CONSUME_FROM_LAST_OFFSET 这种方式，当然可以根据自己需要修改computePullFromWhere的策略

private ConsumeFromWhere consumeFromWhere = ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET;

IX. updateTopicSubscribeInfoWhenSubscriptionChanged

X. sendHeartbeatToAllBrokerWithLock

XI. rebalanceImmediately

 

（完）