本篇整理 Python 网络编程：socket、TCP 流程、UDP 流程、asyncio 异步流和 aiohttp。

操作系统文集已经从 OS 视角整理了 I/O 系统、Linux 示例 和 POSIX IPC 中的 socket。本篇从 Python API 进入：socket 直接操作网络端点， asyncio 把网络 I/O 接入事件循环，aiohttp 在其上提供 HTTP 客户端和服务端。

1. 套接字 API

1.1 套接字对象

套接字（socket）是网络通信端点。Python 的 socket.socket 对象封装了操作系统 socket 文件描述符；除 makefile() 外，大多数方法都直接对应底层 socket 系统调用。

创建 socket 时最重要的两个参数是地址族和 socket 类型：

socket.socket() 只创建本地端点。客户端继续调用 connect() 建立连接；服务端继续调用 bind()、listen() 和 accept()。

1.2 地址与端口

IPv4 TCP/UDP socket 的地址通常写成 (host, port)：

端口用于区分同一主机上的不同服务。Unix-like 系统上，小于 1024 的端口通常需要管理员权限；开发和测试服务通常使用大于 1024 的端口。

bind(('127.0.0.1', 0)) 表示让操作系统分配一个临时可用端口。分配后可以用 getsockname() 读取真实端口。

1.3 阻塞与超时

普通 socket 默认是阻塞式 I/O。connect()、accept()、recv() 都可能阻塞当前线程：

阻塞式 socket 代码应设置超时，避免网络异常时无限等待：

import socketwith socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client:    client.settimeout(3.0)    print(client.gettimeout()) # 3.0

事件循环下的 socket 通常会被设置为非阻塞。应用层通常通过 asyncio 或更高层的网络库通信。

2. TCP 流程

传输控制协议（TCP, Transmission Control Protocol）建立连接后提供双向字节流：对端收到的是有序字节序列，应用层需要自己组织消息格式。

2.1 客户端流程

TCP 客户端的基本流程是：创建 socket，连接服务端，发送字节，接收字节，关闭连接。

send() 返回实际写入内核缓冲区的字节数，可能小于传入数据长度；sendall() 会循环发送直到全部提交或抛出异常。因此，简单客户端优先使用 sendall()。

2.2 服务端流程

TCP 服务端的基本流程是：创建监听 socket，绑定地址，进入监听状态，接受连接，再用 accept() 返回的新 socket 处理这个客户端。

补充： listen(backlog:int)

当服务器调用 listen() 将一个 socket 设置为监听状态时，backlog 参数决定了服务器可以同时处理的连接请求数量。TCP 建立连接需要经历三次握手，在此过程中，连接会经历以下两个队列：

1. SYN 队列：存储处于半连接状态的请求（即 SYN_RECEIVED 状态）。
2. Accept 队列：存储已完成三次握手的连接（即 ESTABLISHED 状态）。

backlog 参数主要用于限制 Accept 队列 的最大长度。如果队列已满，新连接请求可能会被拒绝或丢弃。

在 Linux 系统中，TCP 协议栈采用两个队列的实现方式：

1. SYN 队列 的长度由系统参数 /proc/sys/net/ipv4/tcp_max_syn_backlog 决定。
2. Accept 队列 的长度由 backlog 参数和系统参数 /proc/sys/net/core/somaxconn 的较小值决定。

当 Accept 队列已满时，服务器可能会：丢弃新连接请求或根据 /proc/sys/net/ipv4/tcp_abort_on_overflow 的设置，发送 RST 包通知客户端连接被拒绝。

下面的示例把服务端和客户端放在同一个脚本中，使用后台线程只处理一次连接，便于直接运行：

import socketimport threadingdef serve_once(server: socket.socket) -> None:    conn, addr = server.accept()    with conn:        data = conn.recv(1024)        conn.sendall(b'echo:' + data)    server.close()server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)server.bind(('127.0.0.1', 0))server.listen()host, port = server.getsockname()thread = threading.Thread(target=serve_once, args=(server,))thread.start()with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client:    client.connect((host, port))    client.sendall(b'hello')    print(client.recv(1024).decode()) # echo:hellothread.join()

监听 socket 只负责接受连接。真正收发数据的是 accept() 返回的连接 socket。真实服务端通常会循环 accept() ，并把每个连接交给线程、进程池、事件循环或专门的服务器框架处理。

连接 socket 是全双工字节流。连接建立后，两端都可以在同一条连接上执行 send() / sendall() 和 recv()；发送方向和接收方向相互独立， 但应用代码仍要自己安排读写顺序，避免双方同时等待对方先发数据。

阻塞式 TCP socket 的读写由内核缓冲区状态决定：

TCP socket 传递的是字节。send()、sendall() 接收 bytes、bytearray、memoryview 等字节类对象；recv() 返回 bytes。如果要传递 Python 对象，需要应用层先编码，例如 JSON、MessagePack、Protocol Buffers 或自定义二进制格式。

2.3 消息分帧

TCP 是字节流协议。一次 recv(1024) 可能只读到半条消息，也可能读到多条消息拼在一起。应用层协议需要定义消息分帧规则。

常见分帧方式：

下面用换行作为消息分隔符：

message = b'PING\nPONG\n'first, second, rest = message.partition(b'\n')print(first.decode())  # PINGprint(second)          # b'\n'print(rest.decode())   # PONG

recv() 返回 b'' 表示对端已经关闭连接，字节流已经结束。

3. UDP 流程

用户数据报协议（UDP, User Datagram Protocol）无需建立连接，发送方只要知道目标地址就能发送数据报；它不保证到达、顺序或去重。

3.1 收发流程

UDP 服务端绑定地址后直接用 recvfrom() 接收数据。返回值包含数据和发送方地址，服务端可以用 sendto() 回复。

import socketimport threadingdef serve_once(server: socket.socket) -> None:    data, addr = server.recvfrom(1024)    server.sendto(b'echo:' + data, addr)    server.close()server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)server.bind(('127.0.0.1', 0))host, port = server.getsockname()thread = threading.Thread(target=serve_once, args=(server,))thread.start()with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as client:    client.sendto(b'hello', (host, port))    data, addr = client.recvfrom(1024)    print(data.decode()) # echo:hellothread.join()

UDP 客户端可以不调用 connect()，直接 sendto(data, address)。UDP socket 也支持 connect(address)，但这里的 connect 不会建立握手，只记录默认对端地址，并让后续 send() / recv() 使用该地址。

3.2 数据报语义

UDP 按数据报收发。一次 sendto() 对应一个数据报；一次 recvfrom() 最多取一个数据报。

同一个数字端口可以同时被 TCP 和 UDP 使用，因为它们属于不同传输协议。比如 TCP 9999 与 UDP 9999 是两组不同的端口绑定。

UDP 的可靠性由应用层决定。如果业务需要确认、重传、去重、排序和拥塞控制，就要在应用层实现，或直接使用 TCP / QUIC 等更高层方案。

4. 异步网络 API

阻塞式 socket 在当前线程上阻塞等待。异步网络接口把 socket 交给事件循环，当 socket 可读或可写时再恢复对应 coroutine。

常见层级如下：

4.1 异步流

asyncio.open_connection() 创建客户端连接，返回 StreamReader 和 StreamWriter。asyncio.start_server() 创建 TCP 服务端，每个连接到达时调用处理函数。

异步流主流程：

读取接口：

下面是单文件异步 echo 示例：

import asyncioasync def handle(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:    data = await reader.read(100)    writer.write(b'echo:' + data)    await writer.drain()    writer.close()    await writer.wait_closed()async def main() -> None:    server = await asyncio.start_server(handle, '127.0.0.1', 0)    host, port = server.sockets[0].getsockname()[:2]    reader, writer = await asyncio.open_connection(host, port)    writer.write(b'hello')    await writer.drain()    print((await reader.read(100)).decode()) # echo:hello    writer.close()    await writer.wait_closed()    server.close()    await server.wait_closed()asyncio.run(main())

writer.write() 只是把数据写入传输层缓冲区；await writer.drain() 等待缓冲区回落到合适水位。大量写入时应保留 drain() ，否则可能在用户态积累过多待发送数据。

4.2 异步客户端

aiohttp 是基于 asyncio 的异步 HTTP 客户端/服务端库。它运行在 asyncio 网络 I/O 之上，负责处理 HTTP 协议细节：请求行、响应状态、header、body、连接复用、压缩、重定向和超时。 aiohttp 是第三方库，示例运行前需要先安装 aiohttp。

客户端核心对象：

客户端主流程：

响应读取接口：

客户端配置对象：

基本请求形态如下：

import asynciofrom aiohttp import ClientSession, ClientTimeout, TCPConnectorasync def main() -> None:    timeout = ClientTimeout(total=5)    connector = TCPConnector(limit=100, limit_per_host=10, ttl_dns_cache=60)    async with ClientSession(timeout=timeout, connector=connector) as session:        async with session.get('https://example.com') as response:            print(response.status)       # 200            print(len(await response.text()) > 0) # Trueasyncio.run(main())

补充：async with 与 with

普通 with 使用同步上下文管理协议。执行 with manager as value: 时，解释器会调用 manager.__enter__() 进入资源作用域，离开时调用 manager.__exit__(exc_type, exc, tb) 清理资源：

1. 计算上下文管理器表达式，得到 manager。
2. 调用 value = manager.__enter__()。
3. 执行 with 代码块。
4. 退出时调用 manager.__exit__(exc_type, exc, tb)；如果代码块中抛出异常，异常信息会传入 __exit__()。

async with 使用异步上下文管理协议，只能写在 async def 内。执行 async with manager as value: 时，进入和退出阶段分别等待 manager.__aenter__() 与 manager.__aexit__(exc_type, exc, tb)：

1. 计算异步上下文管理器表达式，得到 manager。
2. 调用并等待 value = await manager.__aenter__()。
3. 执行 async with 代码块。
4. 退出时调用并等待 await manager.__aexit__(exc_type, exc, tb)；如果代码块中抛出异常，异常信息会传入 __aexit__()。

差异集中在资源进入和释放是否允许挂起。with 的 __enter__() / __exit__() 在当前线程同步执行；async with 的 __aenter__() / __aexit__() 可以在等待网络、文件描述符或连接池状态时把控制权交还给事件循环。ClientSession 在退出时关闭会话和连接池， session.get() 返回的响应对象在退出时释放响应资源，使底层连接可以回到连接池。

ClientSession 不应按请求创建。通常一个应用、一个服务对象或一个目标站点复用同一个 session；每次请求创建 session 会丢失连接池复用，并增加 DNS、握手和连接管理开销。

响应体读取方式按数据规模选择：

4.3 异步服务端

aiohttp.web 的服务端 API 由 Application、路由和异步 handler 组成。handler 接收 Request，返回 Response。

服务端主流程：

手动生命周期接口：

请求读取接口：

例如：

from aiohttp import webasync def hello(request: web.Request) -> web.Response:    name = request.match_info.get('name', 'Python')    return web.Response(text=f'hello {name}')app = web.Application()app.add_routes([web.get('/hello/{name}', hello)])web.run_app(app, host='127.0.0.1', port=8080)

为了在一段脚本中同时演示服务端和客户端，可以使用 AppRunner 启动应用，再用 ClientSession 请求它：

import asyncioimport socketfrom aiohttp import ClientSession, ClientTimeout, webasync def hello(request: web.Request) -> web.Response:    name = request.match_info['name']    return web.json_response({'message': f'hello {name}'})async def main() -> None:    app = web.Application()    app.add_routes([web.get('/hello/{name}', hello)])    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    sock.bind(('127.0.0.1', 0))    host, port = sock.getsockname()    runner = web.AppRunner(app)    await runner.setup()    site = web.SockSite(runner, sock)    await site.start()    try:        timeout = ClientTimeout(total=5)        async with ClientSession(timeout=timeout) as session:            async with session.get(f'http://{host}:{port}/hello/Python') as response:                print(response.status)      # 200                print(await response.json()) # {'message': 'hello Python'}    finally:        await runner.cleanup()asyncio.run(main())

web.run_app(app) 适合命令行启动一个长期运行的服务；AppRunner / SockSite 适合测试、嵌入式启动或需要自己管理服务生命周期的场景。

4.4 超时与连接池

网络代码应显式处理超时。阻塞式 socket 使用 settimeout()；asyncio 可以用 asyncio.timeout() 包住等待；aiohttp 客户端使用 ClientTimeout。

import asyncioasync def slow_operation() -> str:    await asyncio.sleep(1)    return 'done'async def main() -> None:    try:        async with asyncio.timeout(0.01):            await slow_operation()    except TimeoutError:        print('timeout') # timeoutasyncio.run(main())

不同层级的超时对象：

aiohttp 的连接池由 ClientSession 持有，底层通过 connector 管理。默认 TCPConnector 会复用 HTTP keep-alive 连接；请求完成后， 连接回到连接池，后续同一目标的请求可以复用它。

import asynciofrom aiohttp import ClientSession, ClientTimeout, TCPConnectorasync def main() -> None:    timeout = ClientTimeout(total=10, connect=3, sock_connect=3, sock_read=5)    connector = TCPConnector(limit=100, limit_per_host=10, ttl_dns_cache=60)    async with ClientSession(timeout=timeout, connector=connector) as session:        ...asyncio.run(main())

TCPConnector(limit=100) 限制所有目标的总连接数；limit_per_host=10 限制同一 (host, port, is_ssl) 目标的并发连接数。 当连接数达到限制时，新的请求会等待已有连接释放。长期运行的服务应在应用启动时创建 session，在关闭时释放 session；短脚本则用 async with ClientSession() 让上下文管理器自动关闭。

5. 接口选择

网络编程的层级选择从目标和协议开始：

底层 socket 负责“把字节送到对端”。TCP/UDP 决定传输语义；asyncio 决定等待期间如何调度 coroutine； aiohttp 把这些机制组合成面向 HTTP 的客户端和服务端接口。