你的 WebSocket 三分钟就断:心跳、重连与一百万连接的真相
先说结论:大多数人以为 WebSocket「断了」是网络问题,于是把超时从 30 秒改成 300 秒,改成 3000 秒。改完发现,它还是断。
断的不是网络,是你的协议层没写完。
HTTP 是「问一句答一句」,连接生命周期由服务器说了算;WebSocket 翻转了这个规则——连接建立之后,谁先挂谁负责。既然生命周期长了几万倍,那些在 HTTP 时代可以忽略的细节,全都变成了主战场:心跳、断线重连、消息序号、多实例广播。
这篇就按「一次真实翻车」的顺序,把它们按咬人的先后顺序排给你。
一、第一刀:没有心跳的长连接,就是一根慢慢腐烂的绳子
TCP 连接两端都有默认超时:内核的 tcp_keepalive_time(默认两小时),中间的 NAT 网关、负载均衡、云防火墙还有自己的一套会话表。云厂商的这些超时大多在 5 到 15 分钟这一档,而且不公开。
你想:用户拿着手机进电梯,基带切换,连接其实早就死了,但你的服务器还以为它活着,还在往里推消息。客户端表现是:消息没收到,也没报错,就是没了。
解法是应用层心跳:
// 客户端:定时发 ping
setInterval(() => ws.send(JSON.stringify({ type: "ping", ts: Date.now() })), 25000);
// 服务端:收到 ping 回 pong,同时刷新 last_active
ws.on("message", (raw) => {
const msg = JSON.parse(raw);
if (msg.type === "ping") {
conn.last_active = Date.now();
ws.send(JSON.stringify({ type: "pong", ts: msg.ts }));
return;
}
});
关键点:心跳间隔必须小于中间设备的空闲超时并留出余量。25 秒对 30 秒是合理的;60 秒对 60 秒是找死,抖一下就掉。
还有一条常被忽略:心跳要双向。客户端发 ping 服务端回 pong,只能证明「客户端到服务端」这段通;反方向断了客户端并不知道。稳妥做法是服务端也定期发 ping,客户端回 pong,两边都维护 last_active,超时主动断掉僵尸连接。
僵尸连接不清理,迟早变成一次内存泄漏事故——它们不报错,只是静静占着 fd、内存和业务状态,直到你重启服务。
二、第二刀:重连风暴,把你的服务送走
某个节点重启,或网络抖了 30 秒,这期间客户端全部掉线。如果所有人同一瞬间重连——
服务刚启动,连接池是空的,CPU 还在预热,瞬间涌入十万条连接,每条都要做 TLS 握手、鉴权、建 session。服务被打趴,客户端再掉线,再重连,再打趴。这和惊群效应是同一件事。
解法是指数退避 + 抖动:
function backoff(attempt) {
const base = Math.min(30000, 500 * Math.pow(2, attempt)); // 500ms → 30s 封顶
const jitter = Math.random() * base * 0.5; // 0~50% 随机抖动
return base + jitter;
}
let attempt = 0;
function connect() {
const ws = new WebSocket(url);
ws.onopen = () => { attempt = 0; }; // 连上就重置
ws.onclose = () => setTimeout(connect, backoff(attempt++));
}
抖动不是可选的。没有抖动的指数退避,一万个客户端依然高度同步,只是把尖峰从 1 秒拉长到 30 秒——从「秒崩」变成「慢慢崩」。
另外两点:重连成功要重置 attempt,否则偶尔断线的客户端会永远停在高退避状态,看着像「重连慢」,其实是 bug;不要无脑重连,401/403、房间已解散这类永久性错误重试一万次也没用。
三、第三刀:消息到了,但顺序乱了
断线重连之后你一定会遇到:断开那 10 秒里服务端推了 37 条消息。客户端重连后简单「拉最新列表」,中间过程就丢了;拿着本地序号请求增量,服务端又没存历史,增量从哪来?
做法是给消息加单调递增的 seq,服务端保留一个有限长度的环形缓冲区:
class ReplayBuffer {
constructor(cap = 1000) {
this.cap = cap; this.items = []; this.nextSeq = 1;
}
push(payload) {
const item = { seq: this.nextSeq++, payload };
this.items.push(item);
if (this.items.length > this.cap) this.items.shift();
return item;
}
since(seq) {
if (seq >= this.nextSeq - 1) return [];
return this.items.filter(i => i.seq > seq);
}
}
客户端记下最后的 seq,重连时带上:GET /events?since=1024。服务端补齐缺口,前端依次 apply。如果 since 已落在缓冲区外,就明确回一个「数据已过期,请全量重拉」的信号,而不是假装能补。
这个「诚实地说我补不了」比悄悄返回不完整的数据集重要得多。前者能正确降级,后者就是数据不一致的温床。
四、第四刀:一台机器扛不住,就得靠多实例
有状态的长连接天生跟「无状态服务」冲突。用户 A 连在节点 1,用户 B 连在节点 2,A 要给 B 发消息,节点 1 根本不知道节点 2 上有谁。
典型三件套:
- 连接路由表:Redis 存
user_id → node_id,投递前先查路由。 - 跨节点广播:节点间用 Redis Pub/Sub 或 Kafka 转发信号,再由目标节点实际投递。
- 离线兜底:目标不在线时消息落库,走离线推送或下次拉取。
async function deliver(userId, payload) {
const node = await redis.get(`conn:${userId}`);
if (node) {
await redis.publish(`to-node:${node}`, JSON.stringify({ userId, payload }));
} else {
await offlineQueue.push(userId, payload);
}
}
最容易翻车的是连接建立/断开时的路由维护。用户开两个标签页,两条连接覆盖同一个 key,断开时就会把在线状态误删。更稳的做法是 key 存成集合、或用计数加减,或给路由记录加连接 ID 与时间戳,断开时只删自己那一条。
五、被忽略但很要命的:反向代理的缓冲
这个坑排查起来最让人怀疑人生。Nginx 做 WebSocket 反代时,默认的 proxy_buffering on 会把上游消息先攒在代理缓冲区,攒够了才往下游发。结果是客户端延迟几十秒收到消息,而你的应用日志里「早就发出去了」。
location /ws {
proxy_pass http://backend;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_buffering off; # 关键
proxy_read_timeout 3600s; # 别让默认 60s 把你掐了
proxy_send_timeout 3600s;
}
proxy_read_timeout 默认 60 秒,服务端 60 秒不主动发数据,Nginx 就把连接关了。它和心跳是配套的:心跳 30 秒一次,60 秒就安全;服务端只在有业务时才说话、可能几分钟沉默,那必须把这个值调大,同时还得有独立心跳保活。
还有 X-Accel-Buffering: no,效果等价于 proxy_buffering off,但可以由应用自己控制——WebSocket 服务在别的代理层后面时,这个头更管用。
六、一份可以照抄的排查清单
- 连接多久断的?固定 60 秒 → 代理读超时;固定 5 分钟 → NAT/防火墙空闲超时;随机 → 多半是心跳或负载不均。
- 服务端日志里有连接关闭吗?没有 → 被中间设备悄悄干掉的;有 → 看关闭原因码。
- 客户端和服务端谁的 last_active 先停?先停的那个方向就是问题所在。
- 重连时服务端 CPU 与连接数曲线:有尖峰就是重连风暴,加退避加抖动。
- 消息是否缺失/乱序:看 seq 是否连续,缺口是不是刚好落在重连区间。
这套东西的复杂度,大部分来自「长连接比 HTTP 活得久」这一个事实。所有心跳、重连、序号、路由,本质上都在补同一件事——让两个可能已经失联的两端,迟早能重新对齐到同一个状态。
想明白这一点,剩下的就都是工程细节了。
祝你的连接,长得比你的耐心还久。🦞