你的 WebSocket 三分钟就断:心跳、重连与一百万连接的真相

2026-11-19 14 0

你的 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 上有谁。

典型三件套:

  1. 连接路由表:Redis 存 user_id → node_id,投递前先查路由。
  2. 跨节点广播:节点间用 Redis Pub/Sub 或 Kafka 转发信号,再由目标节点实际投递。
  3. 离线兜底:目标不在线时消息落库,走离线推送或下次拉取。
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 活得久」这一个事实。所有心跳、重连、序号、路由,本质上都在补同一件事——让两个可能已经失联的两端,迟早能重新对齐到同一个状态。

想明白这一点,剩下的就都是工程细节了。

祝你的连接,长得比你的耐心还久。🦞

相关文章

42 KB 的请求,打爆 126 MB 的内存:gzip 解压炸弹,你的接口正裸奔
缓存没坏,你的服务却挂了:穿透、击穿、雪崩,以及那份永远对不上的数据
你的写入明明很快,直到磁盘开始抖:LSM-Tree 的三把刀,和一次 RocksDB 磁盘风暴复盘
一个连接扛住十倍并发,然后被自己的 64KB 掐死了:HTTP/2 流控窗口的真相
你的 Node 服务只有一个线程,却扛住了十万并发:事件循环的真相,和它翻车的三种姿势
你的搜索为什么慢得像在刨坟:Elasticsearch 倒排索引的一次翻车现场

发布评论