《AI Agent 技术原理与架构·运行时、协议与系统架构》3.3 长任务、定时任务与延迟任务

三类任务有不同的时间语义:延迟任务推迟到指定时点执行一次,周期任务按周期重复,长任务靠租约续约证明自己还活着。实验用 tick 驱动的定时器与租约检查器演示三类任务的调度时点,以及忘记续约即被当作死任务的判定。结论是时间语义必须显式建模,过期判定要有明确规则。

以下 tick 数、租约 TTL、调度时点均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。TTL=3、周期=3 是讲解用的参数,真实系统按任务耗时和故障检测要求配置,但"忘记续约即被视为死任务"这一条不变。

3.2 讲了任务在队列里的并发控制。这一节换一个维度:任务的时间语义。不是所有任务都"排队马上跑"——有些要推迟、有些要周期性重复、有些会跑很久。

三类任务的时间语义不同,混在一起是运行时最常见的坑:把长任务当普通任务等它立刻返回,把延迟任务塞进普通队列,把周期任务当成一次性的。这一节把三类任务的调度时点讲清楚,并重点演示长任务的核心机制:租约。

三类任务的时间语义

类型时间语义例子
延迟任务推迟到指定时点,执行一次5 tick 后发提醒
周期任务按周期重复每 3 tick 做健康检查
长任务可能运行很久,需要证明活着批量处理、长时间推理

延迟任务要回答"什么时候触发":schedule(delay, callback) 把回调推迟到 current+delay 那个时点。周期任务要回答"多久一次":every(period, callback) 在当前 tick 数能被周期整除时触发。长任务要回答"还活着吗":靠租约续约证明。

长任务为什么需要租约

长任务的问题不是"慢",而是"不知道是不是挂了"。一个普通任务队列里,任务要么在跑要么在等;一个长任务可能已经死了(进程崩溃、网络断开),但系统不知道,以为它还在跑。

租约(lease)解决这个问题:长任务定期"续约",声明自己还活着;系统检查"距上次续约是否超过 TTL",超过就当作死任务处理。

状态判定
活着now − last_seen ≤ ttl
死亡now − last_seen > ttl

这个机制的关键词是忘记续约即死亡。任务不需要显式上报"我死了",只要停止续约,TTL 一过就被系统判定死亡。这解决了"不知道挂了"的问题——不需要可靠的心跳协议,只需要每次续约的时点。

最小实验:定时器与租约检查器

实验用一个 tick 驱动的 Timer 调度三类任务,并检查两个长任务(一个续约、一个遗忘)的存活。

# file: agp_lab/long_tasks.py | write
# tier: 3
# verify: python3 -m unittest tests.test_long_tasks
"""长任务、定时任务与延迟任务。

延迟任务用时间槽推迟到指定 tick,周期任务按周期重复,
长任务靠租约续约证明自己还活着,租约过期即被当作死任务。

本模块实现一个 tick 驱动的定时器与租约检查器,
演示三类任务的调度时点与"忘记续约即死亡"的判定。
"""
from __future__ import annotations

from typing import Any, Callable


class Timer:
    """tick 驱动的定时器:支持一次性延迟与周期任务。"""

    def __init__(self) -> None:
        self.current = 0
        self.due: dict[int, list[Callable[[], None]]] = {}
        self.periodic: list[tuple[int, Callable[[], None]]] = []

    def schedule(self, delay: int, callback: Callable[[], None]) -> None:
        self.due.setdefault(self.current + delay, []).append(callback)

    def every(self, period: int, callback: Callable[[], None]) -> None:
        self.periodic.append((period, callback))

    def tick(self) -> None:
        for callback in self.due.pop(self.current, []):
            callback()
        for period, callback in self.periodic:
            if self.current % period == 0:
                callback()
        self.current += 1


def lease_alive(last_seen: int, now: int, ttl: int) -> bool:
    """租约续约:now - last_seen <= ttl 才算活着。"""
    return now - last_seen <= ttl


def simulate(ticks: int = 12, lease_ttl: int = 3) -> dict[str, Any]:
    """跑三类任务:一次性延迟、周期、两个长任务(一个续约、一个遗忘)。"""
    timer = Timer()
    events: list[str] = []

    def delayed() -> None:
        events.append(f"delayed@{timer.current}")

    def periodic() -> None:
        events.append(f"periodic@{timer.current}")

    timer.schedule(5, delayed)
    timer.every(3, periodic)

    # 长任务:A 每个 tick 续约;B 在 tick 4 后停止续约。
    lease_a = 0
    lease_b = 0
    dead: list[int] = []

    for _ in range(ticks):
        lease_a = timer.current  # A 续约
        if timer.current <= 4:
            lease_b = timer.current  # B 续约直到 tick 4
        if not lease_alive(lease_b, timer.current, lease_ttl):
            dead.append(timer.current)
        timer.tick()

    return {
        "events": events,
        "lease_a_alive": lease_alive(lease_a, timer.current - 1, lease_ttl),
        "lease_b_dead_at": dead[0] if dead else None,
    }


def demo() -> dict[str, Any]:
    return simulate()


if __name__ == "__main__":
    result = demo()
    print("events:", result["events"])
    print(f"lease_a_alive={result['lease_a_alive']}")
    print(f"lease_b_dead_at={result['lease_b_dead_at']}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.long_tasks

输出:

events: ['periodic@0', 'periodic@3', 'delayed@5', 'periodic@6', 'periodic@9']
lease_a_alive=True
lease_b_dead_at=8

两行输出对应两件事:

  1. events:调度时点序列。周期任务在 tick 0、3、6、9 触发(每 3 tick 一次),延迟任务在 tick 5 触发一次。delayed@5 夹在两个周期任务之间,说明两种时间语义在同一套 Timer 里共存且各自准确。
  2. lease_a_alive=True, lease_b_dead_at=8:长任务 A 每个 tick 续约,始终活着;长任务 B 只在 tick ≤ 4 时续约,然后停止。TTL=3,所以 B 在 tick 8 时 now − last_seen = 8 − 4 = 4 > 3,被判定死亡。B 没有说"我死了",它只是停止续约,TTL 一过就被判死。

两个值得点破的细节:

  • 周期任务在 tick 0 就触发(0 % 3 == 0),而延迟任务在 tick 5 才触发。周期任务"马上开始、按周期重复",延迟任务"到点执行一次"——语义不能混。
  • lease_b_dead_at=8 不是 5。B 最后一次续约在 tick 4,TTL=3,所以判定死亡是在 tick 8(4 + 3 = 7,下一个检查点 8 才发现超期)。TTL 决定了死亡判定的滞后窗口:TTL 越长,误判越少但发现越慢;TTL 越短,发现越快但网络抖动容易误杀。

租约的参数(TTL、续约周期)要按任务特征配置,而且不同的长任务可能要不同的租约。一个批量推理任务 30 秒汇报一次就够了,一个秒级交互任务 3 秒不汇报就该判死。租约不是全局一个数,而是按任务类别配置的策略,跟优先级(3.1)、容量(3.2)一样都是任务属性。

任务类别续约周期TTL判死风险
秒级交互1s3s网络抖动易误杀
批量处理10s30s发现死亡慢
长时间推理30s120s中间无进展不可见

租约还有一个容易被忽略的用途:它天然是任务进度的心跳。每次续约除了"我还活着",还可以附带"我走到哪了"。这样不只在死任务时能判定,还能实时观测长任务的进展,而不是等它完成或判死才看到一次状态。租约从"存活证明"升级为"存活+进度"的双重信号。

租约过期后的重调度是长任务最复杂的场景。 Worker 崩溃前可能刚把任务执行到一半,重调度会让新 Worker 从头执行——如果任务不是幂等的,就会产生重复副作用。所以租约机制必须和"任务执行的可重入性"配合:要么任务被设计成可重放(纯计算),要么重调度前先做补偿或对账。

场景重调度动作前提
纯计算任务从头执行无副作用
有副作用的任务先补偿再重试见 5.3 Saga
对账任务从检查点续跑进度状态可读

租约也回答了"慢任务会不会被误杀"。 一个任务只是算得慢,但一直续约,它就不会被判死;判死只发生在"既不续约、也不完成"。续约周期因此要小于 TTL——如果续约周期接近 TTL,一次网络抖动就能误杀活任务。经验上续约周期取 TTL 的三分之一到一半,留足抖动余量。

长任务的进度可见性与租约是两件事,但常一起做。租约回答"任务还活着吗",进度回答"任务走到哪了"。只有前者,运维只能看到"还在跑";加上后者,才能判断"跑了 10 分钟只走了 10%,是不是有问题"。生产上把进度和租约合并进同一条心跳消息,一次汇报两个信息(见 3.3 的"租约即心跳")。

心跳内容回答运维动作
仅存活还活着无法判断快慢
存活+阶段走到哪步判断进展是否合理
存活+阶段+量完成了多少预估剩余时间

还有一个终态处理的边界:任务执行完后,租约要显式释放,否则租约到期被判死,任务被重调度——一个已完成的任务又被跑一遍。判死逻辑必须先查终态:任务若已标记完成,租约过期只是收尾清理,不是重调度。租约与终态标记的先后顺序,是长任务最常见的 bug 来源之一。

租约与计费、配额往往需要联动。 长任务占用的资源(GPU 实例、API 配额)在租约有效期内是承诺保留的——租约不只是"存活证明",还是"资源占用的授权凭证"。Worker 想续约,先看资源预算还有没有;预算耗尽,任务即使活着也该被降级或停止。租约把"任务生命周期"与"资源生命周期"绑定在同一个机制里。

资源状态租约动作说明
预算充足正常续约任务继续
预算紧张降级续约降低资源等级
预算耗尽拒绝续约停止或迁移

长任务还有一个边界:它会跨越部署窗口。 新版本上线、配置变更时,正在运行的长任务怎么办?直接杀掉会让它前功尽弃。生产上通常给长任务"排空窗口":部署前等它们自然完成,或把租约到期时间对齐到部署窗口。长任务与部署的配合,是它区别于短任务的又一个运维成本。

租约到期时间要可预期,任务才有"deadline 意识"。 长任务拿到租约时知道到期时间,能主动决定"在这之前完成"或"提前请求续约"。生产上把租约到期时间传给任务,让它可据此安排执行节奏——比任务无感知地被判死要好得多。让任务知道自己的生命周期,是长任务框架与"无状态任务"的分界。

长任务的结束要显式,不能只靠"租约到期"。 任务正常完成要主动上报终态(COMPLETED),而不是等租约过期被误判重调度。终态上报与租约释放要在一个事务里:先标记完成、再释放租约,两者原子——中间任何一个失败,都可能导致"已完成任务被重跑"。终态原子性是长任务正确性的最后一块拼图。

架构判据

时间语义建模是否合格,用五条判据检查:

判据合格的样子不合格的样子
语义分开延迟、周期、长任务各有机制全部塞进普通队列
触发准确到时执行、周期准确靠轮询近似,时点漂移
租约明确续约时点 + TTL 规则清晰长任务无存活证明
死任务处理租约过期即被判定并回收死任务永远占用资源
TTL 可配TTL 按任务耗时配置TTL 写死、与耗时无关

判据的核心是第三条:长任务必须有存活证明。 没有租约,长任务死了系统也不知道,会一直占着 Worker、占着资源、挡着后续任务。租约是这个问题的显式答案。

小结

  • 三类任务时间语义不同:延迟任务到点执行一次,周期任务按周期重复,长任务靠租约证明活着。
  • 租约解决"不知道长任务挂了":忘记续约、TTL 一过即被判死,不需要可靠心跳。
  • 实验演示了调度时点(周期 0/3/6/9、延迟 5)与死亡判定(B 停止续约后在 tick 8 被判死)。
  • TTL 决定死亡判定的滞后窗口:越长越稳但越慢,越短越快但易误杀。

阅读导航:上一节:3.2 并发上限、背压与取消 · 下一节:4.1 进程、容器、微虚拟机 。

常见错误与边界

  1. 把延迟任务塞进普通队列。 延迟任务要"到点执行",普通队列"有空就跑",时点会漂移。
  2. 把周期任务当一次性。 周期任务要按周期重复,注册时用 every 而不是 schedule。
  3. 长任务没有租约。 没有存活证明,死任务会永远占着资源;租约过期即回收。
  4. TTL 写死。 TTL 必须与任务耗时匹配;TTL 太短会误杀慢任务,太长会让死任务拖很久。
  5. 以为租约要可靠心跳。 租约不需要可靠的心跳协议,只需"停止续约即死亡"的判定规则。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图