# 第 29 章：存储前的队列

> 新年零点那一分钟，消息是平时的 10 倍，存储每秒只写得下 2 万条。发消息的人，要等存储写完才拿到确认吗？

深入理解 IM 系统 · https://im.liko.page/zh/queue-before-storage/

到第 28 章，每个会话归一台消息服务器管，它给消息取 seq。取完以后的路还是 v1 那条：把消息写进存储，提交了才回确认（ACK），再推送（第 3、5 章）。

平时这没问题。v3 平均每秒 4,630 条消息，高峰 13,900 条；存储在第 28 章也分了片，假设存消息的那几片合起来每秒写得下 2 万条，还有余量。可新年零点那一分钟，或者一个群突然火了，消息会是平时的好几倍。

这一章的问题：**来的比存储写得快时，发消息的人要不要等存储？**

## 1. 一分钟的高峰

假设高峰是平均的 10 倍，每秒 46,300 条，持续一分钟。存储每秒只写 2 万条，每秒多出 26,300 条，排在它前面。

这一分钟结束时，前面排着约 **158 万**条。高峰过后，消息回到平时的每秒 4,630 条，存储每秒只比进来的多写约 1.5 万条，还要约 **103 秒**才排完。

## 2. 存储在路上：确认跟着排队

确认要等提交，所以排队的时间就是发送者等确认的时间。高峰最后一秒发出的那条，要等 158 万 ÷ 2 万 ≈ **79 秒**。

手机等不了这么久。第 3 章定过：没等到确认，就在第 1、3、7、15 秒重发，到第 31 秒标成“失败”。按上面的速度：

- 高峰开始约 24 秒以后发的，等待就超过了 31 秒；
- 一直到高峰过后约 62 秒，排队才短回 31 秒以内；
- 这中间发的约 **197 万**条，在发送者的手机上都显示“发送失败”。

它们大多其实会被存下，只是晚了。Ana 看到红色的感叹号，点一下重发；服务器早就收到了，用户却以为丢了。就算服务器认出重复一点不费力（第 4 章），每条也多发了四次。

推送在提交之后，所以 Ben 那边也晚：最晚的一条，晚到 79 秒。

## 3. 先写日志，再回确认

v3 在消息服务器和存储之间加一条**消息日志**：一个持久的、只能往后追加的队列，写进去的东西存在 3 台机器上。

发消息的路变成：

1. 消息服务器认重复（第 4 章）、取 seq（第 28 章）；
2. 把消息追加到日志里这个会话所在的分区；
3. 日志存好了，就回确认，带着 seq。

日志只往末尾追加，很多条合成一次写盘，比存储的随机写快得多。假设它每秒收得下 20 万条，46,300 条的高峰不用排队，确认几毫秒就回，“失败”一条也没有。

**分区**是日志分成的若干段，每段内部有先后。同一个会话的消息总进同一个分区，所以读出来的顺序就是 seq 的顺序。

日志后面，几个**消费者**各读各的：

- **推送**：读到就推给在线的设备（第 2 章）。
- **会话记录**：给每个成员改那一行、贴版本号（第 11 章）。发给谁按第 12 章的成员区间算：成员表记着每人能看的 seq 从哪到哪，第 4,823 条发给区间含 4,823 的人。消费者晚一分钟才算，中间有人退了群，他那一行还在，照样算上他；结果和马上算一样。
- **存储**：把消息写进消息存储，按“会话 + seq”写，写两次也只有一行。

每个消费者记着自己读到了日志的哪一处，但不是每做一条就记一次，比如每 100 条记一次。做到这 100 条的第 80 条时挂了，重启后从上次记下的地方接着读，这 80 条就再做一遍。所以每个消费者都要做两遍也没事：存储按“会话 + seq”写，写两遍还是一行；推送再推一遍，手机本地库里的（会话, seq）是唯一键（第 7 章），还是那一行。

高峰时的 158 万条还是要排，只是从“发消息的人等”变成了“存储落后”：最多落后 79 秒，排在日志的磁盘上，而不是谁的内存里。

落得最远的是会话记录：每条消息要改每个收件人的那一行，高峰时每秒约 31 万个小事务（46,300 条 × 平均 6.67 个收件人）。假设记录的存储按平时的高峰配，高峰最后一条的记录要晚约 140 秒才写上，高峰过后约 3.5 分钟才追平。推送不等它，消息照样马上到；晚的是会话列表的顺序和未读数。

**第 11 章的待办，就是这条日志。** 那时，消息的事务里记一行“徒步群 4,823，改所有成员的会话”，后台再慢慢改。现在不用另记：日志里的每条消息就是一行待办，会话记录这个消费者读到哪，待办就做到哪。（第 15 章单聊已读回执的待办不一样：它记在读的事务里，不是一条消息，仍然单独记。）

**第 3 章的“存好”，从此是“进了日志”。** 确认回来时，消息已经在 3 台机器上，丢不了；可它可能还不在存储里。

## 4. 三件要做对的事

**一、先能取到，再告诉别人。** 推送、会话记录、最新 seq，都是在告诉设备“4,823 有了”。设备听到，可能马上来拉：补一个洞（第 5 章），或者拿落下的会话最新一条（第 6 章）。这时存储如果还落后 79 秒，就拉了个空。

办法是让一个快的消费者先走：把消息写进一份**最近消息的缓存**（在内存里），更新最新 seq，然后才允许推送和会话记录去说“有了”。读的时候先查这份缓存，没有再查存储。整段高峰的 158 万条放进缓存，约 316 MB。开源的 [OpenIM](https://github.com/openimsdk/open-im-server/blob/175a7bb/internal/msgtransfer/online_history_msg_handler.go) 就是这个顺序：先写 Redis，再交给写 MongoDB 的队列和推送的队列。

**二、迟到的重复。** v1 认重复有两道：内存里最近的消息 ID，加上存储里“发送者 + 消息 ID”的唯一键（第 4 章）。第二道兜的是很晚才补发的那种，比如 App 被杀了一小时，从发件箱再发。现在确认在存储之前，唯一键要等存储写到才开口，太晚了：服务器已经给这条重复取了新 seq、回了确认。

所以：

- 最近 ID 的窗口，要比存储可能落后的时间长。窗口是为高峰设的，所以按含高峰那一分钟的 5 分钟算：46,300 × 60 加上其余 4 分钟按平时高峰 13,900 × 240，约 611 万个 ID、196 MB，分在各台消息服务器上。
- 更晚的补发，手机带上“第一次发是多久以前”（用手机自己的钟算差，不怕它和服务器的钟对不齐）；比窗口还旧的，消息服务器先查一次存储里的唯一键，再决定取不取 seq。这种补发很少，这一次查询不贵。

**三、换主人时，别从存储接着数。** 第 28 章的新主人，从存储里最后一条的 seq 接着发。可现在存储可能落后 79 秒，日志里已经有更大的号，接着数就会重号；第 14 章每条消息带的两个数（到这条为止的计数、发送者在这个会话里的流水号）也一样，而它们一个也不能跳，也不能重（跳一个或重一个，第 14 章算出的未读数就差一条）。所以新主人先等最近消息缓存读到日志末尾，从缓存里取这个会话最后的 seq、计数、流水号和最近 5 分钟的消息 ID，再开始服务。缓存平时只落后几毫秒。

第 28 章兜底的唯一键（会话, seq）也要等存储写到才开口，那时确认早回了。所以日志自己要挡住旧主人（第 28 章的租约：续不上约的主人自己停，可它可能卡住几秒才发现）：每次追加带上租约的编号，比已见过的旧的，拒掉。

## 5. 算一下

- **高峰：** 每秒 46,300 条，一分钟；排队最多约 158 万条，存储最多落后 79 秒，高峰过后约 103 秒追平。
- **发送者：** 存储在路上，约 197 万条显示“失败”；先写日志，0 条。
- **日志：** 每天 400,000,000 条 × 200 字节 = 80 GB；留 3 天、存 3 份，720 GB。
- **消费者，v3 平时高峰：** 存储每秒 13,900 条，是它能力的七成；推送每秒 139,000 次（按设备算，每条 10 台）；会话记录每秒约 9.3 万个小事务、18.5 万行（按人算，每人一个事务，10 台 ÷ 每人 1.5 台 = 6.67 人），按一台存储每秒 2 万行算要 9.3 台（第 32 章算总账）。

## 6. 代价

- **多一套系统。** 日志集群要部署、要扩容、要盯着，3 份副本，720 GB。
- **确认不等于在存储里。** 平时存储只晚几毫秒，高峰时晚几十秒；每个消费者都要能重做、要记住读到哪；谁落后了多少，要有人看（第 33、36 章）。
- **热的会话还是一条道。** 一个群的消息只进一个分区，按顺序由一个消费者读，不能拆开并行。这是第 28 章“热会话只在一台服务器上”在日志里又出现了一次。
- **多一份缓存要先写对。** 告诉设备之前，消息必须已经能取到；换主人时，也要从它那里接着数。

## 7. 其他答案

- **直接写存储。** v1、v2 都这样，量小的时候最简单，少一套系统。
- **按高峰买存储。** 为一分钟的高峰准备平时高峰 3.3 倍的写入能力，一年里绝大多数时间空着。
- **先进队列，再取 seq。** OpenIM 的发送接口把消息写进 Kafka 就返回，确认里只有服务端消息 ID 和时间（[send.go](https://github.com/openimsdk/open-im-server/blob/175a7bb/internal/rpc/msg/send.go)）；后面的消费者才取 seq、写缓存、再交给存储和推送。好处是收消息的地方不用管 seq；代价是确认里没有 seq，自己发的消息要等推送或同步才知道排在哪（第 5 章）。Telegram 的公开 API 是另一边：单聊发出一条消息，回来的 [`updateShortSentMessage`](https://core.telegram.org/constructor/updateShortSentMessage) 里就有这条消息的 `id` 和 `pts`（账号的更新序号），发的人马上知道它排在哪；服务器里面是先排队还是先入库，没有公开。
- **钉钉。** 公开的文章（[阿里IM技术分享(九)](http://www.52im.net/thread-4106-1-1.html)，钉钉技术专家尹启绣）说：收消息的应用只校验能不能发，投进 RocketMQ 就返回；后面的应用入库，再经消息队列交给同步服务推给在线的人。写队列失败时还有两道后备：直接调用后面的应用，再不行写本地的 redoLog，定时回放进队列。入库失败也照样推送，入库放到单独的队列里重试。

## 8. 这一章的决定

**决策卡**

- 问题：存储在发送路径上：一分钟 10 倍的高峰，确认最多要等 79 秒，约 197 万条消息在发送者手机上显示“失败”，推送也一起晚。
- 选择：消息服务器取完 seq，把消息追加到按会话分区的消息日志，日志存好就回确认。最近消息缓存、推送、会话记录、存储各自从日志读，按自己的速度追，能重做、记着读到哪；先写缓存，再告诉设备“有了”。
- 代价：多一套日志集群（3 份，720 GB）；确认时消息可能还不在存储里，高峰时存储落后几十秒、会话记录落后几分钟；每个消费者要能重做；热的会话只有一个分区；迟到的重复要靠更长的窗口；换主人要从缓存接着数，日志要挡住旧主人。
- 什么时候重新考虑：消息到底送到没有（第 33 章）；过载时丢什么（第 34 章）；存储慢下来（第 36 章）；丢掉一个机房时，日志里还没复制的消息（第 37 章）。
- 其他答案：直接写存储（量小时）；按高峰买存储；先进队列再取 seq、确认不带 seq（OpenIM）；入库失败照样推送（钉钉）。

服务器这边的路通了。可客户端那一半，第 3 章到这里的每一条规则，iOS、安卓、电脑、网页各要写一遍。下一章：一套 SDK，多个平台。
