以下 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
两行输出对应两件事:
- events:调度时点序列。周期任务在 tick 0、3、6、9 触发(每 3 tick 一次),延迟任务在 tick 5 触发一次。
delayed@5夹在两个周期任务之间,说明两种时间语义在同一套 Timer 里共存且各自准确。 - 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 | 判死风险 |
|---|---|---|---|
| 秒级交互 | 1s | 3s | 网络抖动易误杀 |
| 批量处理 | 10s | 30s | 发现死亡慢 |
| 长时间推理 | 30s | 120s | 中间无进展不可见 |
租约还有一个容易被忽略的用途:它天然是任务进度的心跳。每次续约除了"我还活着",还可以附带"我走到哪了"。这样不只在死任务时能判定,还能实时观测长任务的进展,而不是等它完成或判死才看到一次状态。租约从"存活证明"升级为"存活+进度"的双重信号。
租约过期后的重调度是长任务最复杂的场景。 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 进程、容器、微虚拟机 。
常见错误与边界
- 把延迟任务塞进普通队列。 延迟任务要"到点执行",普通队列"有空就跑",时点会漂移。
- 把周期任务当一次性。 周期任务要按周期重复,注册时用
every而不是schedule。 - 长任务没有租约。 没有存活证明,死任务会永远占着资源;租约过期即回收。
- TTL 写死。 TTL 必须与任务耗时匹配;TTL 太短会误杀慢任务,太长会让死任务拖很久。
- 以为租约要可靠心跳。 租约不需要可靠的心跳协议,只需"停止续约即死亡"的判定规则。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。