Appearance
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 就安全”。
分层要点:
- 目录结构:
${storePathRootDir}/commitlog/下是 1GB 一个的 CommitLog 文件;consumequeue/<topic>/<queueId>/下是 30 万条一个的索引文件(每条 20 字节,约 5.72MB);index/下是 IndexFile(默认 500 万条一个,约 120MB)。另外还有abort(异常退出标记)、checkpoint(刷盘点)、config/(Topic/消费位点等)。 - CommitLog 是唯一的“真数据”:所有 Topic、所有队列的消息混写在一个顺序日志里,只追加、不修改;单条记录包含消息体、Topic、属性、队列 ID、队列内偏移、物理偏移、生成时间、host、重试次数等。1GB 文件写满后滚到下一个,顺序写是 RocketMQ 高吞吐的根基。
- ConsumeQueue 是“按队列的目录”:每个 Topic 的每个队列一个目录,每条索引 20 字节——
8 字节 CommitLog 物理偏移 + 4 字节消息大小 + 8 字节 tag 哈希。消费者按队列顺序读它,拿到物理偏移再去 CommitLog 读消息体。它不存消息,只存“去哪找”,所以极小。 - IndexFile 是“按 key 的索引”:以消息的
KEYS(未设置时通常用UNIQ_KEY兜底)做哈希,落到 500 万个槽位,槽位后挂链表,每个索引项 20 字节(keyHash、物理偏移、时间差、下一条)。用于按 key 查消息、排查问题;没设KEYS的消息按业务 key 查不到。 - 写入路径:Producer 消息到达 →
DefaultMessageStore.putMessage加锁(putMessageLock)→ 追加到 CommitLog 的 mmap(PageCache)→ 按flushDiskType决定同步/异步刷盘 → 返回SendResult;同时ReputMessageService异步把新消息“分发”成 ConsumeQueue 与 IndexFile。索引构建是异步的,所以刚写入的消息可能瞬间查不到索引。 - 刷盘与复制决定“什么时候算安全”:异步刷盘只写 PageCache,靠内核回刷(默认 500ms 触发),宕机可能丢最后一段;同步刷盘用
GroupCommitService批量 fsync 后才返回;主从复制有ASYNC_MASTER/SYNC_MASTER。SEND_OK只代表“按当前配置成功”,不等于一定落盘/有副本(5.1-1)。 - 读取路径:消费时先读 ConsumeQueue(mmap,顺序)拿到物理偏移,再读 CommitLog(mmap,可能随机)取消息体;tag 过滤先用 ConsumeQueue 里的 tag hash 快速跳过,hash 命中后再校验真实 tag。按 msgId 查可直接解析出 Broker 地址 + 物理偏移;按 key 查走 IndexFile;按时间查对 ConsumeQueue 二分。
- 清理、恢复与保护:消息默认保留 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
checkpointtext
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。
- 存储核心:
三个文件对比:
| 维度 | CommitLog | ConsumeQueue | IndexFile |
|---|---|---|---|
| 存什么 | 完整消息 | 20 字节目录项 | key → 物理偏移 |
| 组织 | 所有 Topic 混写、顺序 | 按 Topic/队列 | 按 key 哈希 |
| 文件大小 | 1GB/个 | 30W 条/个(约 5.72MB) | 500W 条/个(约 120MB) |
| 写方式 | 顺序追加 | 顺序追加(每队列) | 随机(哈希槽) |
| 读方式 | 按偏移随机读 | 顺序读 | 哈希查找 |
| 是否可重建 | 源数据 | 可 | 可 |
| 作用 | 存储与回放 | 消费索引 | 查询索引 |
- ConsumeQueue 单条结构:
| 字段 | 长度 | 作用 |
|---|---|---|
| CommitLog Offset | 8B | 消息体在 CommitLog 的物理位置 |
| Size | 4B | 消息总长度 |
| Tag HashCode | 8B | 快速过滤 tag(哈希) |
- 刷盘/复制组合:
| 组合 | 可靠性 | 延迟 | 适用 |
|---|---|---|---|
| ASYNC_FLUSH + ASYNC_MASTER | 最低 | 最低 | 日志、非核心 |
| SYNC_FLUSH + ASYNC_MASTER | 防单机掉电 | 中 | 一般业务 |
| ASYNC_FLUSH + SYNC_MASTER | 防主节点故障 | 中 | 一般业务 |
| SYNC_FLUSH + SYNC_MASTER | 最高 | 最高 | 交易、支付 |
| DLedger(Raft) | 高 + 自动选主 | 较高 | 强一致/自动容灾 |
- 查询方式对比:
| 查询 | 走哪 | 说明 |
|---|---|---|
| 按队列消费 | ConsumeQueue → CommitLog | 正常消费路径 |
| 按 msgId | 解析 Broker 地址 + 物理偏移 | offsetMsgId 可直接定位 |
| 按 key | IndexFile | 需要生产端设置 KEYS |
| 按时间 | ConsumeQueue 二分 + CommitLog | 用于回溯/排查 |
| 按 Topic 全量 | ConsumeQueue 遍历 | 代价高,慎用 |
- 失效场景与定位:
| 现象 | 根因 | 处理 |
|---|---|---|
| 刚发的消息按 key 查不到 | 索引异步构建 | 稍等或按 msgId 查 |
| 消费 lag 高且磁盘 IO 高 | PageCache 未命中、随机读 | 扩内存、减少随机消费、加 Broker |
| 发送 RT 抖动 | 同步刷盘 fsync 慢 | 看磁盘、改异步(评估可靠性) |
| 磁盘使用率飙升 | 保留时间过长/消费停滞 | 调 fileReservedTime、清理、扩容 |
| 磁盘满后拒写 | 保护阈值 | 清理/扩容,恢复写入 |
| 重启后大量重建 | 异常退出、索引损坏 | 看 abort、重建耗时、预留时间 |
| 消息体损坏 | 磁盘故障/断电 | 副本切换、从 CommitLog 恢复 |
| 查询超时 | IndexFile 命中差/全表扫 | 建 key、按时间缩小范围 |
| 主从延迟大 | 异步复制积压 | 看 HA 指标、网络、磁盘 |
| ConsumeQueue 与 CommitLog 不一致 | 分发落后/异常 | 等分发追上或重建 |
深挖点(面试官常追的 6 个):
- 为什么所有 Topic 写同一个 CommitLog:如果按 Topic/队列分文件写,多队列并发写会变成随机 IO,磁盘寻道把吞吐打下来;混写到一个日志后,所有写入都是追加,顺序 IO 接近磁盘/PageCache 上限。代价是消费时要靠 ConsumeQueue 定位,读变成“索引顺序 + 数据随机”,但消费通常落后写入不多,数据大概率还在 PageCache 里。
- ConsumeQueue 为什么只有 20 字节、为什么要存 tag hash:20 字节是“能定位消息”的最小信息集——物理偏移、长度、tag 哈希。存 tag 哈希是为了消费端过滤时不用读消息体:hash 不匹配直接跳过,匹配才去 CommitLog 校验真实 tag(哈希可能碰撞)。这让“按 tag 订阅”在海量消息下仍然廉价。
- mmap 写完就安全了吗:不安全。
putMessage写的是 mmap 映射的 PageCache,数据在内核页缓存里,掉电会丢;异步刷盘默认约 500ms 触发一次,窗口内宕机就丢。同步刷盘通过GroupCommitService批量 fsync 后才返回SEND_OK;再叠加SYNC_MASTER才有副本保障。“写进 mmap”≠“落盘”≠“有副本”,这是三件事。 - 写放大与读放大:写路径只有 CommitLog 一次顺序写 + 两条很小的索引(20B/条),写放大极小;读路径是 ConsumeQueue 顺序读 + CommitLog 随机读,属于读放大。RocketMQ 用 PageCache、预读、消费位点连续来缓解;如果消费者长期落后很多、或按时间随机回查,就会打到磁盘,表现为 IO 高、RT 抖动。
- IndexFile 的结构和限制:文件头记录起止时间与物理偏移,然后是 500 万个哈希槽(每槽 4 字节),再是 500 万个索引项(每项 20 字节:keyHash、物理偏移、时间差、下一条槽位索引),冲突用链表解决。固定 500 万条,写满后新建文件;查询时按 key 哈希找槽、沿链比对。所以 key 设计要避免大量重复(同一 key 多条消息会形成长链);没设
KEYS的消息只能用UNIQ_KEY或 msgId 查,业务 key 查不到。 - 删除、恢复与“索引可重建”:消息按
fileReservedTime(默认 72h)和磁盘水位清理,删除是整文件删除,不是逐条删;异常退出会写abort文件,重启时DefaultMessageStore检测到它就重建 ConsumeQueue/IndexFile(从 CommitLog 重新分发),所以重启可能很慢,大集群要预留时间。理解“CommitLog 是源、索引是派生”是回答存储类问题的关键。
追问链:
- RocketMQ 存哪几个文件? → CommitLog、ConsumeQueue、IndexFile。
- 哪个存完整消息? → CommitLog。
- CommitLog 多大一个? → 默认 1GB。
- 所有 Topic 混写吗? → 是。
- 为什么混写? → 顺序 IO,高吞吐。
- ConsumeQueue 存什么? → 物理偏移、大小、tag 哈希。
- 一条多少字节? → 20 字节。
- 一个文件多少条? → 30 万条。
- 为什么不存消息体? → 只是目录,省空间。
- 消费怎么读? → 先读 ConsumeQueue,再读 CommitLog。
- ConsumeQueue 顺序吗? → 每个队列内顺序。
- CommitLog 读是随机吗? → 按偏移读,可能随机。
- 为什么还快? → PageCache、消费连续。
- IndexFile 干什么? → 按 key 查消息。
- 多大一个? → 500 万条,约 120MB。
- 索引项多大? → 20 字节。
- 冲突怎么解决? → 哈希槽 + 链表。
- 没设 key 能按业务 key 查吗? → 不能,只能用 UNIQ_KEY/msgId。
- 按 msgId 怎么查? → 解析 Broker 地址 + 偏移。
- 按时间怎么查? → ConsumeQueue 二分。
- 写入流程? → 加锁 → 追加 CommitLog → 刷盘/复制 → 返回。
- 索引什么时候建? → 异步分发。
- 刚写能查到索引吗? → 可能不能。
- 刷盘有几种? → 同步/异步。
- 异步刷盘多久? → 默认约 500ms 触发。
- 异步会丢吗? → 掉电可能丢最后一段。
- 同步刷盘怎么实现? → GroupCommitService 批量 fsync。
- 复制有几种? → 异步/同步 Master。
SEND_OK就安全吗? → 看刷盘与复制配置。- mmap 是什么? → 文件映射到虚拟内存。
- 写完在 PageCache 吗? → 是。
- PageCache 丢了会怎样? → 未刷盘数据丢。
- transientStorePool 是什么? → 堆外写缓冲,异步提交。
- 写放大为什么小? → 一次顺序写 + 小索引。
- 读放大在哪? → CommitLog 随机读。
- 怎么缓解? → PageCache、扩内存、连续消费。
- 消息保留多久? → 默认 72 小时。
- 怎么删? → 整文件删除。
- 磁盘满了会怎样? → 清理,再高只读。
- abort 文件是什么? → 异常退出标记。
- 重启为什么慢? → 重建 ConsumeQueue/IndexFile。
- 索引能重建吗? → 能,从 CommitLog 分发。
- CommitLog 能重建吗? → 不能,它是源。
- 主从复制复制什么? → CommitLog。
- Slave 能读吗? → 能。
- DLedger 改了哪层? → CommitLog 写入走 Raft。
- 5.x 存储有什么变化? → RocksDB ConsumeQueue 可选、存算分离。
- 怎么监控存储? → 磁盘、IO、PageCache、分发延迟。
- 怎么优化写? → 顺序写、批量、异步刷盘(评估可靠性)。
- 面试怎么总结? → 一份日志 + 两份索引 → 顺序写 → 异步分发 → 刷盘/复制定可靠性 → 读放大与 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 与重建 → 与可靠性、积压、顺序的联动。