操作系统 / 系统课时

控制 Nagle 与小包发送延迟

控制 Nagle 与小包发送延迟

小请求并不一定在 send() 返回后立刻变成 TCP 段。本节用 Linux TCP 选项和抓包观察 Nagle 对连续小写入的影响,区分 TCP_NODELAY 与 TCP_CORK,并在低延迟和包效率之间做选择。

学习目标

  • 解释 Nagle 为什么会让连续小写入等待 ACK。
  • 使用 TCP_NODELAY 与 TCP_CORK 控制发送策略,并验证选项状态。
  • 根据交互延迟、消息拼装方式和带宽效率选择合适策略。

小包为什么会被延后

Nagle 的目标不是“固定等待一段时间”,而是在连接已经存在未确认数据时,尽量不要继续发送新的微小 TCP 段。若后续写入不足以形成可发送的大段,它可能先留在发送队列中,直到已有数据被确认或满足发送条件。

这也是为什么 Nagle 与对端的 ACK 策略叠加时,交互式协议更容易感到抖动:发送端等 ACK 再发小数据,而接收端又可能短暂延迟 ACK。它不是每次都发生,因此不能只用一次本机延迟测试下结论。

Nagle、TCP_NODELAY 与 TCP_CORK 的发送时序对比

TCP_NODELAY 关闭 Nagle,适合 RPC、终端交互、游戏控制消息等“尽快发出比减少小包更重要”的场景。它并不保证“一次 send() 对应一个 TCP 包”,因为分段、合并、TSO/GSO 和接收端处理仍可能改变你在抓包或 recv() 中看到的边界。

验证 TCP_NODELAY 与 TCP_CORK

下面的 Linux Python 程序建立一条回环 TCP 连接,按 default、nodelay、cork 三种模式发送 A、B、C。程序本身验证 socket 选项;真实发包时序应配合抓包观察,而不能根据服务端 recv() 次数推断。

python
import argparse
import socket
import threading
import time

HOST = "127.0.0.1"
PORT = 19090

def run_server(ready):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
        server.bind((HOST, PORT))
        server.listen(1)
        ready.set()
        conn, _ = server.accept()
        with conn:
            data = bytearray()
            while True:
                chunk = conn.recv(1024)
                if not chunk:
                    break
                data.extend(chunk)
            print(f"server bytes={bytes(data)!r}")

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("mode", choices=["default", "nodelay", "cork"])
    args = parser.parse_args()

    ready = threading.Event()
    thread = threading.Thread(target=run_server, args=(ready,))
    thread.start()
    ready.wait()

    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client:
        client.connect((HOST, PORT))

        if args.mode == "nodelay":
            client.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        elif args.mode == "cork":
            client.setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 1)

        for part in (b"A", b"B", b"C"):
            client.sendall(part)
            time.sleep(0.02)

        # CORK 模式必须主动解除,才把待发送数据及时推出。
        if args.mode == "cork":
            client.setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 0)

        nodelay = client.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY)
        cork = client.getsockopt(socket.IPPROTO_TCP, socket.TCP_CORK)
        print(f"client mode={args.mode} nodelay={nodelay} cork={cork}")
        client.shutdown(socket.SHUT_WR)

    thread.join()

if __name__ == "__main__":
    main()

预期输出如下;三字节内容应一致,选项值随运行模式变化。

text
client mode=cork nodelay=0 cork=0
server bytes=b'ABC'

cork=0 是因为程序在读取选项前已经显式解除 TCP_CORK。改用 nodelay 运行时,nodelay=1;默认模式下两个选项都为 0。

用抓包判断真实效果

在一个终端抓取回环接口,另一个终端分别运行三种模式。抓包中的时间戳、序列号和分段大小取决于内核、网卡卸载与调度,因此关注“数据段何时出现、是否明显聚合”,不要要求固定包数。

bash
sudo timeout 3 tcpdump -i lo -nn -tt tcp port 19090

预期输出形态如下,实际 <TIME>、<PORT>、序列号和长度会不同。

text
<TIME> IP 127.0.0.1.<PORT> > 127.0.0.1.19090: Flags [S], ...
<TIME> IP 127.0.0.1.<PORT> > 127.0.0.1.19090: Flags [P.], ... length <BYTES>
<TIME> IP 127.0.0.1.19090 > 127.0.0.1.<PORT>: Flags [.], ...

若本机启用了 TSO/GSO/GRO,回环抓包看到的段形态可能与真正上线路径不同。要评估生产延迟,应在接近真实 RTT 和负载的环境中重复观察。

什么时候用哪一个

TCP_NODELAY 适合低延迟、双向频繁交互且单次消息较小的协议;代价是更容易产生小段,增加协议头和处理开销。对已经自行批量编码、一次写入就较大的应用,开启它通常不会带来明显收益。

TCP_CORK 更适合“先写头部、再写正文,最后一起推出”的发送模式,例如动态拼装 HTTP 风格响应或文件头加文件体。它的关键不是长期保持开启,而是围绕一次消息显式 cork、写入、uncork;若只想提示某一次 send() 后面还有数据,可考虑 Linux 的 MSG_MORE,粒度更细。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

控制 Nagle 与小包发送延迟

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通