Skip to content

5.3-2 RocketMQ 存储:CommitLog、ConsumeQueue、IndexFile ​

所属:05 消息中间件 / 5.3 RocketMQ 分级:A 状态:◐ 初稿 关联:5.1-1、5.1-4、5.3-1、5.3-3、5.3-4、5.3-6、5.3-8、5.4-2

  • 题型:原理 / 源码 / 调优

  • 一句话结论:RocketMQ 用**“一份顺序写的 CommitLog + 两份轻量索引”解决“高吞吐写 + 按队列消费 + 按 key 查询”三个矛盾:所有 Topic 的消息都追加到同一个 CommitLog(1GB 一个文件,纯顺序 IO),后台异步构建 ConsumeQueue(每队列 20 字节目录项:CommitLog offset + size + tag hash) 和 IndexFile(按 key 的哈希索引)。写放大最小、写吞吐高,代价是消费时一次索引读 + 一次 CommitLog 随机读**,依赖 PageCache;消息可靠性取决于刷盘与主从复制,不是“写进 mmap 就安全”。

  • 分层要点:

    1. 目录结构:${storePathRootDir}/commitlog/ 下是 1GB 一个的 CommitLog 文件;consumequeue/<topic>/<queueId>/ 下是 30 万条一个的索引文件(每条 20 字节,约 5.72MB);index/ 下是 IndexFile(默认 500 万条一个,约 120MB)。另外还有 abort(异常退出标记)、checkpoint(刷盘点)、config/(Topic/消费位点等)。
    2. CommitLog 是唯一的“真数据”:所有 Topic、所有队列的消息混写在一个顺序日志里,只追加、不修改;单条记录包含消息体、Topic、属性、队列 ID、队列内偏移、物理偏移、生成时间、host、重试次数等。1GB 文件写满后滚到下一个,顺序写是 RocketMQ 高吞吐的根基。
    3. ConsumeQueue 是“按队列的目录”:每个 Topic 的每个队列一个目录,每条索引 20 字节——8 字节 CommitLog 物理偏移 + 4 字节消息大小 + 8 字节 tag 哈希。消费者按队列顺序读它,拿到物理偏移再去 CommitLog 读消息体。它不存消息,只存“去哪找”,所以极小。
    4. IndexFile 是“按 key 的索引”:以消息的 KEYS(未设置时通常用 UNIQ_KEY 兜底)做哈希,落到 500 万个槽位,槽位后挂链表,每个索引项 20 字节(keyHash、物理偏移、时间差、下一条)。用于按 key 查消息、排查问题;没设 KEYS 的消息按业务 key 查不到。
    5. 写入路径:Producer 消息到达 → DefaultMessageStore.putMessage 加锁(putMessageLock)→ 追加到 CommitLog 的 mmap(PageCache)→ 按 flushDiskType 决定同步/异步刷盘 → 返回 SendResult;同时 ReputMessageService 异步把新消息“分发”成 ConsumeQueue 与 IndexFile。索引构建是异步的,所以刚写入的消息可能瞬间查不到索引。
    6. 刷盘与复制决定“什么时候算安全”:异步刷盘只写 PageCache,靠内核回刷(默认 500ms 触发),宕机可能丢最后一段;同步刷盘用 GroupCommitService 批量 fsync 后才返回;主从复制有 ASYNC_MASTER / SYNC_MASTER。SEND_OK 只代表“按当前配置成功”,不等于一定落盘/有副本(5.1-1)。
    7. 读取路径:消费时先读 ConsumeQueue(mmap,顺序)拿到物理偏移,再读 CommitLog(mmap,可能随机)取消息体;tag 过滤先用 ConsumeQueue 里的 tag hash 快速跳过,hash 命中后再校验真实 tag。按 msgId 查可直接解析出 Broker 地址 + 物理偏移;按 key 查走 IndexFile;按时间查对 ConsumeQueue 二分。
    8. 清理、恢复与保护:消息默认保留 72 小时(fileReservedTime),每天固定时间(默认 04:00)删除过期文件;磁盘使用率超过阈值会触发清理、强制清理,再高进入只读拒绝写入。异常退出会留下 abort 文件,重启时据此重建 ConsumeQueue/IndexFile;索引损坏也可通过 CommitLog 重建。CommitLog 是源,索引是可重建的派生数据。
  • 图/流程:

text
文件布局:
  store/
    commitlog/
      00000000000000000000   ← 1GB
      00000000000001073741824
    consumequeue/
      order/
        0/00000000000000000000   ← 20B × 30W
        1/00000000000000000000
      pay/
        0/...
    index/
      20231030120000000        ← 500W 条
    abort
    checkpoint
text
CommitLog 记录(简化):
  ┌──────────┬──────────┬──────────┬─────────┬─────────┐
  │ TOTALSIZE│ MAGIC    │ BODYCRC  │ QUEUEID │ FLAG    │
  ├──────────┼──────────┼──────────┼─────────┼─────────┤
  │ QUEUEOFFSET(8)      │ PHYSICALOFFSET(8)          │
  ├──────────┼──────────┼──────────┼─────────┼─────────┤
  │ BORNTIME(8) │ STORETIME(8) │ RECONSUMETIMES(4)     │
  ├──────────┴──────────┴──────────┴─────────┴─────────┤
  │ BODY                                                │
  │ TOPIC(len+bytes) + PROPERTIES(len+bytes)            │
  └─────────────────────────────────────────────────────┘
text
写路径:
  Producer → Broker
    → putMessageLock
      → CommitLog mmap 追加(PageCache)
        → ASYNC_FLUSH:直接返回
        → SYNC_FLUSH :GroupCommitService fsync 后返回
      → 主从复制(ASYNC/SYNC_MASTER)
    → 返回 SendResult
  后台:ReputMessageService
    → 构建 ConsumeQueue(20B/条)
    → 构建 IndexFile(有 key 才建)
text
读路径:
  Consumer
    → 读 ConsumeQueue[queueId][offset]
        得到 commitLogOffset + size + tagHash
      → tagHash 不匹配:跳过
      → 匹配:读 CommitLog[commitLogOffset, size]
        → 校验真实 tag / 属性
          → 返回消息
  • 版本/源码锚点:

    • 存储核心:DefaultMessageStore、CommitLog、ConsumeQueue、IndexFile、MappedFile、MappedFileQueue、ReputMessageService、DefaultMessageStore.CleanCommitLogService。
    • 刷盘:FlushRealTimeService(异步)、GroupCommitService(同步)、CommitRealTimeService(transientStorePool 异步提交)。
    • 复制:HAService、HAConnection、HAClient;brokerRole(ASYNC_MASTER / SYNC_MASTER / SLAVE)。
    • 查询:queryMessage(按 key/时间)、DefaultMessageStore.getMessage、ConsumeQueue.getIndexBuffer。
    • 参数:mappedFileSizeCommitLog(1GB)、mappedFileSizeConsumeQueue(30W × 20B)、flushDiskType、fileReservedTime(72h)、deleteWhen(04:00)、diskMaxUsedSpaceRatio(75%)、osPageCacheBusyTimeOutMills、transientStorePoolEnable。
    • 5.x:RocksDB ConsumeQueue(可选)、存算分离、Proxy;开源默认仍是 CommitLog + ConsumeQueue。
  • 三个文件对比:

维度CommitLogConsumeQueueIndexFile
存什么完整消息20 字节目录项key → 物理偏移
组织所有 Topic 混写、顺序按 Topic/队列按 key 哈希
文件大小1GB/个30W 条/个(约 5.72MB)500W 条/个(约 120MB)
写方式顺序追加顺序追加(每队列)随机(哈希槽)
读方式按偏移随机读顺序读哈希查找
是否可重建源数据可可
作用存储与回放消费索引查询索引
  • ConsumeQueue 单条结构:
字段长度作用
CommitLog Offset8B消息体在 CommitLog 的物理位置
Size4B消息总长度
Tag HashCode8B快速过滤 tag(哈希)
  • 刷盘/复制组合:
组合可靠性延迟适用
ASYNC_FLUSH + ASYNC_MASTER最低最低日志、非核心
SYNC_FLUSH + ASYNC_MASTER防单机掉电中一般业务
ASYNC_FLUSH + SYNC_MASTER防主节点故障中一般业务
SYNC_FLUSH + SYNC_MASTER最高最高交易、支付
DLedger(Raft)高 + 自动选主较高强一致/自动容灾
  • 查询方式对比:
查询走哪说明
按队列消费ConsumeQueue → CommitLog正常消费路径
按 msgId解析 Broker 地址 + 物理偏移offsetMsgId 可直接定位
按 keyIndexFile需要生产端设置 KEYS
按时间ConsumeQueue 二分 + CommitLog用于回溯/排查
按 Topic 全量ConsumeQueue 遍历代价高,慎用
  • 失效场景与定位:
现象根因处理
刚发的消息按 key 查不到索引异步构建稍等或按 msgId 查
消费 lag 高且磁盘 IO 高PageCache 未命中、随机读扩内存、减少随机消费、加 Broker
发送 RT 抖动同步刷盘 fsync 慢看磁盘、改异步(评估可靠性)
磁盘使用率飙升保留时间过长/消费停滞调 fileReservedTime、清理、扩容
磁盘满后拒写保护阈值清理/扩容,恢复写入
重启后大量重建异常退出、索引损坏看 abort、重建耗时、预留时间
消息体损坏磁盘故障/断电副本切换、从 CommitLog 恢复
查询超时IndexFile 命中差/全表扫建 key、按时间缩小范围
主从延迟大异步复制积压看 HA 指标、网络、磁盘
ConsumeQueue 与 CommitLog 不一致分发落后/异常等分发追上或重建
  • 深挖点(面试官常追的 6 个):

    1. 为什么所有 Topic 写同一个 CommitLog:如果按 Topic/队列分文件写,多队列并发写会变成随机 IO,磁盘寻道把吞吐打下来;混写到一个日志后,所有写入都是追加,顺序 IO 接近磁盘/PageCache 上限。代价是消费时要靠 ConsumeQueue 定位,读变成“索引顺序 + 数据随机”,但消费通常落后写入不多,数据大概率还在 PageCache 里。
    2. ConsumeQueue 为什么只有 20 字节、为什么要存 tag hash:20 字节是“能定位消息”的最小信息集——物理偏移、长度、tag 哈希。存 tag 哈希是为了消费端过滤时不用读消息体:hash 不匹配直接跳过,匹配才去 CommitLog 校验真实 tag(哈希可能碰撞)。这让“按 tag 订阅”在海量消息下仍然廉价。
    3. mmap 写完就安全了吗:不安全。putMessage 写的是 mmap 映射的 PageCache,数据在内核页缓存里,掉电会丢;异步刷盘默认约 500ms 触发一次,窗口内宕机就丢。同步刷盘通过 GroupCommitService 批量 fsync 后才返回 SEND_OK;再叠加 SYNC_MASTER 才有副本保障。“写进 mmap”≠“落盘”≠“有副本”,这是三件事。
    4. 写放大与读放大:写路径只有 CommitLog 一次顺序写 + 两条很小的索引(20B/条),写放大极小;读路径是 ConsumeQueue 顺序读 + CommitLog 随机读,属于读放大。RocketMQ 用 PageCache、预读、消费位点连续来缓解;如果消费者长期落后很多、或按时间随机回查,就会打到磁盘,表现为 IO 高、RT 抖动。
    5. IndexFile 的结构和限制:文件头记录起止时间与物理偏移,然后是 500 万个哈希槽(每槽 4 字节),再是 500 万个索引项(每项 20 字节:keyHash、物理偏移、时间差、下一条槽位索引),冲突用链表解决。固定 500 万条,写满后新建文件;查询时按 key 哈希找槽、沿链比对。所以 key 设计要避免大量重复(同一 key 多条消息会形成长链);没设 KEYS 的消息只能用 UNIQ_KEY 或 msgId 查,业务 key 查不到。
    6. 删除、恢复与“索引可重建”:消息按 fileReservedTime(默认 72h)和磁盘水位清理,删除是整文件删除,不是逐条删;异常退出会写 abort 文件,重启时 DefaultMessageStore 检测到它就重建 ConsumeQueue/IndexFile(从 CommitLog 重新分发),所以重启可能很慢,大集群要预留时间。理解“CommitLog 是源、索引是派生”是回答存储类问题的关键。
  • 追问链:

    1. RocketMQ 存哪几个文件? → CommitLog、ConsumeQueue、IndexFile。
    2. 哪个存完整消息? → CommitLog。
    3. CommitLog 多大一个? → 默认 1GB。
    4. 所有 Topic 混写吗? → 是。
    5. 为什么混写? → 顺序 IO,高吞吐。
    6. ConsumeQueue 存什么? → 物理偏移、大小、tag 哈希。
    7. 一条多少字节? → 20 字节。
    8. 一个文件多少条? → 30 万条。
    9. 为什么不存消息体? → 只是目录,省空间。
    10. 消费怎么读? → 先读 ConsumeQueue,再读 CommitLog。
    11. ConsumeQueue 顺序吗? → 每个队列内顺序。
    12. CommitLog 读是随机吗? → 按偏移读,可能随机。
    13. 为什么还快? → PageCache、消费连续。
    14. IndexFile 干什么? → 按 key 查消息。
    15. 多大一个? → 500 万条,约 120MB。
    16. 索引项多大? → 20 字节。
    17. 冲突怎么解决? → 哈希槽 + 链表。
    18. 没设 key 能按业务 key 查吗? → 不能,只能用 UNIQ_KEY/msgId。
    19. 按 msgId 怎么查? → 解析 Broker 地址 + 偏移。
    20. 按时间怎么查? → ConsumeQueue 二分。
    21. 写入流程? → 加锁 → 追加 CommitLog → 刷盘/复制 → 返回。
    22. 索引什么时候建? → 异步分发。
    23. 刚写能查到索引吗? → 可能不能。
    24. 刷盘有几种? → 同步/异步。
    25. 异步刷盘多久? → 默认约 500ms 触发。
    26. 异步会丢吗? → 掉电可能丢最后一段。
    27. 同步刷盘怎么实现? → GroupCommitService 批量 fsync。
    28. 复制有几种? → 异步/同步 Master。
    29. SEND_OK 就安全吗? → 看刷盘与复制配置。
    30. mmap 是什么? → 文件映射到虚拟内存。
    31. 写完在 PageCache 吗? → 是。
    32. PageCache 丢了会怎样? → 未刷盘数据丢。
    33. transientStorePool 是什么? → 堆外写缓冲,异步提交。
    34. 写放大为什么小? → 一次顺序写 + 小索引。
    35. 读放大在哪? → CommitLog 随机读。
    36. 怎么缓解? → PageCache、扩内存、连续消费。
    37. 消息保留多久? → 默认 72 小时。
    38. 怎么删? → 整文件删除。
    39. 磁盘满了会怎样? → 清理,再高只读。
    40. abort 文件是什么? → 异常退出标记。
    41. 重启为什么慢? → 重建 ConsumeQueue/IndexFile。
    42. 索引能重建吗? → 能,从 CommitLog 分发。
    43. CommitLog 能重建吗? → 不能,它是源。
    44. 主从复制复制什么? → CommitLog。
    45. Slave 能读吗? → 能。
    46. DLedger 改了哪层? → CommitLog 写入走 Raft。
    47. 5.x 存储有什么变化? → RocksDB ConsumeQueue 可选、存算分离。
    48. 怎么监控存储? → 磁盘、IO、PageCache、分发延迟。
    49. 怎么优化写? → 顺序写、批量、异步刷盘(评估可靠性)。
    50. 面试怎么总结? → 一份日志 + 两份索引 → 顺序写 → 异步分发 → 刷盘/复制定可靠性 → 读放大与 PageCache → 清理与重建。
  • 生产案例/取舍(示例,替换成你的项目):

    • 消费 lag 高时 Broker 磁盘 IO 打满,原因是消费者落后太多、PageCache 未命中;扩内存 + 增加消费者后恢复。
    • 异步刷盘 + 异步复制,机房断电丢最后 1 秒订单消息;核心 Topic 改同步刷盘 + 同步复制。
    • 磁盘使用率到 90% 进入只读,生产全部失败;调小保留时间 + 扩容 + 加水位告警。
    • 按 key 查不到消息,排查是生产端没设 KEYS;补 key 规范。
    • 用同一个 key 发大量消息,IndexFile 链表过长、查询变慢;改用唯一业务键。
    • 重启后重建索引耗时 40 分钟,期间消费不可用;优化停机流程、预留重建窗口。
    • CommitLog 所在盘故障,靠 Slave 切换恢复;事后加副本与巡检。
    • 同步刷盘后发送 RT 从 2ms 涨到 10ms;非核心 Topic 改异步,核心保留同步。
    • 消费位点长期落后,读放大导致 IO 飙高;扩容消费者 + 提升处理速度。
    • 每天 04:00 删除过期文件引发 IO 抖动;错峰 + 控制删除速率。
    • 5.x 试水 RocksDB ConsumeQueue,索引查询更稳;评估兼容性与运维成本。
    • 取舍:混写换写吞吐,代价是读放大;20 字节索引换空间,代价是二次读;异步刷盘换低延迟,代价是丢消息窗口;同步刷盘换可靠,代价是 RT;索引异步构建换写性能,代价是短暂不可查。
  • 易错点:

    • 认为 CommitLog 按 Topic 分文件。
    • 认为每个队列一个 CommitLog。
    • 认为 ConsumeQueue 存消息体。
    • 认为 ConsumeQueue 一条很大。
    • 认为 IndexFile 是主存储。
    • 认为没设 KEYS 也能按业务 key 查。
    • 认为写进 mmap 就已经落盘。
    • 认为 SEND_OK 一定持久化。
    • 认为异步刷盘不会丢。
    • 认为同步刷盘没有性能代价。
    • 认为复制和刷盘是一回事。
    • 认为索引是同步构建的。
    • 认为刚发的消息一定能立刻按 key 查到。
    • 认为 CommitLog 读一定是顺序的。
    • 认为 RocketMQ 读没有放大。
    • 认为 PageCache 不影响性能。
    • 认为消息是逐条删除的。
    • 认为磁盘满了只是写入变慢。
    • 认为重启不需要重建索引。
    • 认为 ConsumeQueue 损坏就无法恢复。
    • 认为 CommitLog 损坏也能从索引恢复。
    • 认为主从复制复制的是 ConsumeQueue。
    • 认为 Slave 不能提供读。
    • 认为 DLedger 不影响写入路径。
    • 认为 5.x 默认就用 RocksDB 存 ConsumeQueue。
    • 认为消息保留时间可以随便调大。
    • 认为磁盘水位告警可以省。
    • 认为存储层和可靠性无关。
  • 30 秒口述稿:

RocketMQ 存储是“一份日志加两份索引”。所有 Topic 的消息都追加到 CommitLog,1GB 一个文件,纯顺序写,这是高吞吐的根基;后台异步把新消息分发成 ConsumeQueue 和 IndexFile。ConsumeQueue 是按 Topic 队列的目录,每条只有 20 字节:CommitLog 物理偏移、消息大小、tag 哈希,消费时先读它再回 CommitLog 取消息体;IndexFile 按 key 建哈希索引,用来排查和查询。写入先到 mmap 的 PageCache,异步刷盘约 500ms 一次,同步刷盘走 GroupCommitService,真正安全还要看主从是同步还是异步。所以 SEND_OK 只代表按当前配置成功,不等于落盘和有副本。消息默认保留 72 小时,整文件删除;异常退出靠 abort 文件触发 ConsumeQueue 和 IndexFile 重建。

  • 3 分钟展开顺序:结论(一份日志 + 两份索引)→ 目录与文件大小 → CommitLog 记录结构与混写原因 → ConsumeQueue 20 字节结构与 tag 过滤 → IndexFile 哈希槽与查询 → 写路径(加锁、mmap、异步分发)→ 刷盘与复制四种组合 → 读路径(索引 + 随机读、读放大、PageCache)→ 按 msgId/key/时间查询 → 清理、磁盘保护、abort 与重建 → 与可靠性、积压、顺序的联动。