Python / 系统课时

优雅停机怎样避免丢请求

优雅停机怎样避免丢请求

异步服务收到停机信号后,如果立即取消全部任务,正在处理的请求会被截断;如果只停止监听却不管理存量任务,进程又可能一直退出不了。优雅停机的关键是分阶段收敛:先拒绝新连接,再等待在途请求,超时后才取消剩余任务,最后释放连接和共享资源。

学习目标

  • 设计“停止接收、排空请求、强制收尾、释放资源”的停机顺序
  • 用任务集合跟踪仍在执行的连接处理任务
  • 为排空阶段设置截止时间,避免优雅停机变成无限等待

停机要分成可观察的阶段

asyncio.Server.close() 会停止继续接收新连接,但已经建立的连接不会被一并强制关闭。因此,服务还需要显式跟踪正在运行的请求任务:先调用 close() 切断入口,再等待在途任务完成,之后再等待 Server 完整关闭。

异步服务优雅停机状态流程

一个实用的停机状态可以理解为:运行态允许接收新连接;排空态只处理已经进入系统的请求;若排空超时,则取消剩余任务;最后关闭仍存活的连接、数据库连接池等共享资源。新请求的入口必须先关,否则排空期间仍会不断增加任务。

用任务集合实现排空

下面的完整示例启动两个并发请求,然后在它们仍在处理时进入停机流程。服务先关闭监听器,再等待连接处理任务完成;只有超过 timeout 才取消仍未结束的任务。示例只使用标准库 asyncio,可直接观察两个在途请求如何被排空。

python
import asyncio
from contextlib import suppress

class GracefulServer:
    def __init__(self) -> None:
        self.server: asyncio.Server | None = None
        self.tasks: set[asyncio.Task[None]] = set()
        self.writers: set[asyncio.StreamWriter] = set()

    async def start(self) -> None:
        self.server = await asyncio.start_server(
            self.on_connect,
            "127.0.0.1",
            0,
        )

    @property
    def port(self) -> int:
        assert self.server is not None
        return self.server.sockets[0].getsockname()[1]

    def on_connect(
        self,
        reader: asyncio.StreamReader,
        writer: asyncio.StreamWriter,
    ) -> None:
        self.writers.add(writer)
        task = asyncio.create_task(self.handle_client(reader, writer))
        self.tasks.add(task)
        task.add_done_callback(self.tasks.discard)

    async def handle_client(
        self,
        reader: asyncio.StreamReader,
        writer: asyncio.StreamWriter,
    ) -> None:
        try:
            line = await reader.readline()
            if not line:
                return

            name, delay_text = line.decode().strip().split(",", 1)
            await asyncio.sleep(float(delay_text))

            writer.write(f"ok:{name}\n".encode())
            await writer.drain()
            print(f"request done: {name}")
        except asyncio.CancelledError:
            print("request cancelled")
            raise
        finally:
            self.writers.discard(writer)
            writer.close()
            with suppress(ConnectionError):
                await writer.wait_closed()

    async def shutdown(self, timeout: float) -> None:
        assert self.server is not None

        # 第一阶段:关闭监听器,立即停止接收新连接。
        self.server.close()
        print("stop accepting")

        snapshot = set(self.tasks)
        if snapshot:
            _, pending = await asyncio.wait(snapshot, timeout=timeout)
        else:
            pending = set()

        if pending:
            print(f"cancel remaining: {len(pending)}")
            for task in pending:
                task.cancel()
            await asyncio.gather(*pending, return_exceptions=True)
        else:
            print("active requests drained")

        await self.server.wait_closed()

        # 兜底关闭仍登记的连接;正常完成的连接已在 handler 中关闭。
        for writer in list(self.writers):
            writer.close()
        await asyncio.gather(
            *(writer.wait_closed() for writer in list(self.writers)),
            return_exceptions=True,
        )
        print("shutdown complete")

async def client(port: int, name: str, delay: float) -> bytes:
    reader, writer = await asyncio.open_connection("127.0.0.1", port)
    try:
        writer.write(f"{name},{delay}\n".encode())
        await writer.drain()
        return await reader.readline()
    finally:
        writer.close()
        await writer.wait_closed()

async def main() -> None:
    service = GracefulServer()
    await service.start()

    first = asyncio.create_task(client(service.port, "A", 0.10))
    second = asyncio.create_task(client(service.port, "B", 0.20))

    # 给两个连接一次事件循环调度机会,使它们进入服务端处理。
    await asyncio.sleep(0.05)
    await service.shutdown(timeout=1.0)

    replies = await asyncio.gather(first, second)
    print([reply.decode().strip() for reply in replies])

asyncio.run(main())

预期输出

text
stop accepting
request done: A
request done: B
active requests drained
shutdown complete
['ok:A', 'ok:B']

调度细节可能让两条 request done 日志的精确时间不同,但在本例的延迟设置下 A 会先于 B 完成。监听端口由操作系统动态分配,实际值不同不影响结果。

超时后的取消要有边界

排空时间不能无限长。生产服务通常根据请求的正常最长耗时设置一个停机截止时间;到期后取消仍在运行的任务,并等待这些任务执行各自的 finally。这一步不是为了“立刻杀掉”,而是让取消信号沿协程传播,给连接处理代码一次确定的清理机会。

如果请求内部调用了不响应取消的阻塞代码,Task.cancel() 也无法及时结束它。此时应把阻塞操作移到可控线程或进程,并为下游 I/O 设置自己的超时,而不是把停机超时当成唯一保护。

共享资源最后关闭

数据库连接池、消息客户端和线程池等共享资源应在请求任务排空之后再关闭。顺序反过来会让本可正常完成的在途请求因为依赖先被销毁而失败。

在真实服务中,停机信号只负责触发一次 shutdown 协程;shutdown 自己负责关闭监听器、等待任务、处理超时和释放共享资源。这样“收到 SIGTERM”“部署滚动更新”和“人工停止服务”都能复用同一条停机路径,也更容易验证是否真的做到不接新请求、尽量完成旧请求、最终按时退出。

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

目录与阅读设置

阅读设置

17

记录一个想法

优雅停机怎样避免丢请求

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

登录哪都通