异步场景常见解决方案

异步场景常用搭配梳理表格

场景数据流向代码模式关键组件适用场景
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/sendWebSocket聊天室、游戏、协同编辑
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() + 轮询/WebhookCelery/RQ + Redis/RabbitMQ耗时任务、分布式处理
10. 流式文件处理读取块 → 处理块 → 流式返回async for chunk in file_stream: yield processed_chunkaiofiles + 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)内存队列会丢失任务

核心原则总结

  1. 要实时推送 → Queue + create_task + StreamingResponse
  2. 要事后处理 → BackgroundTasks
  3. 要双向通信 → WebSocket
  4. 要并发加速 → asyncio.gather
  5. 要持久化任务 → 外部消息队列 (Celery/Redis)
  6. 要查进度 → 共享状态 + 轮询API
  7. 要定时任务 → 后台周期性函数

流式实时响应, create_task + Queue + StreamingResponse 是标准的最佳实践!