基础篇
进阶篇
高频篇
精选篇
手写篇
面经篇
AI 篇
原理篇
每日一题
小程序题库
  • 知识卡片碎片时间过考点
  • 场景篇按分类整理的大前端场景考点
  • 历年面经按年份追踪真实考点
  • 算法题库NEW在线编码即时判题
  • 专项自测100 题快速查漏
  • 前端基础
    • HTTP从报文一路讲到 HTTPS
    • 浏览器渲染、事件循环、进程
    • 计算机基础Linux、网络、操作系统
  • 进阶专项
    • 设计模式23 种模式怎么用
    • 前端系统进阶学习大型项目工程化
    • 前端综合文章长期沉淀的实践文
  • 工程与工具
    • Node学习指南从环境搭建到服务端
    • NPM工作流script、依赖与发布
    • Docker容器化部署上手
    • Canvas图形与动画实战
  • 路线与导图
    • 思维导图知识点全景图
    • 学习路线按图索骥不跑偏
  • 动态
    • 公众号动态公众号历史文章
    • 博客动态站长的技术博客
    • 开发者导航常用工具与文档站
    • AI 热点每日 AI 资讯与动向
AI 工作台
旧版
AIHT
内容
精选全部 AI 动态热点榜AI 日报收藏
分类
模型行业编程产品技术观点开源
更多
Agent 接入
返回首页开发者导航
AIHT
精选 / 资讯详情
8.0
热点
AI SCORE
技术实践2026-11-22 22:58

asyncio 限并发,还要限制待处理任务

dev.to · AI#Python#异步编程#背压
Editor brief · 编辑速览

对大量协程使用 gather 加信号量,虽然能限制并发请求,却仍会提前创建任务并持有输入数据。文章改用固定 worker 和有界队列,让下游模型变慢时通过队列阻塞向上游传递背压。

文章思维导图
Knowledge map
拖拽缩放
AI deep read

AI 深度解读

把模型请求的并发数设成 4,不代表程序只接收了 4 份工作。作者用一个 Python 示例说明:即使同时调用模型的请求只有 4 个,程序仍可能提前创建 1,000 个任务,让大部分任务拿着输入数据排队。

文章的结论是:处理持续到来的文档,除了限制正在执行的请求,还要限制尚未开始的积压。它值得读的地方,在于把并发、背压、速率限制和失败恢复拆开了。这几件事经常被一个 Semaphore 混在一起处理,实际却各管一段。

并发只有 4,为什么还有 1,000 个任务

常见写法是给每份文档创建一个协程,把它们交给 asyncio.gather,再用 asyncio.Semaphore(4) 包住模型调用。

Semaphore 能保证同一时刻最多 4 个调用进入受保护区域,却不会阻止外部继续创建任务。任务走到信号量前,已经存在,也已经持有对应文档的引用。

限制同时执行的数量,不等于限制已经接收的工作量。

如果输入只有 1,000 个很小的对象,问题可能不明显。但当文档来自数据库分页读取,模型响应又逐渐变慢,读取端若继续向前跑,等待任务及其引用的数据就可能越积越多。

作者的演示只使用标准库,要求 Python 3.11 或更高版本。虽然开头讨论的是 gather,实际对照代码两边都用 TaskGroup 等待任务完成,区别在于任务如何创建。

示例没有调用真实模型,而是用 asyncio.sleep(0.001 + (doc_id % 3) * 0.0002) 模拟耗时。输入为 range(1_000),作者本地运行得到:

Semaphore: tasks=1000, peak_active=4
Queue: tasks=4, peak_active=4, peak_queued=8

两种写法都达到 4 个活跃请求。变化发生在积压的组织方式:第一种创建 1,000 个文档任务,第二种只创建 4 个 worker 任务,队列最多存放 8 个待处理项。这里统计的是示例创建的工作任务,不是整个事件循环的任务总数。

让读取端停下来,队列才算发挥作用

作者建议使用 4 个 worker,配一个容量为 8 的队列。队列满时,生产者停在 await queue.put(doc_id);worker 取走一个元素,生产者才能继续。没有输入时,worker 则等待 get()。

这叫背压:下游处理不过来,上游也得放慢,不能一直往里塞。

下面是原文的队列实现。它把「每份文档创建一个任务」改成了「固定任务循环取文档」:

async def with_queue(doc_ids: range, workers: int, capacity: int) -> Counts:
    counts = Counts()
    queue: asyncio.Queue[int | None] = asyncio.Queue(maxsize=capacity)

    async def worker() -> None:
        while True:
            doc_id = await queue.get()
            try:
                if doc_id is None:
                    return
                await fake_model(doc_id, counts)
            finally:
                queue.task_done()

    async with asyncio.TaskGroup() as group:
        for _ in range(workers):
            group.create_task(worker())
            counts.tasks_created += 1

        for doc_id in doc_ids:
            if queue.full():
                counts.producer_waits += 1
            await queue.put(doc_id)
            counts.peak_queued = max(counts.peak_queued, queue.qsize())

        await queue.join()
        for _ in range(workers):
            await queue.put(None)

    return counts

最关键的是 await queue.put(doc_id):生产循环亲自等待空位,积压才不会跑到队列外面。如果给每次 queue.put() 再创建一个任务,队列虽然保持很小,等待入队的任务仍会堆起来。

在队列已满、所有 worker 都忙的时候,这部分流程最多持有 8 个等待项、4 个处理中项,以及生产者等待入队时拿着的 1 个 ID,合计 13 个。

但这不是内存字节数的上限。示例放进队列的是 ID;若换成整份 PDF,内存还取决于文档大小。若结果一直追加进列表,结果也会持续占用内存。作者因此建议逐份或小批量读文档,并在结果产生后及时保存。数据库读取层提前缓存多少,也需要单独检查。

队列管积压,配额和失败还得另外处理

4 个 worker 限制的是并发调用。假设服务商配额为每分钟 60 次请求,这属于另一种约束:响应越快,同样 4 个 worker 每分钟就可能发出越多请求。因此,请求发送前仍要执行独立的速率限制,队列容量无法代替它。

等待策略也要区分场景。离线批处理可以等待;HTTP 请求若直接无限等空位,客户端可能一直挂着。作者建议限制等待时间,或明确拒绝,让客户端稍后重试。put_nowait() 在队列已满时会抛出 QueueFull,可以作为显式处理满载的一条路径。

正常结束时,queue.join() 等待已接收的项目都得到 task_done(),随后发送与 worker 数量相同的 None,让 4 个 worker 退出循环。

异常路径由 TaskGroup 协调:某个 worker 抛出 CancelledError 以外的异常,会取消其他任务并使批次失败;整个批次被取消时,任务组等待内部任务完成退出。作者称,本地测试中,两种情况下 4 个 worker 都停止了,包括生产者正在等待队列空位的情况。

不过,停止干净不等于任务不会丢。队列只存在于进程内,函数退出后,尚未处理的 ID 会随之丢失。若需要重启续跑,就得持久化 ID,并在结果保存后标记完成,下次再加载未完成项。真实网络请求被取消后,远端也可能已经接收请求,重试前需要核实其状态。

我的判断

我赞同作者把「执行上限」和「积压上限」分开的做法。它直接对应两个不同问题:服务商能同时承受多少调用,以及当前进程愿意接收多少待处理工作。

但原文证明的范围要看清。作者实测的是模拟调用下的任务数、峰值并发和队列长度,没有给出真实模型、数据库读取、内存峰值或吞吐量的对照数据。不能据此宣称队列方案一定更快,或节省了多少内存;实际服务中的收益仍需测量。

容量 8 也只是便于观察的演示参数。队列持续满载、等待时间持续增长时,加大容量只会接纳更多等待文档,不会让模型处理得更快。作者建议观察等待时间和 worker 是否空闲,但没有给出容量选择公式。

对于规模明确、输入很小的批次,Semaphore 仍然简单适用。对于未知长度的数据流,有界队列更容易控制接收量;若还要求重启恢复,仅靠这段内存队列代码就不够了。

能拿来做什么

  • 修改现有 Python 模型批处理时,可以保留模型调用函数,把逐文档创建任务的循环换成固定 worker 和有界队列,并先保持原来的并发数,便于比较积压变化。
  • 从数据库读取文档时,让负责读取的生产者直接等待 queue.put(),同时检查分页缓存,并及时保存每份处理结果,避免输入端或结果端继续囤积数据。
  • 如果 Node 服务中也采用了「每条输入创建 Promise,再等待并发额度」的结构,可以用同样的问题检查它:等待对象是否持续增长,读取端能否随下游变慢而暂停。
  • 把批处理包装成 HTTP 接口前,明确队列满时等待多久、如何拒绝请求,并把服务商速率配额与重启恢复分别设计,避免把所有责任都交给队列。
Original source

本文由 AI 通读原文后重新编写,观点部分为站内判断,细节以原文为准,来源 dev.to · AI,原文版权归原作者所有。

阅读原文
上一篇
远程 MCP 实测:可达性之外还要看什么
下一篇
用小模型和检索搭建可溯源本地助手

资讯速览

dev.to · AI · 2026-11-22 22:58

AI 评分 8.0 / 10

相关标签

#Python#异步编程#背压

继续阅读

  • AI 写代码之后,如何把住交付质量
  • 远程 MCP 实测:可达性之外还要看什么
  • 用小模型和检索搭建可溯源本地助手
  • 给编码Agent设定间距令牌约束
  • Agent沙箱为何必须追踪文件读取历史