RocketMQ源碼解析Broker#消息存儲ConsumeQueue

1.首先介紹下RocketMq消息存儲的目錄結構

Broker在收到消息後，通過MessageStore將消息存儲到commitLog中，但是consumer在消費消息的時候是按照topic+queue的維度來拉取消息的。爲了方便讀取，MessageStore將CommitLog中消息的offset按照topic+queueId劃分後，存儲到不同的文件中，這就是ConsumeQueue

文件組織方式

回顧一下數據結構圖中ConsumeQueue相關的部分。

上圖是：/home/rocketmq/store/audi_slave/config配置下的consumerOffset.json 數據格式，這個文件描述的是topic與消費者的關係，每一個隊列對應的消費進度。但是消費是實時更新的，所以必須實時更新消費進度，消費進度的更新是從消息的拉取得到的。

 

ConsumeQueue存儲結構

底層儲存跟CommitLog一樣使用MappedFile，每個CQUnit的大小是固定的，存儲了消息的offset、消息size和tagCode。存tag是爲了在consumer取到消息offset後時候先根據tag做一次過濾，剩下的才需要到CommitLog中取消息詳情。
之前講過，MessageStore通過ReputMessageService來將消息的offset寫道ConsumeQueue中，我們看下這部分代碼實現

 

ReputMessageService

這個Service是一個單線程的任務，一直循環的調用doReput()方法：

        private boolean isCommitLogAvailable() {
            return this.reputFromOffset < DefaultMessageStore.this.commitLog.getMaxOffset();
        }

        private void doReput() {
            //1、判斷commitLog的maxOffset是否比上次讀取的offset大
            for (boolean doNext = true; this.isCommitLogAvailable() && doNext; ) {
                if (DefaultMessageStore.this.getMessageStoreConfig().isDuplicationEnable()
                    && this.reputFromOffset >= DefaultMessageStore.this.getConfirmOffset()) {
                    break;
                }
                //2、從上次的結束offset開始讀取commitLog文件中的消息
                SelectMappedBufferResult result = DefaultMessageStore.this.commitLog.getData(reputFromOffset);
                if (result != null) {
                    try {
                        this.reputFromOffset = result.getStartOffset();

                        for (int readSize = 0; readSize < result.getSize() && doNext; ) {
                            //3、檢查message數據完整性並封裝成DispatchRequest
                            DispatchRequest dispatchRequest =
                                DefaultMessageStore.this.commitLog.checkMessageAndReturnSize(result.getByteBuffer(), false, false);
                            int size = dispatchRequest.getMsgSize();

                            if (dispatchRequest.isSuccess()) {
                                if (size > 0) {
                                    //4、分發消息到CommitLogDispatcher，1)構建索引; 2)更新consumeQueue
                                    DefaultMessageStore.this.doDispatch(dispatchRequest);
                                    //5、分發消息到MessageArrivingListener,喚醒等待的PullReqeust接收消息,Only Master?
                                    if (BrokerRole.SLAVE != DefaultMessageStore.this.getMessageStoreConfig().getBrokerRole()
                                        && DefaultMessageStore.this.brokerConfig.isLongPollingEnable()) {
                                        DefaultMessageStore.this.messageArrivingListener.arriving(dispatchRequest.getTopic(),
                                            dispatchRequest.getQueueId(), dispatchRequest.getConsumeQueueOffset() + 1,
                                            dispatchRequest.getTagsCode(), dispatchRequest.getStoreTimestamp(),
                                            dispatchRequest.getBitMap(), dispatchRequest.getPropertiesMap());
                                    }
                                    //5、更新offset
                                    this.reputFromOffset += size;
                                    readSize += size;
                                    if (DefaultMessageStore.this.getMessageStoreConfig().getBrokerRole() == BrokerRole.SLAVE) {
                                        DefaultMessageStore.this.storeStatsService
                                            .getSinglePutMessageTopicTimesTotal(dispatchRequest.getTopic()).incrementAndGet();
                                        DefaultMessageStore.this.storeStatsService
                                            .getSinglePutMessageTopicSizeTotal(dispatchRequest.getTopic())
                                            .addAndGet(dispatchRequest.getMsgSize());
                                    }
                                } else if (size == 0) {
                                    //6、如果讀到文件結尾，則切換到新文件
                                    this.reputFromOffset = DefaultMessageStore.this.commitLog.rollNextFile(this.reputFromOffset);
                                    readSize = result.getSize();
                                }
                            } else if (!dispatchRequest.isSuccess()) {
                                //7、解析消息出錯，跳過。commitLog文件中消息數據損壞的情況下才會進來
                                if (size > 0) {
                                    log.error("[BUG]read total count not equals msg total size. reputFromOffset={}", reputFromOffset);
                                    this.reputFromOffset += size;
                                } else {
                                    doNext = false;
                                    if (DefaultMessageStore.this.brokerConfig.getBrokerId() == MixAll.MASTER_ID) {
                                        log.error("[BUG]the master dispatch message to consume queue error, COMMITLOG OFFSET: {}",
                                            this.reputFromOffset);

                                        this.reputFromOffset += result.getSize() - readSize;
                                    }
                                }
                            }
                        }
                    } finally {
                        //8、release對MappedFile的引用
                        result.release();
                    }
                } else {
                    doNext = false;
                }
            }
        }
    /**
     * 消息分發
     */
    public void doDispatch(DispatchRequest req) {
        for (CommitLogDispatcher dispatcher : this.dispatcherList) {
            dispatcher.dispatch(req);
        }
    }

• 第1步，每次處理完讀取消息後，都將當前已經處理的最大offset記錄下來，下次處理從這個offset開始讀取消息
• 第2步，從commitLog文件中讀取消息詳情
• 第4步，分發讀取到的消息，MessageStore在初始化的時候會往dispatcherList中添加兩個Dispatcher.

this.dispatcherList = new LinkedList<>();
//consumeQueue構建Dispatcher
this.dispatcherList.addLast(new CommitLogDispatcherBuildConsumeQueue());
//索引更新Dispatcher
this.dispatcherList.addLast(new CommitLogDispatcherBuildIndex());

具體Dispatcher的處理邏輯，我們下面詳細說

• 第8步，在通過commitLog讀取消息時，不會把消息數據複製到堆內存中，只是返回文件映射的byteBuffer，所以MappedFile記錄了有多少個引用，在數據使用完後需要釋放。

Dispatcher構建ConsumeQueue

CommitLogDispatcherBuildConsumeQueue實現比較簡單，直接調用的MessageStore的接口

class CommitLogDispatcherBuildConsumeQueue implements CommitLogDispatcher {

        @Override
        public void dispatch(DispatchRequest request) {
            final int tranType = MessageSysFlag.getTransactionValue(request.getSysFlag());
            switch (tranType) {
                /** 對於非事務消息和commit事務消息 */
                case MessageSysFlag.TRANSACTION_NOT_TYPE:
                case MessageSysFlag.TRANSACTION_COMMIT_TYPE:
                    DefaultMessageStore.this.putMessagePositionInfo(request);
                    break;
                case MessageSysFlag.TRANSACTION_PREPARED_TYPE:
                case MessageSysFlag.TRANSACTION_ROLLBACK_TYPE:
                    break;
            }
        }
    }

MessageStore中的實現：

    public void putMessagePositionInfo(DispatchRequest dispatchRequest) {
        //找到對應的ComsumeQueue文件
        ConsumeQueue cq = this.findConsumeQueue(dispatchRequest.getTopic(), dispatchRequest.getQueueId());
        cq.putMessagePositionInfoWrapper(dispatchRequest);
    }

前面已經講過consumeQueue的數據存儲結構，每個topic+queueId對應一個ConsumeQueue，每個ConsumeQueue包含一系列MappedFile。所以，這裏第一步就是獲取對應的ConsumeQueue，如果不存在的話就會新建一個。後面就是調用CQ的put方法：

public void putMessagePositionInfoWrapper(DispatchRequest request) {
        //1、寫入重試次數，最多30次
        final int maxRetries = 30; 
        //2、判斷CQ是否是可寫的
        boolean canWrite = this.defaultMessageStore.getRunningFlags().isCQWriteable();
        for (int i = 0; i < maxRetries && canWrite; i++) {
            long tagsCode = request.getTagsCode();
            if (isExtWriteEnable()) {
                //3、如果需要寫ext文件，則將消息的tagscode寫入
                ConsumeQueueExt.CqExtUnit cqExtUnit = new ConsumeQueueExt.CqExtUnit();
                cqExtUnit.setFilterBitMap(request.getBitMap());
                cqExtUnit.setMsgStoreTime(request.getStoreTimestamp());
                cqExtUnit.setTagsCode(request.getTagsCode());

                long extAddr = this.consumeQueueExt.put(cqExtUnit);
                if (isExtAddr(extAddr)) {
                    tagsCode = extAddr;
                } else {
                    log.warn("Save consume queue extend fail, So just save tagsCode! {}, topic:{}, queueId:{}, offset:{}", cqExtUnit,
                        topic, queueId, request.getCommitLogOffset());
                }
            }
            //4、寫入文件
            boolean result = this.putMessagePositionInfo(request.getCommitLogOffset(),
                request.getMsgSize(), tagsCode, request.getConsumeQueueOffset());
            if (result) {
                //5、記錄check point
                this.defaultMessageStore.getStoreCheckpoint().setLogicsMsgTimestamp(request.getStoreTimestamp());
                return;
            } else {
                ...
                ...
            }
        }

       ...
        this.defaultMessageStore.getRunningFlags().makeLogicsQueueError();
    }

• 第3步，將tagcode和bitMap記錄進CQExt文件中，這個是一個過濾的擴展功能，採用的bloom過濾器先記錄消息的bitMap，這樣consumer來讀取消息時先通過bloom過濾器判斷是否有符合過濾條件的消息
• 第4步，將消息offset寫入CQ文件中，這邊代碼如下：

private boolean putMessagePositionInfo(final long offset, final int size, final long tagsCode,
        final long cqOffset) {

        if (offset <= this.maxPhysicOffset) {
            return true;
        }
        //一個CQUnit的大小是固定的20字節
        this.byteBufferIndex.flip();
        this.byteBufferIndex.limit(CQ_STORE_UNIT_SIZE);
        this.byteBufferIndex.putLong(offset);
        this.byteBufferIndex.putInt(size);
        this.byteBufferIndex.putLong(tagsCode);

        final long expectLogicOffset = cqOffset * CQ_STORE_UNIT_SIZE;
        //獲取最後一個MappedFile
        MappedFile mappedFile = this.mappedFileQueue.getLastMappedFile(expectLogicOffset);
        if (mappedFile != null) {
            //對新創建的文件，寫將所有CQUnit初始化0值
            if (mappedFile.isFirstCreateInQueue() && cqOffset != 0 && mappedFile.getWrotePosition() == 0) {
                this.minLogicOffset = expectLogicOffset;
                this.mappedFileQueue.setFlushedWhere(expectLogicOffset);
                this.mappedFileQueue.setCommittedWhere(expectLogicOffset);
                this.fillPreBlank(mappedFile, expectLogicOffset);
                log.info("fill pre blank space " + mappedFile.getFileName() + " " + expectLogicOffset + " "
                    + mappedFile.getWrotePosition());
            }

            if (cqOffset != 0) {
                long currentLogicOffset = mappedFile.getWrotePosition() + mappedFile.getFileFromOffset();

                if (expectLogicOffset < currentLogicOffset) {
                    log.warn("Build  consume queue repeatedly, expectLogicOffset: {} currentLogicOffset: {} Topic: {} QID: {} Diff: {}",
                        expectLogicOffset, currentLogicOffset, this.topic, this.queueId, expectLogicOffset - currentLogicOffset);
                    return true;
                }

                if (expectLogicOffset != currentLogicOffset) {
                    LOG_ERROR.warn(
                        "[BUG]logic queue order maybe wrong, expectLogicOffset: {} currentLogicOffset: {} Topic: {} QID: {} Diff: {}",
                        expectLogicOffset,
                        currentLogicOffset,
                        this.topic,
                        this.queueId,
                        expectLogicOffset - currentLogicOffset
                    );
                }
            }
            this.maxPhysicOffset = offset;
            //CQUnit寫入文件中
            return mappedFile.appendMessage(this.byteBufferIndex.array());
        }
        return false;
    }

寫文件的邏輯和寫CommitLog的邏輯是一樣的，首先封裝一個CQUnit，這裏面offset佔8個字節，消息size佔用4個字節，tagcode佔用8個字節。然後找最後一個MappedFile，對於新建的文件，會有一個預熱的動作，寫把所有CQUnit初始化成0值。最後將Unit寫入到文件中。

總結

ConsumeQueue文件數據生成的整個步驟就講到這裏了。Consumer來讀取文件的時候，只要指定要讀的topic和queueId，以及開始offset。因爲每個CQUnit的大小是固定的，所以很容易就可以在文件中定位到。找到開始的位置後，只需要連續讀取後面指定數量的Unit，然後根據Unit中存的CommitLog的offset就可以到CommitLog中讀取消息詳情了