异步场景常见解决方案
异步场景常用搭配梳理表格
| 场景 | 数据流向 | 代码模式 | 关键组件 | 适用场景 |
|---|
| 1. 流式实时响应 | 生产者 → 队列 → 消费者 | create_task(生产者) + 队列 + StreamingResponse(消费者) | asyncio.Queue | 大模型流式输出、实时日志、SSE推送 |
| 2. 即时响应+后台处理 | 主流程 → 返回响应 → 后台任务 | BackgroundTasks.add_task(后台任务) | BackgroundTasks | 邮件发送、日志记录、文件清理 |
| 3. 长轮询/消息订阅 | 发布者 → 广播 → 多个订阅者 | asyncio.Queue + 广播机制 + 超时控制 | asyncio.Queue + asyncio.Event | 消息通知、实时数据订阅 |
| 4. WebSocket 双向通信 | 客户端↔服务器实时双向 | WebSocket.accept() + while True: receive/send | WebSocket | 聊天室、游戏、协同编辑 |
| 5. 任务进度查询 | 任务 → 存储状态 → 轮询查询 | create_task(任务) + 共享状态(dict/Redis) + 状态查询接口 | dict/Redis + 轮询API | 文件上传进度、批量任务处理 |
| 6. 异步数据库操作 | 请求 → 数据库查询 → 返回 | await db.fetch_all() | 异步DB驱动 | API接口、数据服务 |
| 7. 并发API调用 | 多个外部请求 → 并发执行 → 聚合 | asyncio.gather(*tasks) | asyncio.gather | 微服务聚合、多源数据获取 |
| 8. 定时/周期任务 | 定时触发 → 后台执行 | asyncio.create_task(周期性函数) + while True: await asyncio.sleep() | asyncio.sleep | 缓存刷新、心跳检查 |
| 9. 任务队列(Celery风格) | API → 任务队列 → Worker处理 → 回调 | celery.send_task() + 轮询/Webhook | Celery/RQ + Redis/RabbitMQ | 耗时任务、分布式处理 |
| 10. 流式文件处理 | 读取块 → 处理块 → 流式返回 | async for chunk in file_stream: yield processed_chunk | aiofiles + StreamingResponse | 大文件下载、实时转码 |
详细代码示例
1. 流式实时响应(你的场景)
@app.post("/chat")
async def chat_stream(request: Request):
queue = asyncio.Queue()
# 立即启动生产者
asyncio.create_task(llm_generate(request.query, queue))
async def stream_consumer():
while True:
chunk = await queue.get()
if chunk is None: # 结束信号
break
yield f"data: {chunk}\n\n"
return StreamingResponse(stream_consumer(), media_type="text/event-stream")
2. WebSocket 双向通信
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
async def producer():
while True:
data = await fetch_realtime_data()
await websocket.send_json(data)
await asyncio.sleep(1)
async def consumer():
async for message in websocket.iter_text():
await process_message(message)
# 同时运行生产者和消费者
await asyncio.gather(producer(), consumer())
3. 任务进度查询
# 存储任务状态
tasks_status = {}
async def long_task(task_id: str):
tasks_status[task_id] = {"progress": 0, "status": "running"}
for i in range(10):
await asyncio.sleep(2)
tasks_status[task_id]["progress"] = (i + 1) * 10
tasks_status[task_id]["status"] = "completed"
@app.post("/start-task")
async def start_task():
task_id = str(uuid.uuid4())
asyncio.create_task(long_task(task_id))
return {"task_id": task_id}
@app.get("/task-status/{task_id}")
async def get_status(task_id: str):
return tasks_status.get(task_id, {"status": "not_found"})
4. 并发API调用
async def fetch_user(user_id: int):
async with aiohttp.ClientSession() as session:
async with session.get(f"https://api.example.com/users/{user_id}") as resp:
return await resp.json()
@app.get("/users/batch")
async def get_users_batch(user_ids: list[int]):
# 并发获取所有用户
tasks = [fetch_user(uid) for uid in user_ids]
results = await asyncio.gather(*tasks, return_exceptions=True)
return {"users": results}
5. 周期性任务
class PeriodicTask:
def __init__(self, interval: float):
self.interval = interval
self.task = None
async def run_periodically(self):
while True:
try:
await self.do_work()
except Exception as e:
print(f"任务出错: {e}")
await asyncio.sleep(self.interval)
async def do_work(self):
# 实际工作
print(f"刷新缓存: {time.time()}")
def start(self):
self.task = asyncio.create_task(self.run_periodically())
@app.on_event("startup")
async def startup():
periodic = PeriodicTask(60) # 每分钟执行一次
periodic.start()
6. 流式文件处理
import aiofiles
@app.get("/download-large-file")
async def download_large_file():
async def read_and_send():
async with aiofiles.open("large_file.txt", mode="rb") as f:
while chunk := await f.read(8192):
yield chunk
await asyncio.sleep(0) # 让出控制权
return StreamingResponse(
read_and_send(),
media_type="application/octet-stream"
)
选择指南
| 需要什么 | 推荐模式 | 为什么不选其他 |
|---|
| 实时看到处理过程 | 流式实时响应 (#1) | BackgroundTasks 会延迟,WebSocket 太重 |
| 不关心处理过程 | 即时响应+后台处理 (#2) | create_task 需要自己管理生命周期 |
| 多用户实时交互 | WebSocket (#4) | SSE 只能单向,轮询效率低 |
| 知道任务ID,随时查进度 | 任务进度查询 (#5) | 流式响应需要保持连接 |
| 需要并行加速 | 并发API调用 (#7) | 串行太慢,多线程复杂 |
| 需要定时执行 | 周期性任务 (#8) | 用外部cron不够灵活 |
| 分布式、可靠、重试 | 任务队列 (#9) | 内存队列会丢失任务 |
核心原则总结
- 要实时推送 →
Queue + create_task + StreamingResponse
- 要事后处理 →
BackgroundTasks
- 要双向通信 →
WebSocket
- 要并发加速 →
asyncio.gather
- 要持久化任务 → 外部消息队列 (Celery/Redis)
- 要查进度 → 共享状态 + 轮询API
- 要定时任务 → 后台周期性函数
流式实时响应, create_task + Queue + StreamingResponse 是标准的最佳实践!