# 第 40 章：社区服务器

> 一个社区有 10 万成员、50 个频道，大多数人一周才来看一两次。主线给每个成员改一行会话记录、推给每台在线设备，在这里每条消息要做多少事？

深入理解 IM 系统 · https://im.liko.page/zh/community-servers/

App 加了一个新东西：**社区**。一个户外品牌开了“山野”社区，10 万人加入。社区里有 50 个**频道**：#公告、#路线、#装备、#二手……每个频道就是一个会话，人人都能看历史、能说话，只要权限允许。Discord 把这样的社区叫 server（服务器），这一章的标题由此而来；下文都叫“社区”，免得和机器混在一起。

Ana 也加入了。她一周点开两次，看过的只有 3 个频道。其他 10 万人大多和她一样：加了，很少来。热闹的晚上，整个社区每秒有 10 条消息。

这一章从 v3（[第 32 章](/zh/v3-million-online/)）出发，问：主线的做法搬到这样的社区里，哪些留下，哪些要改？第 11、12、13 章都说过“成员上万的群不走这条路”，这一章就是那条路。

## 1. 社区和群差在哪

| | 徒步群（主线） | 山野社区 |
|---|---|---|
| 人数 | 500 | 100,000 |
| 会话 | 一个群一个会话 | 一个社区 50 个频道 |
| 谁在看 | 很多人每天都看 | 在线的人里，大多在看别的 |
| 谁能看什么 | 在群里就能看 | 按角色：有的频道只有管理员能看，有的只有老会员能说话 |
| 新人能看多少历史 | 进群前 100 条（第 12 章） | 频道里全部历史，有权限就能看 |

最后两行是新需求，前三行是规模。先看规模。

## 2. 照主线做，一条消息要做多少事

社区里 10 万成员，按全书的假设，高峰时 10% 在线，就是 1 万人。Discord 公开说过，大社区里约 90% 的成员连接是“被动”的：人在线，但没点进这个社区看（[Discord, 2023](https://discord.com/blog/maxjourney-pushing-discords-limits-with-a-million-plus-online-users-in-a-single-server)）。照这个比例，在看的约 1,000 人，在线但在看别处的 9,000 人，不在线的 9 万人。

主线的 v3 收到社区里的一条消息，要做这些：

- **改会话记录**（[第 11 章](/zh/conversation-sync/)）：给每个成员的那一行写上最新 seq、涨记录版本。一条消息 **10 万次更新**，每次是一个小事务、写两行（这个人的版本号和那一行记录）。每秒 10 条，就是每秒 100 万次更新、200 万行，至少 100 台存储（一台每秒 2 万行）；是整个 v3 所有会话记录写入（每秒约 18.5 万行）的 10.8 倍。
- **查在线路由**（[第 20 章](/zh/split-the-gateway/)）：每个成员查一次在哪台网关，每秒 100 万次，是 v3 全部路由查询的 10.8 倍。
- **推给每台在线设备**（[第 16 章](/zh/many-devices/)）：一条推 1 万次（按每人一台设备算；按全书的每人 1.5 台还会更多），每秒 10 万次，两台网关的全部推送能力（一台网关每秒推 5 万次，第 22 章），v3 整体推送的 72%。
- **给离线的人发通知**（[第 17 章](/zh/offline-push/)）：一个会话一分钟最多一个。可社区一直有人说话：每个热闹的频道，每分钟给 9 万个离线成员各发一个，就是每秒 1,500 个。
- **读到哪**（[第 14 章](/zh/unread/)）：每人每个频道一个，500 万行。
- **成员名单**（[第 13 章](/zh/group-sync/)）：整份是 10 万 × 40 字节 = 4 MB。每天进出 1,000 人，成员版本号平均 86 秒就涨一次，手机几乎每次打开都要补。
- **进群、退群占一个 seq**（[第 12 章](/zh/group-membership/)）：一天 1,000 条“某某加入了”，发给 10 万人。

这不是故意搭一个笨设计：这就是主线，在 500 人的群里每一条都算得过来。坏的是规模。Discord 讲过这个形状：社区里每个人说一句，每句又要送给每个人，工作量随人数的**平方**涨。在线 1,000 人各说一句，是 100 万次投递；1 万人，1 亿次；10 万人，100 亿次。

也有不坏的，先记下来：

- **每个频道一个 seq**（第 5 章）、**每个频道归一台消息服务器**（[第 28 章](/zh/message-owners/)）：每秒 10 条，离一台消息服务器每秒 5,000 条（第 28 章的假设）远得很。
- **消息日志**（第 29 章）、**网关**（第 20–24 章）：一条消息还是一条。
- **消息只存一份**（第 6、10 章）：本来就是读扩散，按频道存。

## 3. 决定：只存一份，谁在看推给谁

社区的频道不再给成员写任何东西。一条消息只做三件事：

1. **存一份**，更新频道的最新 seq（缓存里一个数）。
2. **推给正在看这个社区的设备。** 设备点开社区时**订阅**它：告诉服务端“我在看山野”；切走或退到后台时退订。这和第 21 章的在线状态一样：只告诉正在看的人。订阅名单放在负责这个社区的那台服务器的内存里，约 1,000 台设备；推的时候照着名单推，不用再为 10 万个成员一个个查路由。每秒推 1 万次，比主线少 90%，是一台网关能力的 20%。
3. **没在看的在线设备，最多一分钟收一帧“山野有新消息”**，让社区图标亮个点。9,000 台，每秒 150 帧。

那没在看的人怎么知道哪个频道有新消息？**进来时自己取**。Ana 点开山野，手机问一次 50 个频道的最新 seq，50 × 12 字节 = 600 字节，就是第 6 章的最新 seq 扫一遍，只是只扫这一个社区。按每个在线的人一小时点开一次算，每秒约 2.8 次，每次读 50 个数，每秒 139 次缓存读。

“Ana 加入了哪些社区”还是一条会话记录（第 10、11 章）：一人一个社区一行，加入、退出、改设置时才改，**来消息时不改**。换了新手机，照样把这些记录抄过去。

通知也改：社区默认只在**有人 @ 我**时发系统推送，其他消息不发。一次 @ 只给被 @ 的那个人写一行，不是给全社区每人写一行。

Telegram 的超级群是同一个思路：每个超级群有自己的一条事件序列；客户端只对**正在看的**超级群定期去拉更新，最多同时 10 个，关掉就停；服务端也可能对某些超级群少发或不发更新（[updates](https://core.telegram.org/api/updates)）。

## 4. 未读只记打开过的频道

第 14 章每人每个会话一个读到哪。社区里是 10 万 × 50 = 500 万行，大多数永远不会动。

改成：**读的时候才建**。Ana 第一次打开 #路线，才有一行（成员、频道、读到哪、@ 数）。平均每人打开过 3 个频道，就是 30 万行，500 万的 6%；一行约 24 字节，共 7.2 MB，原来是 120 MB。

- **打开过的频道**：进社区时拿到最新 seq，和自己那行的读到哪比，大了就加粗；@ 数单独显示。
- **没打开过的频道**：没有那一行。频道的最新消息比她加入社区的时间晚，就加粗，不显示数字。

为什么不再显示精确的未读数？第 14 章的精确数，靠的是每来一条消息，服务端都把“到这条为止的计数”写进每个人的会话记录。社区不写了，也就只剩“有新的”和“几个 @”。而一个频道 300 条没读，Ana 想知道的也只是这两件。

读的报告照第 14 章：只往上涨，最多一秒一次。只有在看的人会报，最多每秒 1,000 次写，一台存储的 5%。

**@所有人**，在主线里是 500 行，这里是 10 万行。改成在频道上记一行：“第几条 @ 了所有人”。Ana 进来扫的时候，这一条比她的读到哪新，@ 数就加一。能不能用 @所有人，本身是一个权限（第 6 节）。

## 5. 成员名单按需加载

第 13 章的手机存一份整的成员名单，带版本号。社区里整份是 4 MB，而且一直在变。

改成**只拿屏幕上要的**：

- **侧边的成员列表**：拿当前这一屏，100 行 × 40 字节 = 4 KB，往下翻再拿下一屏。在线状态只订阅这一屏的人（第 21 章不用改）。
- **输入 @**：按前缀搜，最多回 100 个，约 4 KB。
- **消息上的名字**：只拿这一页消息的发送者。Matrix 的成员懒加载就是这样（第 13 章提过）。

Discord 给机器人的网关接口也是这个形状：社区人多过一个门槛（`large_threshold`，50 到 250），连接时就不再发离线成员；要成员时按前缀查，最多 100 个，或者分块拿，每块最多 1,000 个（[Gateway Events](https://docs.discord.com/developers/events/gateway-events)）。

进社区、退社区不再是一条发给全体的系统消息，只改成员表。

## 6. 按频道的权限：角色

主线里，在群里就能看、能发（第 12 章）。社区要细得多：#公告只有管理员能发；#老会员只有老会员能看。

一个人一个频道记一个“能不能”，是 500 万个开关，而且加一个频道要写 10 万行。社区的做法是**角色**：

1. 社区定几个角色（管理员、版主、老会员……），每个角色一组权限，每个成员有几个角色。
2. 每个频道可以对某个角色、或某个人，额外允许或禁止几项，叫**改写**。
3. 一个人在一个频道能做什么，是**算出来的**：先拿所有人的权限，加上他各个角色的；再在频道上，依次套用对所有人的禁止和允许、对他角色的禁止和允许、对他本人的禁止和允许。

Discord 的开发者文档写的就是这个顺序；权限是一串位，算的时候按位或、按位与；有“管理员”权限的跳过频道上的所有改写（[Permissions](https://docs.discord.com/developers/topics/permissions)）。

20 个角色、50 个频道，改写最多 1,000 条，加上少数针对个人的。把一个频道改成私密，是改一条，不是改 10 万行。

权限用在三个地方：

- **发消息**：第 12 章在取 seq 的事务里查“是不是成员”，这里查“在这个频道有没有发言权限”。
- **推送**：推给订阅者之前，查他能不能看这个频道。每秒 1 万次，每次几次位运算。
- **翻历史**：第 12 章按进群那一刻算“能看哪一段”；社区里改成按权限：能看这个频道、有“读历史”权限，就能看全部。

## 7. 主线的决定：留、改、扔

| 层 | 主线的决定 | 社区 |
|---|---|---|
| 连接 | 网关、在线路由、心跳、准入、账号（20–25） | **留** |
| 消息 | 确认、去重、按会话的 seq、会话的主人、消息日志（3–5、28、29） | **留**，会话换成频道 |
| 分发 | 每条消息改每个成员的会话记录（11） | **扔**：会话记录只记加入了哪些社区 |
| 分发 | 推给每个成员的每台在线设备（16） | **改**：只推给订阅了的；没在看的每分钟最多一帧 |
| 分发 | 离线时每会话每分钟一个通知（17） | **改**：默认只在 @ 我时发 |
| 分发 | 在线状态只告诉在看的人（21） | **留**，只订阅屏幕上那一屏 |
| 存储 | 消息只存一份（6、10） | **留** |
| 存储 | 每人每个会话一个读到哪，精确未读数（14） | **改**：读了才建；加粗加 @ 数 |
| 存储 | 群里点开一条数几人已读（15） | **扔** |
| 业务 | 入群退群占一个 seq，按进群那刻算能看的历史（12） | **改**：只改成员表；能看什么按权限 |
| 业务 | 手机存整份成员名单，带版本号（13） | **改**：按屏、按搜索、按发送者拿 |
| 业务 | 撤回与编辑（18） | **留**：版主删消息是常事 |
| 业务 | — | **加**：角色和频道上的改写 |
| 客户端 | 本地数据库、一套 SDK（7、30） | **留**，只缓存打开过的频道 |

## 8. 代价

- **不在看的人知道得晚。** 社区图标的点最多晚一分钟；哪个频道有新的，要点进来才知道。
- **未读变粗了。** 只有加粗和 @ 数，没有精确数字。没打开过的频道，按“比加入时间晚”判断；可消息的时间是写的时候取的，不等于存好的先后（第 11 章“其他答案”里的那个洞）：Ana 9:00:00 加入，一条消息 8:59:59 取了时间、9:00:01 才存好，它就算在她加入之前，不加粗。对一个点来说无所谓，下一条来了就亮。
- **一起涌进来的读。** 一条公告发出去，几千人同时点开 #公告，读的是同一页。要把相同的读合成一次：Discord 的数据服务就这样做，同一时刻好几个人要同一行，只查一次数据库（[Discord, 2023](https://discord.com/blog/how-discord-stores-trillions-of-messages)）。
- **两条路。** 几千人以下照主线，精确未读、整份名单都留着；过了门槛才走这一章。代码和测试都多一份，一个群长大了要能换过来。Telegram 的公开 API 里也是两种群：普通群最多 200 人，超级群最多 20 万人，群长大了要升级换过去（第 10 章，[Channels, supergroups and groups](https://core.telegram.org/api/channel)）。
- **权限变了要马上生效。** 频道改成私密，订阅名单里没权限的人得立刻停推，手机上的历史也该清掉。
- **订阅名单在一台服务器的内存里。** 一个社区真的有上百万人同时在线，一台装不下，就得再拆（下一节的 relay）。

## 9. 其他答案

- **Discord 的演进。** 早期每个社区一个进程，有事就扇出给每个连着的会话，大社区发一个事件要 0.9 到 2.1 秒（[Discord, 2017](https://discord.com/blog/how-discord-scaled-elixir-to-5-000-000-concurrent-users)）。后来把没点进来的连接单独放一张表，扇出少了 90%；再在社区进程和连接之间加一层 relay，每个带着权限检查扇出给最多 15,000 个会话（[Discord, 2023](https://discord.com/blog/maxjourney-pushing-discords-limits-with-a-million-plus-online-users-in-a-single-server)）。
- **Discord 的读状态**：每人每个频道一个，有几十亿个（[Discord, 2020](https://discord.com/blog/why-discord-is-switching-from-go-to-rust)）。消息按“频道 + 时间桶”分区存（[Discord, 2017](https://discord.com/blog/how-discord-stores-billions-of-messages)）；频道对象上带着最后一条消息的 ID（`last_message_id`），和这一章“频道的最新 seq”一个作用（[Channel](https://docs.discord.com/developers/resources/channel)）。
- **慢速模式**：社区里说话太快时，每人每隔几秒才能发一条。Discord 的频道上有 `rate_limit_per_user`，0 到 21,600 秒（[Channel](https://docs.discord.com/developers/resources/channel)）；和第 34 章的每台设备限速是一回事，只是按人、按频道设。

## 10. 这一章的决定

**决策卡**

- 问题：社区 10 万成员、50 个频道，大多数人不在看。照主线，一条消息要改 10 万行会话记录、查 10 万次路由、推 1 万次；整份成员名单 4 MB；读到哪 500 万行。
- 选择：社区频道只存一份，不给成员写任何东西：推给订阅了这个社区的设备，没在看的每分钟最多一帧；进社区时扫一遍频道的最新 seq。读到哪读了才建，未读只显示加粗和 @ 数；成员名单按屏、按搜索拿；能看、能发由角色和频道上的改写算出来。
- 代价：不在看的人知道得晚；未读不再精确；公告引来同时的读，要合并；小群和社区两条路；权限变化要立刻作用到订阅；订阅名单在一台服务器的内存里。
- 什么时候重新考虑：一个社区上百万人同时在线（再加一层 relay）；直播间，连消息都可以丢（第 41 章）；所有产品放在一张表里（第 45 章）。
- 其他答案：Discord（被动会话、relay、读状态、按频道和时间桶存）；Telegram 超级群（只拉正在看的）；Matrix 成员懒加载；慢速模式。

社区里，大多数人不在看，所以“谁在看推给谁”就够了。下一章的直播间反过来：100 万人同时在看同一个房间，而且每个人都在看。
