Python / 系统课时
优雅停机怎样避免丢请求
优雅停机怎样避免丢请求
异步服务收到停机信号后,如果立即取消全部任务,正在处理的请求会被截断;如果只停止监听却不管理存量任务,进程又可能一直退出不了。优雅停机的关键是分阶段收敛:先拒绝新连接,再等待在途请求,超时后才取消剩余任务,最后释放连接和共享资源。
学习目标
- 设计“停止接收、排空请求、强制收尾、释放资源”的停机顺序
- 用任务集合跟踪仍在执行的连接处理任务
- 为排空阶段设置截止时间,避免优雅停机变成无限等待
停机要分成可观察的阶段
asyncio.Server.close() 会停止继续接收新连接,但已经建立的连接不会被一并强制关闭。因此,服务还需要显式跟踪正在运行的请求任务:先调用 close() 切断入口,再等待在途任务完成,之后再等待 Server 完整关闭。

一个实用的停机状态可以理解为:运行态允许接收新连接;排空态只处理已经进入系统的请求;若排空超时,则取消剩余任务;最后关闭仍存活的连接、数据库连接池等共享资源。新请求的入口必须先关,否则排空期间仍会不断增加任务。
用任务集合实现排空
下面的完整示例启动两个并发请求,然后在它们仍在处理时进入停机流程。服务先关闭监听器,再等待连接处理任务完成;只有超过 timeout 才取消仍未结束的任务。示例只使用标准库 asyncio,可直接观察两个在途请求如何被排空。
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())预期输出
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”“部署滚动更新”和“人工停止服务”都能复用同一条停机路径,也更容易验证是否真的做到不接新请求、尽量完成旧请求、最终按时退出。