AI 内容创作 / 系统课时

并发控制与任务调度

并发控制与任务调度

数字人服务同时处理语音识别、对话生成、语音合成和逐帧渲染时,单纯增加线程会放大显存争用、会话串扰和超时堆积。本课建立一套可落地的调度模型:同一会话串行、不同会话并行、全局容量受控,并让高优先级、取消和超时都能被正确处理。

学习目标

  • 设计会话隔离、全局并发上限和有界任务队列。
  • 使用优先级、超时与取消机制避免长任务拖垮服务。
  • 通过可运行示例验证调度结果,并识别上线时的关键风险。

调度模型与关键边界

并发控制应分成接入、排队和执行三层。接入层限制队列长度并决定拒绝、降级或转异步;排队层按照优先级、入队顺序和截止时间选择任务;执行层同时保护会话状态与 GPU、编码器等稀缺资源。只限制 worker 数量,无法阻止同一会话的两个任务并发修改播放器、缓冲区或 generation_id。

控制层 保护对象 推荐机制 主要失败信号
接入层 服务总容量 有界队列、速率限制、租户配额 队列满、拒绝率升高
会话层 单个会话状态 session_id 对应的锁或串行队列 状态覆盖、旧结果回写
资源层 GPU、编码器、模型实例 信号量或资源池 显存不足、延迟突增
时限层 任务生命周期 截止时间、取消令牌、幂等键 超时、僵尸任务、重复结果

数字人并发控制与任务调度架构

优先队列通常使用“优先级 + 递增序号”作为排序键,既保证高优先级先执行,又让同级任务保持先进先出。持续到来的高优先级任务可能造成饥饿,因此生产系统应加入等待时间加权、租户配额或加权公平队列。已经开始执行的任务不会被普通优先队列自动抢占,真正的抢占还需要下游推理、TTS 和渲染链路配合取消。

全局并发上限应通过压测确定,而不是直接等于 CPU 核数。GPU 场景可先用 floor((可用显存 - 常驻显存) / 单任务峰值显存) 估算,再根据显存碎片、批处理和延迟目标下调。内存队列仅适合单进程示例;多实例部署还需要外部消息系统、任务租约和故障后的重新投递。

完整可运行示例

本例用 Python 3.11 和单事件循环。调度器只从有空闲会话的任务中按优先级与顺序选择,避免同会话锁住多个工作器。队列有上限,时限从接收请求开始。取消使用显式任务 ID。

python
import asyncio
import itertools
import math
from dataclasses import dataclass


@dataclass
class Job:
    id: str
    session: str
    priority: int
    order: int
    deadline: float
    work: object
    result: asyncio.Future


class Scheduler:
    def __init__(self, slots=2, waiting_limit=8):
        if type(slots) is not int or type(waiting_limit) is not int or min(slots, waiting_limit) <= 0:
            raise ValueError("positive scheduler bounds required")
        self.slots, self.waiting_limit = slots, waiting_limit
        self.waiting, self.active = [], {}
        self.order = itertools.count()
        self.wake = asyncio.Event()
        self.accepting = True
        self.running = False

    def submit(self, ident, session, priority, ttl, work):
        if not self.accepting or len(self.waiting) >= self.waiting_limit:
            raise RuntimeError("not accepting or queue full")
        if not math.isfinite(ttl) or ttl <= 0:
            raise ValueError("positive deadline required")
        if any(job.id == ident for job in self.waiting) or any(job.id == ident for job, _ in self.active.values()):
            raise ValueError("duplicate job in progress")
        loop = asyncio.get_running_loop()
        result = loop.create_future()
        self.waiting.append(Job(ident, session, priority, next(self.order), loop.time() + ttl, work, result))
        result.add_done_callback(lambda _: self.wake.set())
        self.wake.set()
        return result

    def cancel(self, ident):
        for job in self.waiting:
            if job.id == ident:
                self.waiting.remove(job)
                if not job.result.done():
                    job.result.set_result("cancelled")
                self.wake.set()
                return
        for job, task in self.active.values():
            if job.id == ident:
                task.cancel()
                return

    def close(self):
        self.accepting = False
        self.wake.set()

    def completed(self, job, task):
        del self.active[job.session]
        result = "cancelled" if task.cancelled() else task.result()
        if not job.result.done():
            job.result.set_result(result)
        self.wake.set()

    async def execute(self, job):
        try:
            async with asyncio.timeout_at(job.deadline):
                return await job.work()
        except TimeoutError:
            return "timed_out"
        except Exception:
            return "failed"

    async def run(self):
        if self.running:
            raise RuntimeError("scheduler already running")
        self.running = True
        try:
            await self.dispatch()
        finally:
            self.accepting = False
            for job in self.waiting:
                if not job.result.done():
                    job.result.set_result("cancelled")
            self.waiting.clear()
            tasks = [task for _, task in self.active.values()]
            for task in tasks:
                task.cancel()
            await asyncio.gather(*tasks, return_exceptions=True)
            self.running = False

    async def dispatch(self):
        loop = asyncio.get_running_loop()
        while True:
            self.wake.clear()
            for job in list(self.waiting):
                if job.result.done() or loop.time() >= job.deadline:
                    self.waiting.remove(job)
                    if not job.result.done():
                        job.result.set_result("timed_out")
            while len(self.active) < self.slots:
                candidates = [job for job in self.waiting if job.session not in self.active]
                if not candidates:
                    break
                job = min(candidates, key=lambda item: (item.priority, item.order))
                self.waiting.remove(job)
                task = asyncio.create_task(self.execute(job))
                self.active[job.session] = (job, task)
                task.add_done_callback(lambda finished, job=job: self.completed(job, finished))
            if not self.accepting and not self.waiting and not self.active:
                return
            until = min((job.deadline for job in self.waiting), default=None)
            try:
                async with asyncio.timeout_at(until):
                    await self.wake.wait()
            except TimeoutError:
                pass


async def main():
    scheduler = Scheduler()
    release = asyncio.Event()

    async def held():
        await release.wait()
        return "first finished"

    async def quick():
        return "second session finished"

    first = scheduler.submit("a1", "a", 0, 2, held)
    expires = scheduler.submit("a2", "a", 1, .05, quick)
    other = scheduler.submit("b1", "b", 2, 2, quick)
    runner = asyncio.create_task(scheduler.run())
    print(await other)
    print(await expires)
    release.set()
    print(await first)
    scheduler.close()
    await runner


if __name__ == "__main__":
    asyncio.run(main())

保存为 digital_human_scheduler.py,运行 python digital_human_scheduler.py。

text
second session finished
timed_out
first finished

示例表明会话 A 排队的短期限任务不会阻塞会话 B。生产中调用方断开时应明确派发取消。已开始的 GPU 计算和外部业务操作可能无法立即撤销,需要向下传播取消、保持资源租约并隔离旧生成代次。真实运行还要加入租户配额、优先级饥饿治理和持久幂等记录。

上线检查与常见错误

上线前至少验证队列长度、活跃任务数、排队时长、执行时长、超时率、取消率和各 worker 负载。会话锁字典必须在会话结束后清理,否则长期运行会积累无用对象。任务失败后的重试应携带幂等键,并区分可重试错误、业务拒绝和用户主动取消,避免重复生成或重复计费。

  • 只设全局并发,不做会话隔离:同一会话可能同时修改状态,修复方式是会话级锁、Actor 或单会话队列。
  • 只在 API 层返回超时:后台协程仍继续消耗 GPU,修复方式是传播取消并在 finally 中释放资源。
  • 固定高优先级永久优先:普通任务可能长期得不到执行,修复方式是优先级老化、配额或加权公平调度。
  • 无界队列吸收所有请求:服务看似不拒绝,实际延迟持续增长,修复方式是设置容量、截止时间和明确的过载策略。

本课总结

  • 稳定调度需要同时控制接入容量、会话串行性和全局稀缺资源。
  • 优先级只决定待执行任务的顺序,取消传播和迟到结果过滤才能完成真正的中断。
  • 超时、重试和负载分配必须与指标、幂等性及资源清理一起设计。

下一课预告

下一课将学习“监控、隐私与安全合规”,把队列、延迟和错误转化为可观测指标,同时为声音、肖像、日志和生成内容建立授权、脱敏与审计闭环。

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

目录与阅读设置

阅读设置

17

记录一个想法

并发控制与任务调度

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

登录哪都通