Python / 系统课时
把连接处理拆成独立任务
把连接处理拆成独立任务
一个连接同时承担读取、业务处理和写回时,任何一步阻塞都会拖住整条链路。本篇把单连接拆成三个协作任务,用有界队列提供背压,用 TaskGroup 管理共同生命周期,并用超时让失活连接能够被主动回收。
学习目标
- 用
TaskGroup让读取、处理、写回任务统一启动和退出 - 用有界
Queue在任务之间传递数据并形成背压 - 用超时和取消保证异常连接不会留下后台任务
拆分连接内的职责
单连接可以分为读取任务、处理任务和写回任务。读取任务只负责把字节流还原成请求;处理任务只执行耗时业务;写回任务只负责序列化和 drain()。三者通过队列连接,避免彼此直接调用形成长调用链。

有界队列很关键。如果业务处理速度低于读取速度,put() 会在队列满时暂停读取任务,把压力传回 TCP 接收侧;如果使用无限队列,高峰期更容易把网络积压变成进程内存积压。
用 TaskGroup 管理三个协作任务
下面的完整示例启动一个本地 TCP 服务。每个连接创建读取、处理和写回三个任务;读取任务超过 3 秒没有收到新行会触发超时,TaskGroup 随即取消同组其他任务。示例使用换行作为最小消息边界,只为了突出任务生命周期。
import asyncio
QUEUE_SIZE = 8
READ_TIMEOUT = 3.0
async def reader_loop(
reader: asyncio.StreamReader,
requests: asyncio.Queue[str | None],
) -> None:
while True:
async with asyncio.timeout(READ_TIMEOUT):
data = await reader.readline()
if not data:
await requests.put(None)
return
await requests.put(data.decode().rstrip("\n"))
async def worker_loop(
requests: asyncio.Queue[str | None],
responses: asyncio.Queue[str | None],
) -> None:
while True:
message = await requests.get()
try:
if message is None:
await responses.put(None)
return
# 用短暂 sleep 模拟异步业务操作。
await asyncio.sleep(0.05)
await responses.put(f"ACK {message}")
finally:
requests.task_done()
async def writer_loop(
writer: asyncio.StreamWriter,
responses: asyncio.Queue[str | None],
) -> None:
while True:
message = await responses.get()
try:
if message is None:
return
writer.write((message + "\n").encode())
await writer.drain()
finally:
responses.task_done()
async def handle_connection(
reader: asyncio.StreamReader,
writer: asyncio.StreamWriter,
) -> None:
requests: asyncio.Queue[str | None] = asyncio.Queue(QUEUE_SIZE)
responses: asyncio.Queue[str | None] = asyncio.Queue(QUEUE_SIZE)
try:
async with asyncio.TaskGroup() as group:
group.create_task(reader_loop(reader, requests))
group.create_task(worker_loop(requests, responses))
group.create_task(writer_loop(writer, responses))
except* TimeoutError:
pass
finally:
writer.close()
await writer.wait_closed()
async def run_client(port: int) -> None:
reader, writer = await asyncio.open_connection("127.0.0.1", port)
try:
for message in ("PING", "STATUS"):
writer.write((message + "\n").encode())
await writer.drain()
response = (await reader.readline()).decode().rstrip("\n")
print(f"client: {message} -> {response}")
finally:
writer.close()
await writer.wait_closed()
async def main() -> None:
connection_done = asyncio.Event()
async def on_connection(
reader: asyncio.StreamReader,
writer: asyncio.StreamWriter,
) -> None:
try:
await handle_connection(reader, writer)
finally:
connection_done.set()
server = await asyncio.start_server(
on_connection,
"127.0.0.1",
0,
)
port = server.sockets[0].getsockname()[1]
print(f"server: listening on {port}")
async with server:
await run_client(port)
await connection_done.wait()
asyncio.run(main())预期输出
server: listening on <PORT>
client: PING -> ACK PING
client: STATUS -> ACK STATUS<PORT> 是操作系统分配的临时端口,实际值每次可能不同。该示例需要 Python 3.11 或更高版本,因为使用了 asyncio.TaskGroup 和 asyncio.timeout()。
明确正常结束与异常结束
正常 EOF 时,读取任务把 None 放入请求队列;处理任务收到后再把 None 放入响应队列,于是三个任务按数据流方向自然退出。哨兵值只用于表示“没有更多消息”,不要与合法业务数据混用。
异常路径则不同。读取超时、业务任务抛异常或写回失败都会让 TaskGroup 结束,并自动取消仍在运行的兄弟任务。连接关闭集中放在 finally 中,避免某个任务提前退出后遗留打开的 socket。
用队列大小和超时形成可控压力
队列容量不是越大越好。容量过小会让短暂抖动迅速传回读取侧,容量过大则会增加内存占用和排队延迟。可以先从一个保守的小值开始,再在压测中观察队列等待时间、请求延迟和内存曲线。
读取超时也应针对“长期无数据”而不是“业务处理慢”。业务处理如果需要独立时限,应在 worker_loop 内再包一层业务超时,这样能够区分客户端闲置和后端操作超时,日志与错误响应也更准确。
验收连接生命周期
压测前至少验证三类场景:客户端正常发送后关闭、客户端连接后长期不发数据、业务处理函数主动抛异常。三种情况下都应看到连接最终关闭,并且事件循环中没有不断增长的遗留任务。
把读取、处理和写回拆开后,收益不只是并发度更高,而是每个阻塞点都有清晰边界:队列负责背压,超时负责终止无效等待,TaskGroup 负责把失败扩散为同组任务的统一退出。这样的连接处理链路才适合继续做压力测试和容量调优。