Python / 系统课时

把连接处理拆成独立任务

把连接处理拆成独立任务

一个连接同时承担读取、业务处理和写回时,任何一步阻塞都会拖住整条链路。本篇把单连接拆成三个协作任务,用有界队列提供背压,用 TaskGroup 管理共同生命周期,并用超时让失活连接能够被主动回收。

学习目标

  • 用 TaskGroup 让读取、处理、写回任务统一启动和退出
  • 用有界 Queue 在任务之间传递数据并形成背压
  • 用超时和取消保证异常连接不会留下后台任务

拆分连接内的职责

单连接可以分为读取任务、处理任务和写回任务。读取任务只负责把字节流还原成请求;处理任务只执行耗时业务;写回任务只负责序列化和 drain()。三者通过队列连接,避免彼此直接调用形成长调用链。

单连接异步任务处理链路

有界队列很关键。如果业务处理速度低于读取速度,put() 会在队列满时暂停读取任务,把压力传回 TCP 接收侧;如果使用无限队列,高峰期更容易把网络积压变成进程内存积压。

用 TaskGroup 管理三个协作任务

下面的完整示例启动一个本地 TCP 服务。每个连接创建读取、处理和写回三个任务;读取任务超过 3 秒没有收到新行会触发超时,TaskGroup 随即取消同组其他任务。示例使用换行作为最小消息边界,只为了突出任务生命周期。

python
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())

预期输出

text
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 负责把失败扩散为同组任务的统一退出。这样的连接处理链路才适合继续做压力测试和容量调优。

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

目录与阅读设置

阅读设置

17

记录一个想法

把连接处理拆成独立任务

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

登录哪都通