0. 开场:先别急着给每条连接开协程
白天在机房给商业服善后,事故很朴素:有人把每条玩家 TCP 连接当成一个 HTTP 请求来写。连接一进来就开协程,协程里查 Redis、等数据库、再回 JSON。200 人同屏放技能,CPU 没先炸,世界主循环先被这些“接口”堵死,客户端人物开始太空步。
晚上看群,又有人问:本地跑得好好的,一上公网就粘包,为什么。我一般先回一句:贴抓包,别贴日志里美化过的 JSON。
Web 那套无状态 CRUD 不是错,错在拿它套游戏专服。浏览器断线可以重试,接口幂等可以补;游戏里一帧的输入、一次技能判定、一个 Buff 层数,全是内存里的活对象,断了就得重同步。TCP 底层也不会按你的 JSON 分条,它只给一条持续到达的字节流 [S4]。
这篇不喊高并发架构口号,按六道底层闸门拆:内存权威、Reactor 与 epoll ET、消息边界、发送背压、应用层心跳、有状态 Drain。每道闸门都对应一次线上翻车。
1. 第一道门:内存不是缓存,是权威世界
Web 服务能无状态水平扩容,是因为请求像一次性事务:进来、查库、改库、返回、上下文销毁。游戏专服不是。玩家连进来,本地堆里生成一个 Entity,坐标、速度、朝向、技能 CD、受击硬直、Buff 层数、碰撞体全挂身上,每一 Tick 直接读写。
flowchart TD
subgraph WebWorld[Web 无状态 CRUD]
W1[浏览器请求] --> W2[负载均衡]
W2 --> W3[无状态 Pod]
W3 --> W4[Redis]
W3 --> W5[MySQL]
end
subgraph GameWorld[游戏专服 强状态]
G1[玩家 A 长连接] --> G3[专服内存世界]
G2[玩家 B 长连接] --> G3
G3 --> G4[Entity 与 AOI]
G3 --> G5[固定 Tick 主循环]
G3 -.-> G6[异步快照持久化]
end
我们项目按 30Hz 跑,一帧 33.3ms。示例预算不是实测:输入消费 4ms,物理与命中判定 10ms,AOI 增量 8ms,广播打包 6ms,留 5ms 给抖动和统计。中间插一次 Redis RTT 或 MySQL 写,物理时钟先崩,后面所有判定都变玄学。这个预算表每次压测都要重新填,别拿别人的数字当护身符。
差别不在用不用 Redis,而在权威状态放哪。Web 侧权威在数据库,Pod 只是中转站;游戏侧权威在专服内存,数据库反而是旁路。排行榜、跨服邮件、离线数据可以走外部存储;战斗帧里的命中结果不能等它回包。这个边界一模糊,压测就会用 OOM 和走位漂移提醒你。
核心循环里禁止阻塞式网络 IO、磁盘 IO、分布式 RPC。持久化走旁路:脏标记、增量快照、下线落盘。玩家对象内存布局也别随便摆,热点字段尽量紧凑;AOI 容器别每帧全量重建,脏位和空间索引分开维护。客户端上报的坐标、速度、Transform 别直接信,进权威世界前先做 isnan 和 AABB 合法性检查;物理帧落盘加 Magic Number 和摘要校验。不然冲量一发散,脏数据直接吞进存档,读档矩阵乘视锥体被 1e+38 干爆黑屏,早会还能脸不红心不跳甩锅显卡驱动 😋。客户端会说谎,权威状态只认服务端这份内存和能回放的输入日志。
2. 第二道门:Reactor 搬字节,主循环解释世界
几千条长连接挂上来,单连接单线程或单协程不是绝对不行,但很容易把上下文切换、锁争用和调度抖动叠满。Reactor 模式的价值在于把 I/O 操作和应用线程拆开,用事件通知把大量连接压到小线程池里处理 [S1]。落到工程上,常见是 Main Reactor 只 accept,Sub Reactor 各自拿 epoll 监听一批 fd,读完、解包、校验,再把业务命令塞进有界队列。世界主循环单线程按 Tick 消费队列,跑逻辑,生成广播。
flowchart LR
C1[客户端连接] --> MR[Main Reactor 只 accept]
MR --> SR1[Sub Reactor 1 读包解包]
MR --> SR2[Sub Reactor 2 读包解包]
SR1 --> Q[有界 RingQueue]
SR2 --> Q
Q --> WL[WorldLoop 单线程按 Tick 消费]
WL --> OB[AOI 增量生成]
OB --> SQ[每连接发送队列]
SQ --> SR1
SQ --> SR2

Reactor 网络模型示意(来源 S1):单 acceptor 多 reactor 把连接事件分发到多个 reactor,与本篇“IO 归 Reactor、世界逻辑归主循环”的职责划分相互印证。 · 图片来源:uRocket - Reactor Networking in C# with iouring,版权归原作者。
这段话里最容易被忽略的是“有界”。队列无界,网络线程读得比主循环快,最后就是内存爆;队列太小,又会在战斗峰值把正常输入拒掉。容量按 Tick 预算和包速率压测,满了要有策略:关键命令保留,低优先级输入合并或丢弃,绝不能把网络线程卡在业务锁上。多个 Sub Reactor 往同一个队列写时,别拿 SPSC 冒充 MPSC;要么分片队列再合并,要么老老实实上 MPSC。
我见过一种写法:网络线程解完包,直接调 player->Move(),里面再去拿世界锁。平时没事,一打团,世界锁被主循环占着,网络线程全部挂起,epoll 事件堆在 ready list 里没人收,客户端 RTT 从 30ms 飙到 800ms。这不是 Reactor 的锅,是你把业务逻辑塞回了 IO 线程。
epoll 本身维护 interest list 和 ready list,ready list 由内核在 fd 有 IO 活动时动态填充 [S2]。别把 epoll 当高性能银弹,它只是事件通知,真正决定吞吐的是你有没有把“搬字节”和“解释世界”分开。
epoll ET 的坑,man page 写得很直 [S2]:ET 只在状态变化时通知;fd 必须非阻塞;收到事件后要一直 read/write 到 EAGAIN;应用还要自己保存“读到一半”的残包。你如果只 read 一次就回去等下一次事件,缓冲区里剩下的数据可能再也没有新事件来提醒。多线程共享同一个 fd 时,还要考虑 EPOLLONESHOT 之类的一次性触发与重新 arm,防止两个线程同时处理同一条连接 [S2]。
/* 伪代码:ET 读循环,工程里还要处理缓冲上限与统计 */
for (;;) {
ssize_t n = recv(fd, tmp, sizeof(tmp), 0);
if (n > 0) {
if (!conn_buf_append(c, tmp, (size_t)n)) {
close_conn(c, REASON_BUF_LIMIT);
break;
}
continue;
}
if (n == 0) {
close_conn(c, REASON_PEER_FIN);
break;
}
if (errno == EINTR) {
continue;
}
if (errno == EAGAIN || errno == EWOULDBLOCK) {
break;
}
close_conn(c, REASON_IO_ERROR);
break;
}
这段代码只干一件事:把内核里的字节搬干净。解包、校验、业务命令入队都在后面。Reactor 只搬字节,不解释技能。业务包进队列之后,时序才真正归世界主循环。这个职责分工不立住,后面所有优化都是补丁摞补丁。
3. 第三道门:协议线序,TCP 没有消息边界
Web 转过来最容易犯的错,是把一次 send 当成一条消息。Linux tcp(7) 明确说 TCP 是可靠字节流,不保留记录边界 [S4];Stephen Cleary 也反复讲,单次 send 不等于单次 recv,应用层必须自己设计 framing [S3]。本地 loopback 测试特别会骗人:机器快、延迟低,看起来一发一收;一上公网、包一大、代理一插,粘包半包全来了。
| 方案 | 工程评价 | 适合场景 |
|---|---|---|
| 定长封包 | 解析简单,但字段一扩就补丁满天飞 | 极简控制命令 |
| 分隔符 | 文本调试舒服,二进制和转义很脏 | 日志、调试协议 |
| 长度前缀 | 主流,能处理变长包,但必须限最大长度 | 游戏长连接 |
游戏长连接我基本只用长度前缀。包头固定 17 字节:magic 两字节、version 一字节、cmdId 两字节、bodyLen 四字节、seq 四字节、checksum 四字节,统一 big-endian。17 字节不是 4/8 字节对齐,这不是省事,是刻意的防线:字段逐字节序列化,不要 #pragma pack 之后直接 memcpy 到 C struct。线序按显式大端写,协议才不跟着编译器和平台漂。
抓包时只认原始十六进制线序,别只看日志框架打印出来的结构体。日志里 bodyLen 是 60,不代表线上就是 60;真正要核对的是 hex 里的 00 00 00 3C:
53 4B 01 00 1F 00 00 00 3C 00 00 00 07 A1 B2 C3 D4 ...
|magic|ver|cmdId |bodyLen |seq |checksum |body...
少一个填充字节、少一个版本位、seq 大小端写反,能让人通宵怀疑人生
。我排查这类问题只信 tcpdump 的 hex,不信日志里被序列化框架美化过的 JSON,也不信“我这边看是 60”。
import struct
import zlib
HEADER = struct.Struct('>2sBHIII') # magic, version, cmdId, bodyLen, seq, checksum
HEADER_SIZE = HEADER.size # 17
MAX_BODY = 64 * 1024
def checksum_ok(magic, version, cmd_id, body_len, seq, checksum, body):
crc = zlib.crc32(magic)
crc = zlib.crc32(struct.pack('>BHII', version, cmd_id, body_len, seq), crc)
crc = zlib.crc32(body, crc) & 0xffffffff
return crc == checksum
def cut_frames(buf, read_off, last_seq):
frames = []
view = memoryview(buf)
total = len(buf)
while total - read_off >= HEADER_SIZE:
magic, version, cmd_id, body_len, seq, checksum = HEADER.unpack_from(view, read_off)
if magic != b'SK' or version != 1:
raise ValueError('bad header')
if body_len > MAX_BODY:
raise ValueError('body too large')
frame_end = read_off + HEADER_SIZE + body_len
if frame_end > total:
break
body = bytes(view[read_off + HEADER_SIZE:frame_end])
if last_seq is not None and seq <= last_seq:
raise ValueError('non-monotonic seq')
if not checksum_ok(magic, version, cmd_id, body_len, seq, checksum, body):
raise ValueError('bad checksum')
frames.append((cmd_id, seq, body))
last_seq = seq
read_off = frame_end
return frames, read_off, last_seq
这段代码有几个工程点。第一,memoryview 避免每次切片复制;第二,read_off 前移而不是 del buf[:total],否则每切一帧搬一次剩余数据,包一多就是 O(n²);第三,seq 单调和 checksum 校验都在交付业务帧前真正调用,不是流程图里画着好看。seq 回绕按协议单独处理,本示例只做单次会话内递增检查。缓冲区该 compact 的时候 compact 一次,别在热路径里反复搬。
stateDiagram-v2
[*] --> WaitHeader
WaitHeader --> WaitHeader: 不足 17 字节 保留残包
WaitHeader --> WaitBody: 缓冲够 17 字节
WaitBody --> WaitBody: 半包 等下一次 EPOLLIN
WaitBody --> WaitHeader: 完整帧 交付并前移 read_off
WaitBody --> BadFrame: magic version bodyLen seq 或 checksum 不合法
BadFrame --> [*]: 记录原始 hex 并断开
最大包长不是可选项。长度前缀如果直接信包里的 bodyLen,恶意客户端发一个超大长度就能把读缓冲撑爆;分隔符方案也能靠“永远不发分隔符”把内存耗干。S3 明确提醒过要做最大消息长度的 sanity check,防的就是这种 OOM DoS [S3]。
checksum 这里只做线序完整性校验,不是身份认证,也不是反外挂。想靠一个 4 字节 checksum 挡住改包,属于自我安慰;真正的反外挂得在服务端做状态校验、输入合理性检查和回放检测。别把传输校验当安全边界。
还有一个工程直觉:客户端预测的回滚窗口别无限攒。迟到输入超过服务端窗口,就不要硬重演,直接拿权威快照推回去重新同步。延迟补偿上限也别为了迁就高延迟玩家无限倒流;先拿 150 到 200ms 当压测起点,按迟到输入分布、p99 RTT 和重演 CPU 成本定窗口,不是行业常数。无脑迁就高延迟战士倒流,低 ping 玩家体验当场火化 😋。这段是调参口径,不挂来源,因为每家帧率和玩法都不一样。
协议版本不认识时,别 silent fallback 去瞎猜字段,走显式兼容模式或明确拒绝,这是 fail-closed,不是 fail-open。
4. 第四道门:发送端背压
收包有边界,发包同样有边界。线上很多“内存缓慢上涨”不是业务泄漏,是某个慢客户端把内核 SNDBUF 塞满,应用层还在无界队列里堆帧。广播场景尤其致命:500 人同屏,每帧全量同步,只要几条连接不 ACK,发送队列就会从几 KB 涨到几百 MB。内核缓冲区不是垃圾桶,send 返回 EAGAIN 也不是让你换个地方继续堆。
先把一个常见误解掐掉:非阻塞 send 返回 EAGAIN,只代表内核发送缓冲区暂时满了,不代表对端掉线;但对一个持续 EAGAIN 的连接,应用层必须有上限和降级策略,不能无限重试。TCP 的发送缓冲区可以通过 SO_SNDBUF 设置,实际分配还会带内核管理开销 [S4],所以你别拿“我设了 64KB”去卡死预算,按压测和内核实际行为来。
每连接必须有独立的发送队列,带字节上限和帧数上限;高水位进入降级,低水位恢复;按优先级丢包。移动增量、旧快照、普通特效可以合并或丢;技能结算、伤害确认、下线指令不能丢。发送失败不要无脑重试,先把连接标成 suspect,必要时让客户端重连走权威重同步。
/* 伪代码:优先级入队 + 水位降级,数值只做示意 */
#define OUTQ_HIGH_BYTES (256 * 1024)
#define OUTQ_LOW_BYTES (64 * 1024)
#define OUTQ_CRITICAL_MAX_BYTES (512 * 1024)
#define OUTQ_MAX_FRAMES 2048
int enqueue_frame(Conn *c, Frame *f, int prio) {
if (c->outq_bytes >= OUTQ_CRITICAL_MAX_BYTES) {
return 0;
}
if (f->len > OUTQ_CRITICAL_MAX_BYTES - c->outq_bytes) {
return 0;
}
if (c->outq_bytes >= OUTQ_HIGH_BYTES) {
c->degraded = 1;
}
if (c->degraded && prio != PRIO_CRITICAL) {
return 0;
}
if (c->outq_frames >= OUTQ_MAX_FRAMES) {
if (prio != PRIO_CRITICAL) {
return 0;
}
if (!drop_lowest_priority(c)) {
return 0;
}
}
push_frame(c, f, prio);
c->outq_bytes += frame_size(f);
c->outq_frames++;
return 1;
}
void on_send_progress(Conn *c) {
if (c->degraded && c->outq_bytes <= OUTQ_LOW_BYTES) {
c->degraded = 0;
}
}
这里先判 outq_bytes 是否已经到硬上限,再做减法,避免无符号回绕。别小看这个顺序,线上真有人把 outq_bytes + f->len 直接和上限比,溢出之后所有包都像“合格”,队列一路堆到 OOM。
stateDiagram-v2
[*] --> Normal
Normal --> Degraded: 发送队列超过高水位
Degraded --> Normal: 回落到低水位
Degraded --> Closing: 关键帧仍堆积或写超时
Normal --> Closing: 对端 RST 或写错误
Closing --> [*]: 断开并提示重连
背压的 fail-open 不是全丢,是分级别保命。低优先级丢了,玩家多一次瞬移;关键结算丢了,整局账本都会错。先把优先级和上限立住,再谈压缩和批处理。还有,低水位恢复别太敏感,高水位进降级、低水位才恢复,中间留滞回区间,否则队列在阈值附近抖,玩家看到的是一会儿流畅一会儿瞬移。
5. 第五道门:应用层心跳,别等 TCP keepalive 两小时
Linux 的 TCP keepalive 默认值很保守 [S4]:空闲 7200 秒才开始探测,间隔 75 秒,最多 9 次,算下来大约 2 小时 11 分才判死;而且只有开了 SO_KEEPALIVE 才会发探测。游戏里等两小时?玩家早换三把了。更坑的是半打开假死:NAT 表项没了、路由黑洞、客户端进程卡死,TCP 层可能还觉得连接在,应用层 write 甚至还能成功一小会儿——那只是写进了内核发送缓冲区,不代表对面收了。你信它,它就在关键结算时给你来一下。
所以游戏长连接必须有应用层心跳。客户端定期 ping,服务端回 pong,顺便采样 RTT;服务端维护 lastRecvTime、lastSendTime、最近 RTT 和丢包窗口。超时阈值别拍脑袋,常见 3 到 5 个心跳周期,这是调参起点,不是标准答案。上线前拿真实弱网数据看 RTT p99、抖动和误判率;超过阈值先进入重连态,不要立刻踢人;网络抖动可以补帧,真掉线必须走权威快照重同步。
心跳包也要走同一套长度前缀、seq 和校验。外挂可以只回 ping 不接业务包,服务端要能识别“心跳正常但业务包长时间迟到”的异常。seq 断裂、RTT 突刺、ping 通但输入不来,这些信号比 TCP keepalive 早得多。心跳不是形式主义,它是时序探针。
再补一句边界:心跳超时先标 suspect、进重连态,这是 fail-open 式的保命;但重连后如果快照版本对不上、会话票据验不过,就必须 fail-closed 拒绝进局,别让一个可疑连接带着旧状态混进来。降级和放行是两件事,别混着写。
6. 第六道门:有状态服务的 Drain,不是收到信号就 kill
游戏专服天然有状态。把无状态 Deployment 那套滚动升级直接套过来,在我们这是事故,不是方案。终止信号一到就掐进程,内存里的 Entity、场景状态、未落盘快照全没了。缩容不是 kill,是 Drain。
这里先把边界划死:不同调度器、容器平台、裸机进程管理器投递终止信号、摘流和宽限期的时序都不一样,按你们那套的官方文档逐条核对;本篇只写应用侧能控制的 Drain 状态机,不替平台背 API,也不拿博客当 API 文档。
flowchart TD
A[终止信号到达] --> B[标记 draining 拒绝新会话]
B --> C[广播下线预警 给客户端重连窗口]
C --> D{本局结算完成}
D -- 否 --> E[等到预算上限 记录未完成局]
E --> F
D -- 是 --> F[冻结世界写入 生成全量快照]
F --> G[写临时文件 fsync 并校验 magic version seq digest]
G --> H{校验通过}
H -- 否 --> I[保留旧快照 告警 拒绝覆盖]
H -- 是 --> J[原子替换快照]
J --> K[下发重连指令 关闭 Socket]
K --> L[flush 日志与指标 退出]
流程拆细:
- 终止信号到达,应用先置 draining=true,拒绝新会话。平台侧摘流和这个标记怎么配合,按你们自己的运行手册来,不在这里背平台语义。
- 广播下线预警,给客户端准备重连窗口。别等 Socket 快断了才发,客户端来不及切。
- 等本局结算、关键帧、技能 CD 和战斗状态收敛;超过预算就记录未完成局,不要无限等。
- 冻结世界写入,生成全量快照,写临时文件,fsync,校验 Magic Number、版本号、序列号和摘要。
- 校验通过才原子替换快照;校验不过就保留上一份好盘并告警,这是 fail-closed,不是 fail-open。
- 给客户端下发重连指令,再关 Socket。
- flush 日志和指标,进程退出。
预算别抄固定数字。大世界场景把 600 到 900 秒当压测假设,按快照 p99、单局结算 p99、摘流传播余量、退出 flush p99 加出来,不是平台标准,也不是行业常数。小局可能几十秒就够,大世界可能还不够;上线前用演练和压测把每一项填实。平台侧固定身份、服务发现、存储卷生命周期这些细节也不在这篇展开,照你们集群版本官方文档逐条过。
快照的边界要特别小心:校验没过,就不能覆盖上一份好盘。宁可保留可用快照并告警,也不能拿脏数据继续跑。协议解析可以显式兼容,背压可以分级降级,但快照落盘这种写权威状态的操作,必须 fail-closed。
补充一句测量口径:心跳的 3 到 5 个周期、延迟补偿的 150 到 200ms、Drain 的 600 到 900 秒,都只是调参起点或压测假设,不是行业标准。上线前拿真实弱网和演练数据填:看 RTT p99、抖动、误判率、迟到输入分布、重演 CPU 成本和快照 p99。数字对不上,就改参数,别改日志。
7. 收尾
从 Web 到 Socket,最该换掉的不是框架,是“请求用完即抛”的直觉。游戏专服的权威在内存,IO 归 Reactor,世界归主循环;TCP 只给字节流,消息边界要自己画;发送队列没上限,慢客户端就能把服务器拖进 OOM;keepalive 太慢,心跳才是时序探针;有状态服务缩容,Drain 顺序和快照校验错一步都可能团灭。
先立闸,再谈优化。抓包看原始 hex,时序异常别信客户端,fail-open 也要有边界,该 fail-closed 的地方别手软。真炸服那天,能救你的不是漂亮架构图,是这些看起来土但掐得死的底层约束 😋。
参考资料
- [S1] uRocket - Reactor Networking in C# with io_uring: https://dev.to/mda2av/urocket-reactor-networking-in-c-with-iouring-1j95
- [S2] epoll(7) - Linux manual page: https://man7.org/linux/man-pages/man7/epoll.7.html
- [S3] Message Framing: https://blog.stephencleary.com/2009/04/message-framing.html
- [S4] tcp(7) - Linux manual page: https://man7.org/linux/man-pages/man7/tcp.7.html
参考资料
- [S1] https://dev.to/mda2av/urocket-reactor-networking-in-c-with-iouring-1j95(读取于 2026-11-14)
- [S2] https://man7.org/linux/man-pages/man7/epoll.7.html(读取于 2026-11-14)
- [S3] https://blog.stephencleary.com/2009/04/message-framing.html(读取于 2026-11-14)
- [S4] https://man7.org/linux/man-pages/man7/tcp.7.html(读取于 2026-11-14)
评论 (0)