Rust / 系统课时

处理断连与半关闭

处理断连与半关闭

TCP 连接结束并不只有“双方同时关闭”一种状态。服务端必须区分读到 EOF、写入失败和主动关闭写方向,并保证无论哪条路径退出,连接许可和关联任务都能释放,避免连接数看似下降而后台任务仍持续占用资源。

学习目标

  • 正确解释非空缓冲区上 read 返回 0 的含义,并处理对端半关闭。
  • 区分读方向 EOF、写失败与 shutdown() 主动关闭写方向。
  • 让连接处理任务在正常结束和 I/O 错误时都释放资源。

先识别半关闭状态

TCP 是全双工字节流,两端的发送方向可以独立关闭。客户端关闭自己的写方向后,服务端在已接收数据全部读完时会看到 read 返回 0;这表示服务端的读方向到达 EOF,并不代表服务端已经不能继续向客户端写数据。

TCP 半关闭与双向结束时序

写方向是另一条独立路径。对端可能已经关闭接收或发生复位,此时 write_all 会返回 I/O 错误。服务端不应在同一坏连接上无限重试,而应结束当前处理流程,让 socket 和占用的资源一起被释放。

在所有退出路径上清理连接

下面的服务为每个连接获取一个 Semaphore 许可。处理任务无论因为 read == 0、读错误、写错误还是 shutdown() 错误结束,外层任务都会执行 drop(permit),因此连接计数不会泄漏。

toml
[package]
name = "half-close-tcp"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }

将下面代码保存为 src/main.rs:

rust
use std::{io, net::SocketAddr, sync::Arc};
use tokio::{
    io::{AsyncReadExt, AsyncWriteExt},
    net::{TcpListener, TcpStream},
    sync::Semaphore,
};

#[tokio::main]
async fn main() -> io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8081").await?;
    let connection_limit = Arc::new(Semaphore::new(100));
    println!("listening on 127.0.0.1:8081");

    loop {
        let (stream, peer) = listener.accept().await?;
        let permit = connection_limit
            .clone()
            .acquire_owned()
            .await
            .expect("semaphore is not closed");

        tokio::spawn(async move {
            // 清理放在 I/O 处理函数外层,保证错误返回时也会释放许可。
            let result = handle_connection(stream, peer).await;
            drop(permit);
            println!("cleanup: {peer}");

            if let Err(err) = result {
                eprintln!("connection error from {peer}: {err}");
            }
        });
    }
}

async fn handle_connection(
    mut stream: TcpStream,
    peer: SocketAddr,
) -> io::Result<()> {
    let mut buf = [0_u8; 4096];
    let mut total = 0_usize;

    loop {
        match stream.read(&mut buf).await {
            Ok(0) => {
                println!("peer half-closed write: {peer}");

                // 对端不再发送,但仍可能继续接收,因此可以发送最终响应。
                let final_msg = format!("received {total} bytes\n");
                stream.write_all(final_msg.as_bytes()).await?;
                stream.shutdown().await?;
                return Ok(());
            }
            Ok(n) => {
                total += n;
                // 写失败说明这条连接无法继续正常响应,直接退出清理。
                stream.write_all(&buf[..n]).await?;
            }
            Err(err) => return Err(err),
        }
    }
}

预期输出

text
listening on 127.0.0.1:8081

服务会持续监听。<IP> 和 <PORT> 等对端地址属于动态值,实际日志会随客户端连接而变化。

验证客户端半关闭

另开终端运行下面的 Python 客户端。它先发送 hello\n,然后只关闭自己的写方向,仍继续读取服务端数据,直到服务端也关闭写方向。

python
import socket

with socket.create_connection(("127.0.0.1", 8081)) as sock:
    sock.sendall(b"hello\n")
    sock.shutdown(socket.SHUT_WR)

    data = bytearray()
    while True:
        chunk = sock.recv(1024)
        if not chunk:
            break
        data.extend(chunk)

    print(data.decode(), end="")

预期输出

text
hello
received 6 bytes

服务端会同时出现类似日志:

text
peer half-closed write: <IP>:<PORT>
cleanup: <IP>:<PORT>

预期结果中的 <IP> 与 <PORT> 会因运行环境不同而变化。这里最关键的现象是:客户端已经停止发送后,服务端仍能把回显和最终统计写回去,证明半关闭只结束了一个方向。

把异常当作连接生命周期的终点

AsyncWriteExt::shutdown().await 用于主动结束写方向;对 TCP 流而言,对端随后会在自己的读方向看到 EOF。它不是“释放所有业务资源”的替代品:连接许可、请求上下文以及为该连接创建的子任务仍要由应用代码管理。

如果连接处理过程中还启动了心跳、订阅或转发子任务,不要让这些任务脱离连接生命周期。应保存它们的 JoinHandle 或使用结构化取消机制,在主连接任务退出时先通知取消并等待结束,再释放其余资源;单纯 drop(TcpStream) 不会自动终止任意已经分离的 Tokio 任务。

把 read == 0、写错误和主动 shutdown() 都视为明确的状态转换,而不是特殊日志分支。这样每条退出路径最终都会汇合到同一清理位置,连接数限制、内存和后台任务才能真正随连接结束而回收。

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

目录与阅读设置

阅读设置

17

记录一个想法

处理断连与半关闭

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

登录哪都通