Python / 系统课时

连接关闭后资源去哪了

连接关闭后资源去哪了

TCP 连接结束并不等于 Python 对象立刻消失。使用 asyncio Streams 时,需要同时处理对端发来的 EOF、本端 writer.close() 发起的关闭,以及 await writer.wait_closed() 对底层传输真正结束的等待。把这三个动作连起来,才能避免连接泄漏、尾部数据未发送完或任务长期挂起。

学习目标

  • 能识别 reader.read() 返回空字节串所表示的 EOF,并区分“读到 EOF”和“本端已关闭”
  • 能正确组合 writer.close() 与 await writer.wait_closed() 完成连接释放
  • 能用 try/finally 覆盖正常结束与异常路径,建立完整的 TCP 连接生命周期

EOF 只说明对端不再发送

在 Streams API 中,await reader.read(n) 返回 b"" 表示读方向已经到达 EOF。最常见的原因是对端关闭了连接,或者关闭了自己的写方向。

这里有一个容易忽略的边界:读到 EOF 不会自动替你关闭本端的 StreamWriter。TCP 可以出现半关闭状态,所以“对端不再发数据”和“我这边的连接资源已经释放”是两件事。

TCP Streams 连接建立、EOF 与关闭生命周期

因此,服务器读取连接时通常把 EOF 当作退出读取循环的信号,再进入统一的清理逻辑。下面是片段示例,依赖已经建立的 reader 以及外层读取循环:

python
data = await reader.read(1024)
if data == b"":
    # 对端已经结束发送,退出读取阶段。
    break

reader.at_eof() 也能查询 EOF 状态,但在常规读取循环里,直接判断 read() 的返回值更自然,因为它与本次读取结果绑定,不需要额外轮询状态。

close 与 wait_closed 分工不同

writer.close() 的作用是请求关闭 StreamWriter 关联的底层传输。它不是一个需要 await 的协程,也不能把“函数返回”理解为底层套接字已经完全结束。

随后调用 await writer.wait_closed(),可以等待关闭流程完成。把两者连用的目的,是让当前协程在离开清理阶段前,确认底层 Transport 已经执行完关闭动作。

下面是片段示例,依赖当前作用域中已经建立的 writer:

python
writer.close()
await writer.wait_closed()

如果业务代码中存在读取、解码、处理或写回异常,应把关闭动作放进 finally。这样无论是正常 EOF、协议错误还是任务取消,都尽量沿着同一条释放路径结束。

用一个最小程序观察完整生命周期

下面的程序在同一个事件循环里启动 TCP 服务端与客户端。客户端发送两段数据后关闭连接;服务端持续读取,直到获得 EOF,然后在 finally 中关闭自己的写端并等待关闭完成。

python
import asyncio

async def handle_client(
    reader: asyncio.StreamReader,
    writer: asyncio.StreamWriter,
    finished: asyncio.Event,
) -> None:
    received = bytearray()
    try:
        while True:
            chunk = await reader.read(1024)
            if chunk == b"":
                break
            received.extend(chunk)
        print(f"server: received {received.decode()}")
        print("server: EOF")
    finally:
        # EOF 只结束读取;本端仍要显式关闭 writer。
        writer.close()
        await writer.wait_closed()
        print(f"server: closed, total={len(received)}")
        finished.set()

async def run_client(port: int) -> None:
    _, writer = await asyncio.open_connection("127.0.0.1", port)
    writer.write(b"hello ")
    writer.write(b"asyncio")
    await writer.drain()
    # 请求关闭客户端传输,并等待底层关闭完成。
    writer.close()
    await writer.wait_closed()

async def main() -> None:
    finished = asyncio.Event()
    server = await asyncio.start_server(
        lambda reader, writer: handle_client(reader, writer, finished),
        "127.0.0.1",
        0,
    )
    port = server.sockets[0].getsockname()[1]
    async with server:
        await run_client(port)
        await finished.wait()

if __name__ == "__main__":
    asyncio.run(main())

预期输出

text
server: received hello asyncio
server: EOF
server: closed, total=13

服务端应完整收到 13 个字节,再观察到 EOF,并最终执行关闭逻辑。程序使用系统分配的临时端口,因此实际端口值不会固定。

把清理放在所有退出路径上

真实服务里最危险的不是正常 EOF,而是异常提前跳出。一个连接处理协程通常至少可能因协议解析失败、业务异常、超时或任务取消而结束。如果关闭逻辑散落在多个分支,很容易漏掉其中一条路径。

因此可以把连接处理拆成两个阶段:try 中负责“使用连接”,finally 中负责“释放连接”。如果关闭阶段本身也可能遇到平台或网络相关异常,可以在外围记录异常,但不要因此省略关闭动作。

另外,writer.drain() 与 wait_closed() 解决的是不同问题:前者用于写入期间的流量控制,让发送缓冲区过大时产生背压;后者用于关闭阶段等待传输结束。不能用其中一个替代另一个。

什么时候连接才算真正结束

从应用角度看,一次 TCP Streams 会话至少要完成三件事:停止继续读取或写入、发起本端关闭、等待底层传输关闭完成。对端 EOF 只是第一件事的一个触发条件,而不是全部生命周期。

只要把 EOF 识别放在读取循环里,把 writer.close() 和 await writer.wait_closed() 固定放进可靠的清理路径,连接从建立、使用到释放就形成了闭环;这也是后续处理超时、取消和高并发连接时最重要的资源边界。

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

目录与阅读设置

阅读设置

17

记录一个想法

连接关闭后资源去哪了

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

登录哪都通