# 第 22 章：百万连接

> 一条什么也不传的连接占多少内存？100 万条连接，要几台网关？

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

第 20 章把连接拆进了网关。v3 高峰有 100 万条连接，大多数时候一个字节也不传，可每一条都占着内存。

这一章回答一个问题：**一台网关放多少条连接**，所以要几台。

## 1. 一条空闲连接占多少

全书的假设，一条什么也不传的连接：

| 项 | 大小 | 是什么 |
|---|---|---|
| 栈 | 8 KB | 每条连接一个 goroutine（Go 的轻量线程）等着读。它从 2 KB 起步，跑过 TLS 握手这类深一点的调用会长大，这里按 8 KB 算 |
| 读缓冲 | 4 KB | 从连接里读字节用的 |
| 写缓冲 | 4 KB | 往连接里写字节用的 |
| TLS | 10 KB | 加密状态和它自己的收发缓冲 |
| 内核 | 4 KB | 操作系统里这条 TCP 连接的记录和缓冲 |
| **合计** | **30 KB** | |

100 万条就是 **30 GB**。这些数是为举例选的整数，真实的数看语言和库。Go 1.4 把 goroutine 的初始栈从 8 KB 降到了 2 KB（[Go 1.4 发布说明](https://go.dev/doc/go1.4)）；OpenSSL 说它的一个开关能让每条空闲连接省下约 34 KB（[SSL_CTX_set_mode](https://docs.openssl.org/3.0/man3/SSL_CTX_set_mode/)），可见 TLS 那一项可大可小。

注意哪些项是**空闲时也要的**：只有内核那一项和 TLS 的密钥。栈和缓冲，都是为“有数据来了”准备的，大部分时间闲着。

## 2. 先想到的：一台尽量多放

机器越少越好管。一台网关给连接留 16 GB，16 GB ÷ 30 KB，能放 **53 万条**。两台就装下了全部 100 万。

这不是空想。WhatsApp 2012 年在一台 24 核、103 GB 内存的服务器上撑过了 200 万条 TCP 连接（[WhatsApp 博客](https://blog.whatsapp.com/1-million-is-so-2011)）；Phoenix 框架 2015 年在一台 40 核、128 GB 的机器上连了 200 万个 WebSocket 客户端（[Phoenix 博客](https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections)）。

可一台网关不只是装着连接。它还要推送，还会重启。

## 3. 哪个先满

把一台网关上的连接从 0 往上加，看三样东西。全书假设一台网关每秒能推 50,000 次。

- **内存**：每条 30 KB，到 **53 万条**满。
- **高峰的推送**：v3 高峰每秒 13,900 条消息，每条平均推给 10 台设备，就是每秒 139,000 次推送；分到 100 万条连接上，每条每秒 0.139 次，到 **36 万条**推不过来。
- **突发的推送**：第 29 章的突发，消息是全天平均（每秒 4,630 条）的 10 倍，持续一分钟；每条消息推 10 次，就是每秒 463,000 次推送，每条连接每秒 0.463 次。到 **11 万条**就满了。

内存是最后一个满的。

还有一样不是“满”，而是**一次断多少人**。网关会重启，会挂。一台放 10 万条，挂了断开在线的 10%；放 53 万条，断开一半多。断开的人都要重新握手，一台每秒握 2,000 次，10 万条要 50 秒，53 万条要 4 分多钟（怎么让别的网关分担，第 24 章）。

## 4. 决定：每台 10 万条

每台网关最多放 **10 万条**，正好在突发的那条线下面：

- 100 万条连接，要 **10 台**。
- 再假设同一个地区有两个**可用区**（电源和网络互相独立的两组机房），一个整个坏掉时，另一个要扛下所有人：两边各 10 台，共 **20 台**。

平时每台 5 万条；一个可用区坏了，剩下的每台 10 万条：

| 每台连接数 | 内存 | 高峰推送 | 突发推送 |
|---|---|---|---|
| 5 万（平时） | 1.5 GB | 每秒 6,950 | 每秒 23,150 |
| 10 万（坏了一个区） | 3 GB | 每秒 13,900 | 每秒 46,300 |

一台网关每秒推 50,000 次，留 16 GB 给连接。最坏的时候，推送用到九成多，内存用不到五分之一。

这些数都来自这一章假设的那台机器。到底放多少，看具体的机器：换一台机器，先量它每秒能推多少、能握多少次手、能给连接留多少内存，再按上面同样的办法算，取最先碰到的那条线，再按“坏一个区”留出一半。后面各章说“一台网关”，指的就是这台假设的机器：平时 5 万条，最多 10 万条。

所以在这个规模，**每条 30 KB 不是问题**，不用为省内存改代码。公开的资料里也有这样定的：百度的一篇文章写到，它的统一长连接服务把每个实例的连接数控制在 10 万到 20 万，“避免单个实例支持连接数过多，实例发生服务抖动时，对整个集群服务产生较大影响”（百度Geek说，glstr，“千万级高性能长连接Go服务架构实践”，[即时通讯网转载](http://www.52im.net/thread-4623-1-1.html)）。开源实时消息服务 Centrifugo 的文档建议得更保守：“we suggest not putting more than 50-100k clients on one node - but you should measure for your use case”（一般建议一个节点不超过 5 万到 10 万个客户端，但要按自己的情况实测；[Centrifugo FAQ](https://centrifugal.dev/docs/faq)）；另一头是第 2 节的 WhatsApp 和 Phoenix，一台 200 万。

## 5. 想把网关做大时，先省哪一项

如果推送的能力上去了（核多了、推送合并了），想一台放 50 万、100 万条，内存就成了下一道墙。能省的都是“空闲时用不着”的那几项，按改动从小到大：

| 步骤 | 省 | 每条剩 | 100 万条 | 代价 |
|---|---|---|---|---|
| 读写缓冲用时才从池里取，用完放回 | 8 KB | 22 KB | 22 GB | 小：多一个池；突发时所有连接一起要缓冲，池会一下子变大 |
| TLS 空闲时放掉收发缓冲 | 8 KB | 14 KB | 14 GB | 看 TLS 库：OpenSSL 有现成的开关，有的库没有，只能换库 |
| 不给空闲连接留 goroutine：用 epoll（Linux 一次盯住很多条连接的办法）等有数据可读，再从池里取一个去处理 | 8 KB | 6 KB | 6 GB | 大：代码从“一条连接一段顺序代码”变成事件循环，难写、难查 |

（TLS 那一步假设放掉缓冲后剩 2 KB 的状态。）剩下的 6 KB，内核和 TLS 密钥，空闲时也省不掉。

公开的例子里，Mail.Ru 的一篇文章（Sergey Kamardin，2017）给 300 万条连接算过：每条连接两个 goroutine 的栈、各 4 KB 的读写缓冲、标准库 HTTP 服务留下的缓冲，“什么都还没做”就是 72 GB，每条约 24 KB；他们用 epoll 等可读、缓冲和 goroutine 都从池里取，把这些大部分省掉（[A Million WebSockets and Go](https://www.freecodecamp.org/news/million-websockets-and-go-cc58418460bb/)）。

goroutine 多了还有一笔：Go 的垃圾回收要扫它们。百度那篇文章说，按常用的模型每条连接两个 goroutine，一个实例 100 万条连接就是 200 万个 goroutine，连接又建得频繁，“给服务的 gc 带来巨大的压力”；它把写的那一半改成一个共用的“下行任务组”。

## 6. 一行配置

每条连接在系统里算一个打开的文件，一个进程 10 万条，就要 10 万个以上的文件描述符。Linux 默认的软上限常是 1,024，要在 systemd 里调高；Go 1.19 起会自己调高软上限（第 2 章）。今天它只是一行配置，真正的限制还是上面那几样。

## 7. 代价

- **机器多。** 20 台网关，平时每台只用了十分之一的内存。多出来的机器，换的是一台出事只断 5% 到 10% 的人。
- **余量是给坏日子留的。** 平时推送只用到一成多；要等一个可用区坏了、又赶上突发，才用到九成多。
- **这些数要自己量。** 30 KB、每秒 50,000 次推送、每秒 2,000 次握手，都是全书的假设；换一门语言、一个 TLS 库，最先满的可能就换了一样。

## 8. 其他答案

- **少数几台大机器。** WhatsApp 一台 200 万条连接；Phoenix 一台 200 万个客户端（第 2 节）。机器少、好管，代价是一台挂了断的人多，要省内存的那几步都得做。
- **很多台小实例**，每台 10 万到 20 万条（百度，第 4 节）。也是这一章的选择。
- **一条连接一个 goroutine，还是事件循环。** 前者代码好写，空闲时也占着栈；后者省内存，代码难写（第 5 节）。

## 9. 这一章的决定

**决策卡**

- 问题：100 万条连接要几台网关？一条空闲连接约 30 KB，一台 16 GB 能装 53 万条；可推送和一次重启断开的人数，比内存先到上限。
- 选择：每台最多 10 万条（十倍突发时推送仍在每秒 50,000 次以内，一台挂了最多断 10%）：10 台，两个可用区共 20 台。内存只用到 3 GB，先不为省内存改代码。
- 代价：机器多、平时很闲；余量要留给可用区故障加突发的日子；这些上限都要自己量。
- 什么时候重新考虑：推送能力上去、想把网关做大时，按顺序省：缓冲池、TLS 空闲缓冲、事件循环；心跳的开销（第 23 章）；重启时的重连风暴（第 24 章）；过载时慢的连接（第 34 章）。
- 其他答案：少数大机器（WhatsApp、Phoenix 各一台 200 万）；很多台小实例（百度，每台 10 万到 20 万）；一条连接一个 goroutine，还是事件循环。

100 万条连接大多数时候不说话。可不说话的连接，可能早就断了，网关还不知道。下一章：心跳。
