一个连接扛住十倍并发,然后被自己的 64KB 掐死了:HTTP/2 流控窗口的真相

2026-11-18 16 0

HTTP/2 最被吹上天的特性,是"多路复用":一个 TCP 连接上跑几十个流,不用再为每个请求开一条连接,握手省了、慢启动省了、端口也省了。听起来像一场彻头彻尾的胜利。

然后你上线了,压测一打,吞吐死活卡在某个数字上不上去。CPU 空闲率 60%,GC 没压力,QPS 像撞到了一面看不见的墙。监控上只能看到 "连接数 1、活跃流 87",一切看起来都很健康。

这面墙叫 流控窗口。HTTP/2 的流控机制,翻译成人话就是:服务器只能往客户端发 64KB,多一个字节都不给,直到客户端举手说"我吃下了,再给点"。

这篇就把这个坑从头挖到底。

一、多路复用的代价:窗口是按"流"算的,不是按"连接"算的

HTTP/1.1 没有流的概念,只有一个字节流和一个 TCP 接收窗口。HTTP/2 把它拆成了两层:

  • 流级窗口(Stream-level):每一个 Stream 独立拥有一个窗口,默认 65535 字节。
  • 连接级窗口(Connection-level):整个连接共享一个窗口,默认也是 65535 字节。

连接级窗口才是真正的总闸门。哪怕你开了 100 条流,每条流各自能塞 64KB,整个连接在同一时刻最多只能"欠着" 64KB 未确认的数据。

WINDOW_UPDATE 帧长这样:

+-----------------------------------------------+
|                 Length (24)                   |
+---------------+---------------+---------------+
|   Type (8)    |   Flags (8)   |
+-+-------------+---------------+-------------------------------+
|R|                 Stream Identifier (31)                      |
+=+=============================================================+
|                    Window Size Increment (31)                   |
+---------------------------------------------------------------+

注意那个 31 位和 0x80000000 的保留位:单次增量最大是 231-1 字节。你不能靠"一次性把窗口加到 1GB"来解决问题,只能靠高频地、一格一格地加。

而 SETTINGS_INITIAL_WINDOW_SIZE(0x4)只影响流级窗口,而且只对新创建的流生效。这地方埋的坑比想象的多:

你在服务端调完 SETTINGS,客户端已经建好的那些流,窗口还是老的 64KB。一个都没变。

二、64KB 是怎么变成 1KB/s 的

先算一笔账。带宽时延积(BDP)是窗口必须覆盖的下限:

BDP = 带宽 × RTT

例 1:100Mbps × 30ms  = 375 KB
例 2:1Gbps   × 50ms  = 6.25 MB
例 3:10Gbps  × 20ms  = 25 MB

HTTP/2 的默认 64KB,对例 1 都已经是 6 倍超发,对例 2 是 100 倍超发。超发的意思是:你要 等 100 个 RTT 才能把一个 BDP 的数据搬完。这不是"稍慢一点",这是把带宽利用率按住了。

更阴的地方是延迟形态。窗口耗尽时,链路进入"发 64KB → 等 WINDOW_UPDATE → 再发"的循环,而 WINDOW_UPDATE 什么时候到?取决于对端什么时候把数据读走、什么时候调度到发送。这中间任何抖动(GC、慢日志、磁盘 fsync、跨机房)都会让等待时间被放大。

所以你在监控上看到的典型症状是:

  • 平均延迟还行,P99 呈阶梯状毛刺,一个台阶一个台阶往上垒;
  • 单流吞吐上不去,但并发流数一多总吞吐又"看起来正常"——因为多流把连接级窗口轮转着填满了,掩盖了问题;
  • CPU 大量空闲,QPS 却上不去,因为大家都在等窗口。

这就是它最恶心的地方:并发一高,症状自动消失。测试环境 50 并发是好的,生产 500 并发才炸——而你会归咎于"生产流量太大"。

三、怎么把它调到"够用"

先说结论:窗口要按 BDP 的 2 倍以上给,而不是拍脑袋给个 64MB。给太大也有代价——接收端要缓存这么多数据,内存涨;而且一旦对端是坏客户端,恶意发大响应能把你打爆。

以 gRPC 为例,官方给了两个独立的参数,很多人只调了一个,然后对着另一个挠头:

// Go:流级窗口 & 连接级窗口,必须一起调
srv := grpc.NewServer(
    grpc.InitialWindowSize(4 * 1024 * 1024),  // 每条 stream
    grpc.InitialConnWindowSize(16 * 1024 * 1024), // 整个连接
)
// 缺了第二个,你调再大的流级窗口也没用,连接总闸门还是 64KB
# Nginx 作为反向代理时
proxy_http2 on;
proxy_buffering off;          # 关掉缓冲,否则窗口调大也没意义
proxy_request_buffering off;

# 单个 upstream 连接的流控
http2_chunk_size 16k;         # Nginx 侧 SETTINGS_INITIAL_WINDOW_SIZE

Node 侧也有个坑:

// node:http2 的服务端
const server = http2.createServer();
server.settings = {
  initialWindowSize: 4 * 1024 * 1024,  // 流级
};
// 注意:连接级窗口 Node 的 API 不直接暴露,
// 只能靠对端发 WINDOW_UPDATE 慢慢撑开

最后一条才是真相所在:连接级窗口理论上没有"设置"这一说。协议规定它只能由接收方通过 WINDOW_UPDATE 帧递增。所以"我在服务端把连接窗口设成 16MB"这种话,多半是幻觉。你能改的只是流级窗口,连接级窗口得对端配合。

四、怎么证明是它干的

别猜,抓包。三步:

1. 抓 HTTP/2 帧(用 nghttp2 -v 或 Wireshark 的 HTTP2 解析)
2. 统计 WINDOW_UPDATE 的发送间隔与增量
3. 观察模式:连接长时间没有 WINDOW_UPDATE,
   而应用层却在持续 read → 窗口耗尽,实锤

关键信号有三个:

  • SETTINGS_INITIAL_WINDOW_SIZE 帧里是 65535 → 对方根本没调;
  • WINDOW_UPDATE 增量很小(比如每次 +16KB)→ 对方在"挤牙膏",典型是没意识到要调;
  • WINDOW_UPDATE 间隔超过一个 RTT 的两倍 → 接收端被 GC 或慢 IO 拖住了。

如果抓包发现窗口很大、增量也正常,但吞吐依然上不去,那问题就不在 HTTP/2,去查 TCP 层的窗口和 buffer。那是另一个故事了。

五、别把 HTTP/2 的队头阻塞和流控搞混

HTTP/2 消除了应用层的队头阻塞:一条流上的大响应不会挡住另一条流。但它没有消除 TCP 层的队头阻塞——丢一个包,整条连接的所有流都得等重传。

所以你会遇到一个尴尬的组合:流控窗口调到 64MB 后,HTTP/2 层的限制消失了,但跨公网的丢包让 TCP 层又卡住了。这时候该换的是 QUIC(基于 UDP,每流独立重传),而不是继续调窗口。

而如果你的服务在同机房、零丢包、RTT 极低(比如 0.2ms),那 HTTP/2 的流控几乎不会成为瓶颈——反过来,把窗口调太大反而浪费内存。这种环境下默认 64KB 反而是合理的。

所以调参这件事的答案永远是"看你的 BDP",不是"看别人的博客"。

六、一份可以直接抄的清单

  1. 算出你的 BDP:带宽 × RTT,乘 2 作为窗口下界;
  2. 流级窗口和连接级窗口一起调,只调一个等于没调;
  3. 确认 SETTINGS 是在建流之前发的,且对已存在的流无效;
  4. 抓包验证 WINDOW_UPDATE 的频率和增量,别相信配置文件;
  5. 代理层(Nginx/Envoy)记得关掉多余的 buffering;
  6. 如果 P99 还是阶梯状毛刺,且窗口已足够大 —— 去查 GC 和 TCP,别在 HTTP/2 上死磕。

说句实在话:多路复用让我们告别了 HTTP/1.1 那种"开 200 条连接烧光文件描述符"的狼狈,但它换来的不是免费午餐,而是一个藏在协议深处、需要你亲手去调的窗口。

HTTP/1.1 的队头阻塞很吵,一眼就能看出来。HTTP/2 的流控很安静,它只是让你的服务在你看不见的地方,安静地等着。

这大概是工程里最常见的一种慢性病:不报警、不崩溃、日志干净,只是一直比你以为的慢那么一点。而我们花了多少时间在"重写一遍"和"扩容"上,却从来没想过抬头看一眼那 4 个字节的 SETTINGS。

相关文章

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

发布评论