先说一个很典型的线上现象:客户端发的是「一行一个 JSON」,服务端用 read 收,收完直接 serde_json::from_str。大部分请求正常,偶尔报「trailing characters」,偶尔报「EOF while parsing」。开发机上复现不了,因为开发机的网络太快、消息太小,一次 read 恰好等于一条消息。
根因不是 JSON 库,也不是 Rust,而是 TCP 的模型:它只保证「字节按顺序到达」,不保证「一次读一条消息」。两条消息可能被合并成一次读(粘包),一条消息也可能分几次到达(半包)。这个边界必须由应用层自己划。理解了这一点,std::net 剩下的 API 都只是工具。
这一篇用标准库写一个最小的 TCP 服务与客户端,所有输出都是在本机 Windows 上真跑出来的,端口是系统分配的随机端口,每次不一样,看的时候关注行为而不是具体数字。
监听与连接:两个对象,两件事
服务端先 TcpListener::bind,再循环 accept。bind 的地址决定谁能连进来:127.0.0.1:0 只监听本机,端口写 0 表示让操作系统挑一个空闲端口,用 local_addr() 拿回实际端口;0.0.0.0:8080 监听所有网卡,外网能访问,也意味着安全边界从「本机」变成了「整个网络」。很多「服务莫名其妙被扫描」的事故,就是把调试用的 0.0.0.0 带上了生产。
let listener = TcpListener::bind("127.0.0.1:0")?;
let addr = listener.local_addr()?;
println!("listen => {}", addr);
实测输出 listen => 127.0.0.1:8605。这个端口不是代码写死的,是内核分配的。
accept 是阻塞调用:没有新连接时线程停在这里。它返回一个 (TcpStream, SocketAddr),前者代表这条连接,后者是对端地址。注意 TcpListener 本身不处理数据,它只负责「接客」;每条连接都是一个独立的 TcpStream,有自己的读写缓冲。想让多个客户端同时被服务,就必须把每个 TcpStream 交给别的线程,或者用异步运行时,光靠一个循环会在第一个连接上卡住。
地址不一定要写死成字符串。connect 接受任何实现了 ToSocketAddrs 的类型,可以传域名,它会先做 DNS 解析再连接。解析本身是阻塞的,而且可能很慢;DNS 挂了时,connect 甚至还没开始握手就卡住了。要控制总时间,先把域名解析成 SocketAddr,再对具体地址用 connect_timeout。另外 127.0.0.1 是 IPv4 回环地址,IPv6 对应的是 [::1];同时监听两者需要双栈 socket,标准库的 TcpListener 在不同平台上的默认行为并不一致,跨平台服务要显式绑定并测试。
TcpStream::connect 也是阻塞的:它要完成 TCP 三次握手才返回。目标不可达时,可能要等到系统默认超时才失败,这个时间可能长达几十秒。要控制连接超时,标准库没有直接参数,得用 connect_timeout 配合 SocketAddr,或者用非阻塞 connect 再自己等。一次 read 到底读到什么
read 的语义是「把当前内核接收缓冲区里已有的字节,最多读我给的这么多」,它不关心你心里的消息边界。实测:客户端一次写入 19 个字节,服务端用 8 字节的缓冲区读:
read once => 8 bytes: "hellowor"
read again=> 8 bytes: "ld-and-m"
buffered => 3 bytes: "ore"
after eof => 0 bytes
这条输出把三件事一次讲完了。第一,read 受缓冲区大小限制,8 字节的缓冲区一次最多给 8 字节;第二,数据不会丢,剩下的还在内核缓冲区里,下一次 read 继续拿;第三,对端关闭写端后,缓冲里剩下的字节仍然会先返回,直到真的读空,下一次才返回 0。
再看粘包。客户端连续两次 write,分别写 hello 和 world,服务端只调用一次 read(缓冲区 1024 字节):
coalesced => 10 bytes: "helloworld"
两次写被合并成一次读。可能的原因有两层:发送端的 Nagle 算法会把小包攒起来再发,减少网络上的小包;接收端的 read 会把缓冲区里当前已有的字节一次取走。合并本身是优化,不是错误,但你的解析代码必须能接受它。
所以「一次 read 一条消息」这个假设,在任何真实网络里都不成立。开发机上的「恰好对上」只是概率,不是保证。
写方向也有类似的半包问题。很多人以为 write 一次就能把整条消息发出去,其实它只保证「这一段字节写进了发送缓冲区」,返回值可能小于你给的长度。发送缓冲区满时,write 会阻塞(阻塞模式下),或者返回 WouldBlock(非阻塞模式下)。所以除非你确认缓冲区足够大,否则应该用 write_all,它会循环直到写完;更严谨的做法是 write_all 之后 flush,但 TCP 的 flush 只是把用户态缓冲推给内核,不代表对端收到了。真正的「对方收到了」只能靠应用层确认。
分帧:自己定义消息边界
常见的分帧方式有三种,各有用处:
长度前缀的解析要写成循环,不能假设「读一次长度、读一次内容就完事」。下面的写法用 read_exact,它会一直读到凑满指定字节,内部处理了半包:
let mut len_buf = [0u8; 4];
s.read_exact(&mut len_buf)?;
let len = u32::from_be_bytes(len_buf) as usize;
let mut payload = vec![0u8; len];
s.read_exact(&mut payload)?;
实测连发三条消息,服务端逐条解析:
frame => len=5 payload="alpha"
frame => len=4 payload="beta"
frame => len=5 payload="gamma"
换行分隔则用 BufReader 的 read_line,它会把分隔符也读进来,通常要 trim_end 再用。两种方案都要防一个事:长度字段是对方给的,不能无条件相信。恶意客户端发一个 u32::MAX,你按长度 vec![0u8; len] 分配,内存瞬间被吃光。生产代码必须给长度设上限,超限就断开连接。这是网络代码和文件代码最大的不同:输入不可信。
超时、阻塞与非阻塞
默认的 TcpStream 是阻塞的:read 没有数据就一直等,write 缓冲区满也一直等。这会让一个不说话的客户端占住一个线程,形成慢速攻击。标准库给的办法是设超时:
s.set_read_timeout(Some(Duration::from_millis(300)))?;
let mut buf = [0u8; 16];
match s.read(&mut buf) {
Ok(n) => println!("read {} bytes", n),
Err(e) => println!("err kind={:?}", e.kind()),
}
对端 300 毫秒不发数据,实测返回:
timeout => err kind=TimedOut, text=由于连接方在一段时间后没有正确答复或连接的主机没有反应,连接尝试失败。 (os error 10060)
注意错误种类是 TimedOut,但底层系统码是 Windows 的 10060,文字也是系统语言。跨平台代码要按 ErrorKind 分支,不要按错误码或文字。超时不是「连接断了」,连接还在,只是这次读超时;要不要断开由业务决定,通常连续多次超时就该断开并回收资源。
另一种做法是把 socket 设成非阻塞:
listener.set_nonblocking(true)?;
match listener.accept() {
Ok((_, _)) => ...,
Err(e) => ...,
}
没有连接时,实测返回 err kind=WouldBlock, text=无法立即完成一个非阻止性套接字操作。 (os error 10035)。WouldBlock 不是错误,它的意思是「现在没有,等会儿再来」。非阻塞模式要求你写一个事件循环:把所有 socket 注册到 epoll/kqueue/IOCP,等事件通知,再处理就绪的连接。标准库不提供这个循环,所以手写非阻塞服务通常最终会引入 mio 或直接上 tokio。用「循环 + sleep」轮询也能跑,但空闲时浪费 CPU,连接多了延迟也大。
还有一个容易忽略的超时:写超时。对端不读数据时,发送缓冲区会满,write 就会阻塞。设 set_write_timeout 能让它失败而不是永远等。读超时和写超时都要设,只设一个等于只堵住一半。
顺带说清 Nagle。它会把小包攒起来,等前一个包被确认后再发下一个,目的是减少网络上的小包数量。对批量传输是好事,对「一问一答」的低延迟协议可能是坏事:一个 10 字节的请求可能被多等几十毫秒才发出去。set_nodelay(true) 能关掉它,代价是小包变多、网络利用率下降。这不是「开了就更快」,而是「用带宽换延迟」。实测里两条小消息被合并成一次读,正是这类行为的体现;但它也可能发生在关闭 Nagle 之后,因为合并的根本原因是接收端一次读走了缓冲区里已有的所有字节,Nagle 只是影响因素之一。
关闭、半关闭与常见错误
shutdown(Shutdown::Write) 是「我不再发了,但还能收」,这叫半关闭。对端读到 0 就知道你的数据发完了,可以开始收尾,而你的读方向还活着,能等对端的最后一条回复。直接 drop 连接则是两个方向一起关,对端可能还没读完就被重置。
read 返回 Ok(0) 表示对端正常关闭了写方向,这是 EOF,不是错误。很多服务端代码把 0 当成异常,其实是协议里正常的结束信号。相对地,ConnectionReset 表示对端是异常断开的(进程被杀、网络中断),这时未读完的数据可能已经丢了,只能当作连接失败处理。BrokenPipe 表示你往一个已关闭的连接写,通常在读端先退出后发生。
端口侧还有一个现实问题:服务端主动关闭连接后,端口会进入 TIME_WAIT,短时间内不能复用。重启服务时如果报「地址已占用」,常见原因是上一个进程还没完全退出,或者 TIME_WAIT 还没结束。标准库没有设置 SO_REUSEADDR 的接口,需要 socket2 这类库在 bind 之前设置。这段本机没有实测,只说明原因,不要把它当成「重启就一定会遇到」。
并发:一个连接一个线程够不够
标准库的阻塞 socket 最直接的并发模型是「accept 一个,spawn 一个线程」:
for stream in listener.incoming() {
let stream = stream?;
thread::spawn(move || handle(stream));
}
这个模型简单、好调试,几百个连接完全够用。问题是每个线程都有栈和调度开销,上万个长连接就会吃力;而且线程一旦阻塞在 read,就没法用少量线程处理大量连接。异步运行时的价值就在这里:把「等数据」变成注册回调,一个线程能管很多连接。但异步不是免费的,代码复杂度、调试难度、生态绑定都会上升。连接数在几百以内,线程模型往往更划算。
线程也不能无限开。更稳的做法是固定大小的线程池加一个有界任务队列:accept 之后把连接投进队列,池里的线程取一个处理一个。队列满了要拒绝新连接,而不是继续收,否则内存会被待处理连接撑爆。标准库没有线程池,但用 mpsc 通道加固定数量的 worker 就能拼一个最小实现;线程数一般取 CPU 核数上下,IO 密集可以适当多几倍,具体要看压测,不要凭感觉设成 1000。
还有一种常见需求是「给每个连接设空闲上限」。实现方式不是给 read 设一个很大的超时,而是记录最后一次活动时间,定期扫描并关闭超时连接;或者在协议层加心跳。单纯依赖 TCP keepalive 不够,默认间隔往往是两小时,业务等不起。
服务要退出时,还得考虑 accept 正卡着怎么办。TcpListener 没有「可中断的 accept」接口,常见做法是另开一个线程负责收信号,收到后设置一个原子标志,再主动 connect 自己一下把 accept 唤醒,或者直接让进程退出、由操作系统回收。前者是「优雅停机」,能处理完在途请求;后者简单,但正在处理的请求会被硬断。选哪种取决于你的服务能不能承受「请求被切断」。
现象对照
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| JSON 解析偶发「trailing characters」 | 一次 read 收到了两条或多条消息 | 看解析前有没有分帧,别直接拿单次 read 的内容解析 |
| JSON 解析偶发「EOF while parsing」 | 消息被拆成多次到达,只读到了前半截 | 用 read_exact 或循环累积到完整帧 |
read 返回 0,服务端当成错误 | 对端正常关闭写方向,0 是 EOF | 把 0 当正常结束,退出循环并清理连接 |
| 服务端线程越积越多 | 每个连接一个线程且没有空闲超时 | 加读超时、记录最后活动时间、设连接上限 |
| 重启服务报「地址已占用」 | 旧进程未退出,或端口处于 TIME_WAIT | 确认进程已退出;需要时用 socket2 设 SO_REUSEADDR |
read 报 TimedOut 但连接没断 | 设了读超时,对端暂时没发数据 | 按业务决定重试或断开,别把超时当连接关闭 |
| 非阻塞循环 CPU 占用 100% | accept/read 一直返回 WouldBlock,代码在忙轮询 | 改用事件通知,或加退避 sleep,别空转 |
| 客户端发大消息,服务端内存暴涨 | 按对端给的长度直接分配,没有上限 | 给帧长度设硬上限,超限立即断开 |
| 写了数据对端没收到,程序却卡住 | 发送缓冲区满,write 阻塞;对端不读 | 设写超时,检查对端读取速度与协议设计 |
边界与代价
第一层是协议边界。TCP 只提供可靠的字节流,消息边界、请求响应配对、重试与幂等,全部要应用层设计。用 HTTP 就有一整套现成规则;自己定协议,就得自己承担这些。别把「能收发」当成「协议设计完成」。
第二层是安全边界。标准库的 TCP 是明文,没有 TLS。0.0.0.0 监听、无认证、无长度上限、无速率限制,任何一个都能让服务变成攻击面。要在公网使用,至少加上 TLS(rustls 等外部库)、认证和输入校验,这些标准库都不提供。
第三层是并发模型的代价。线程模型写起来直白,但连接数一多就受限于线程;异步模型能把连接数做上去,但要求全链路非阻塞,一个阻塞调用就能拖慢一整个执行器。这个坑正是后面 tokio 那篇的主题:语法上的 async 不会自动把阻塞调用变快。
第四层是可观测性。网络问题往往表现为「偶发」「超时」「连不上」,只看业务日志很难定位。至少要记录连接建立与关闭、每次读写的字节数、错误种类与对端地址。标准库不提供指标,得自己在封装层加。别等到线上出事才想起来「当时到底读到了多少字节」。
小结
把这一篇收成四句:TcpListener 负责接客,TcpStream 负责一条连接;一次 read 拿到的是「当前可读的字节」,不是一条消息;消息边界必须用长度前缀、分隔符或定长自己划;阻塞、超时、非阻塞是三种不同的等待策略,选哪个取决于并发规模和延迟要求。后面讲异步运行时的时候还会回到这个问题:换个等待方式,消息边界依然要自己划。
能收发数据只是起点。接下来要面对的是「一个进程里怎么安全地让多个线程共享状态」,再往后是「多个进程怎么共享同一块内存」。下一篇先处理子进程:调用外部命令、拿退出码、处理管道和超时,这些是写运维工具绕不开的东西。
当天可以自己验证的练习:
- 把长度前缀的例子改成换行分隔,用
BufReader::read_line解析,故意在消息里放一个换行,观察会发生什么。 - 把服务端的读缓冲区改成 1 字节,确认
read_exact仍然能正确拼出完整消息。 - 写一个客户端,连接后不发任何数据,确认服务端在读超时后返回
TimedOut而不是永远阻塞。 - 把
set_nonblocking(true)后的WouldBlock用循环加sleep处理,统计 10 秒内的空转次数。 - 给消息长度加一个 1 MB 上限,构造一个超大长度字段,确认服务端在分配内存前就拒绝。
这五条都不难,但每一条都对应一个真实会踩的坑。跑完再去看任何网络框架的文档,会清楚它到底替你做了什么。