一个 SaaS 计费系统,每天凌晨两点跑对账:把前一天的订单和支付流水逐笔比对,差异写进异常表,正常的生成结算单。单机跑了半年没出问题。后来服务扩到三个实例,部署脚本在每个实例上都装了同一个 crontab。第二天财务发现,同一批商家被结算了三次,金额正好是三倍。

修复方式不是「把另外两台机器的 cron 删掉」那么简单。运维随后发现,只留一台也会漏:那台机器在凌晨一点五十重启,任务没触发,当天没有结算单;而手工补跑时,又因为和执行记录对不上,把已经结算过的商家再算了一遍。

定时任务的难点从来不是「怎么按时触发」,而是「怎么保证只执行一次、执行失败能补、多个实例不抢」。这篇按这三个问题讲,最后给一套不需要引入调度平台也能落地的方案。

四种翻车方式

现象真实原因第一步查什么
同一批数据被处理了两次或三次每个实例都装了定时器,没有抢占或去重查所有实例的 crontab 与任务执行日志,按实例分组
某天的任务完全没跑实例在触发点重启,或调度器进程挂了查任务执行记录表有没有当天那一行
任务跑了六个小时,下一次又启动了没有运行中超时保护,下一次触发时上一次还没结束看单次执行耗时分布与重叠的执行记录
手工补跑后数据翻倍补跑脚本没有复用幂等键,直接重新执行业务查补跑入口是否和执行记录共用同一套去重
不同机器上的任务时间差几分钟机器时钟漂移,或时区配置不一致对比各实例的 date 输出与容器时区
跨夏令时的任务提前或推迟一小时按本地时间调度,没有处理时区切换查调度表达式使用的是 UTC 还是本地时区
任务显示成功,数据却没写全批量处理中途异常,异常被吞掉,任务仍标记完成看任务是否记录处理条数与失败条数,异常是否上报

这七条里,第一条和第二条是最常见的组合:多实例重复执行,同时又会漏执行。它们不是互斥的,同一个系统可以今天重复、明天漏跑。根因都一样:任务的执行状态没有集中记录,谁跑、跑没跑、跑到哪,全靠各自机器上的日志。

触发方式:从简单到可控

单机 crontab 最简单,也最容易出问题。它只保证「在这台机器上到点启动一个进程」,不保证进程成功,不保证只启动一次,也不记录结果。适合一次性脚本、清理临时文件这类失败也无所谓的任务。

分布式调度平台(比如 XXL-Job、Airflow、Kubernetes CronJob)把触发、分发、重试、日志集中起来。好处是能看到所有任务的状态,能配置失败告警和补跑;代价是多一套要运维的系统,配置和权限也要管。

还有一种更土但很有效的办法:数据库轮询。每个实例都跑一个循环,每隔几秒查一次「有没有到期且没人认领的任务」,认领成功才执行。它不需要额外调度组件,执行状态和业务数据在同一个库里,事务好控制;代价是轮询有延迟,任务量大时查询会成为负担。

单机定时器实现最快,没有集中状态。只适合单实例、失败可接受的任务。多实例部署时,必须改成抢任务或只在一台启用。
调度平台状态集中、支持重试和补跑、有界面。适合任务多、需要审计的团队;要额外维护平台本身,并防止平台成为单点。
数据库轮询不引入新组件,状态和业务在同一事务里。适合任务数量中等、对触发延迟不敏感的系统;要注意轮询频率和锁竞争。

选型不用一步到位。任务少于十个、单实例,crontab 加执行记录表就够;实例变多,先加「抢占」;任务再多、需要人工补跑和审计,再上调度平台。

无论用哪种方式,任务都要有一份注册表:任务名、负责人、计划表达式、超时时间、失败是否告警、能否补跑。没有负责人和超时的任务,出事时没人认领,跑起来也没人知道它卡住了。注册表可以是一个配置文件,也可以是调度平台的元数据,关键是要和代码一起评审,不能只在某个人的 crontab 里。

执行键:幂等的起点

要让任务可重复执行而不产生重复结果,先给每次执行一个唯一的键。最常用的组合是「任务名 + 计划执行时间」,比如 reconcile:2026-11-06。同一个计划时间只允许成功执行一次,重复触发会被这个键挡住。

为什么用计划时间而不是实际开始时间?因为重试、补跑、多实例抢占时,实际开始时间每次都不同,用它做键等于没去重。计划时间是业务语义上的「这一次」,无论谁来跑、跑几次,都对应同一条记录。

执行记录表至少要有这些字段:任务名、执行键、状态、开始时间、结束时间、租约到期时间、处理条数、失败条数、错误摘要。状态用 pending、running、success、failed 四态,不要只用布尔值。

CREATE TABLE job_run (
  job_name     VARCHAR(64)  NOT NULL,
  run_key      VARCHAR(64)  NOT NULL,
  status       VARCHAR(16)  NOT NULL DEFAULT 'pending',
  lease_until  TIMESTAMP,
  started_at   TIMESTAMP,
  finished_at  TIMESTAMP,
  processed    BIGINT DEFAULT 0,
  failed       BIGINT DEFAULT 0,
  error        TEXT,
  PRIMARY KEY (job_name, run_key)
);

光有表还不够,业务写入也要幂等。对账生成结算单,结算单表用「商家 ID + 账期」做唯一键;发短信,用「用户 ID + 模板 + 业务键」做去重。任务层的执行键防的是「整个任务重复跑」,业务层的唯一键防的是「任务内部某条数据重复写」。两层都要有。

执行键的格式要稳定且可读。推荐「任务名 + 业务日期」,日期用 UTC 或固定业务时区,不要用带时区偏移的字符串,否则同一时刻可能生成两个不同的键。手工补跑时,允许指定一个不同的执行键,但业务层仍然按业务日期去重,这样既留了重跑余地,又不会产生重复数据。

不要用「先查执行记录,不存在就插入」来做去重。两个实例同时查,都说不存在,然后都插入,重复就发生了。要么用数据库唯一键,要么用原子占位,检查与写入必须是一个原子操作。

多实例抢任务:锁要原子,还要能过期

解决重复执行,本质是让多个实例竞争同一个执行权。常见三种做法:数据库行锁、Redis 分布式锁、租约。

数据库行锁最直接:用 SELECT ... FOR UPDATE SKIP LOCKED 取出到期任务,拿到锁的实例执行,其他实例跳过。好处是锁和业务数据在同一个事务里,不会因为网络分区出现「锁还在、持有者已经挂了」的尴尬;缺点是锁竞争会落到数据库上,任务特别多时要控制批量大小。

BEGIN;
SELECT id, job_name, run_key
FROM job_run
WHERE status = 'pending' AND run_key <= $1
ORDER BY run_key
LIMIT 10
FOR UPDATE SKIP LOCKED;

UPDATE job_run SET status = 'running', started_at = now(), lease_until = now() + interval '10 minutes'
WHERE id = ANY($2);
COMMIT;

Redis 分布式锁用 SET key value NX PX 300000,值要放一个只有持有者知道的随机串,释放时用 Lua 脚本比对值再删。不要用 DEL 直接删,否则可能删掉别人刚抢到的锁。锁一定要带过期时间,否则持有者崩溃后锁永远不释放。

锁的过期时间要大于任务的最长执行时间,否则任务还没跑完锁就失效,第二个实例会进来重复执行。如果任务可能跑很久,就在执行过程中定期续期;续期也要用「比对值再延长」的原子操作。注意网络分区:持有者以为自己还活着,实际上已经和 Redis 断开,续期失败,锁被别人拿走,两个实例同时执行。所以锁只是降低重复概率,最终仍要靠业务幂等兜底。

租约是锁的进化版:不追求「锁住」,而是声明「这段时间归我,过期作废」。执行过程中定期续租;实例挂了,租约到期,别的实例可以接手。它比永久锁更适合长任务,也允许任务在另一个实例上继续,代价是必须保证任务本身幂等,因为接手时可能重复处理一部分。

下面是我在本机用 Node 跑的一个对照:三个实例、十个计划时间点,分别模拟无锁、唯一键、租约三种方式。它只验证「谁执行」,不涉及真实锁的网络分区。

{ mode: 'none', executions: 30, expected: 10, first: 't0-w0,t0-w1,t0-w2,t1-w0' }
{ mode: 'unique', executions: 10, expected: 10, first: 't0-w0,t1-w0,t2-w0,t3-w0' }
{ mode: 'lease', executions: 10, expected: 10, first: 't0-w0,t1-w0,t2-w0,t3-w0' }

无锁时每个时间点被三个实例都执行了一次,总共 30 次;唯一键和租约都只有 10 次。注意这个模拟是单线程的,真实的并发竞争要靠数据库唯一约束或 Redis 原子命令来保证,不能只靠应用层判断。

漏执行:靠记录和补跑,不靠祈祷

漏执行通常发生在触发环节:实例重启、调度器挂了、机器时钟不对、任务被部署流程中断。解决思路不是「让触发绝对可靠」,而是「即使漏了,也能发现并补上」。

第一步是留下预期记录。调度器在每天开始时,就把当天的执行记录写成 pending;到点没有实例认领,它就一直留在那里。监控查「超过计划时间十分钟仍是 pending」的记录,就能发现漏跑。

第二步是补跑入口。补跑不是手工敲命令直接跑业务,而是走同一套认领流程:指定任务名和计划时间,创建或复用执行记录,然后由正常 worker 执行。这样补跑同样受唯一键保护,不会重复。

第三步是补偿窗口。对账、结算这类任务,不要只处理「昨天」,而是处理「上次成功时间到本次计划时间」之间的所有数据。某天漏了,第二天的任务会自动把漏掉的那天补上,前提是业务按日期分区且可重放。

如果业务无法重放,就只能靠对账发现差异,再人工处理。这时候执行记录里的处理条数、失败条数、时间范围就很重要,没有这些,补跑时根本不知道该从哪补。

监控要盯「预期但未完成」的任务,而不是只盯「运行失败」。一个任务可能从来没被触发,也就没有任何失败日志,只有查「计划时间已过、状态仍是 pending」才能发现。建议给每个关键任务配一条这样的查询,按任务的重要程度设置不同的容忍时长,支付对账容忍十分钟,缓存清理容忍一小时。

长任务:拆开、检查点、别重叠

一个任务跑六小时,本身就是一个风险:中途失败全量重来,部署窗口被占住,下一次触发又叠上来。处理长任务有三个手段。

拆成分片:按商家 ID 或日期范围切成小批,每个分片独立记录状态,失败只重跑失败的分片。分片还能并行,但并行度要受下游承受能力限制。

加检查点:每处理一千条记录,把「已处理到哪个 ID」写进执行记录。失败重启时从检查点继续,而不是从头开始。检查点要和业务写入在同一个事务里,否则会出现「检查点前进了、数据没写进去」。

加超时和心跳:任务开始时写租约,执行中定期续租;超过预定时间没有续租,其他实例可以判定它死了并接手。同时给单次执行设硬超时,超时后主动停止,避免拖到下一次触发。

长任务最好放在低峰期,并且和在线流量隔离。共用数据库连接池时,一个六小时的批量任务可能把连接占满,导致白天接口超时。给批处理单独配连接池或限流,是比「加机器」更有效的办法。

分片的粒度要能「失败后只重跑一小段」。按一百万条一刀切,失败一次就要重跑一小时;按一万条分片,失败最多重跑几分钟。分片键选业务上连续的字段,比如自增 ID 或日期,避免随机分片导致重复或遗漏。每个分片的完成状态也要落库,不能只存在内存里,否则 worker 重启就全忘了。

一套可落地的骨架

目录按「调度入口、认领、业务、补跑」分开,别让 cron 直接调用业务函数。

src/
  jobs/
    registry.js        任务名、计划表达式、超时时间
    claim.js           认领:唯一键或 SKIP LOCKED
    runner.js          执行、心跳续租、记录结果
    reconcile.js       具体业务,内部再按日期分片
    backfill.js        补跑入口,复用 claim + runner
  bin/
    tick.js            每十秒跑一次,负责生成到期任务

触发器只做一件事:把「该跑但还没跑」的任务写成 pending。真正执行由 worker 认领,这样触发器挂了也不会丢任务,恢复后还能补上。下面是触发器与 worker 的最小命令示例,实际部署时可换成 Kubernetes CronJob 或 systemd timer,未在本机实测。

# 每十秒生成到期任务
*/1 * * * * cd /app && node bin/tick.js >> /var/log/jobs/tick.log 2>&1

# worker 常驻,认领并执行
node bin/worker.js --concurrency 2

验证方法:在本地起两个 worker,手动插入一条 pending 任务,确认只有一个 worker 执行;把执行中的 worker 杀掉,租约到期后另一个 worker 接手,确认业务没有重复写入;把计划时间改成昨天但状态仍是 pending,跑一次 tick,确认补跑被触发且只执行一次。

psql -c "SELECT job_name, run_key, status, lease_until FROM job_run ORDER BY run_key DESC LIMIT 5;"
psql -c "SELECT COUNT(*) FROM settlement WHERE merchant_id = 42 AND period = '2026-11-06';"

换语言时,认领逻辑不变:Java 用 @Scheduled 加数据库锁,Go 用 time.Ticker 加 FOR UPDATE SKIP LOCKED,Python 用 APScheduler 加同一张执行记录表。调度表达式可以换,幂等键和状态机不能省。

边界与代价

数据库轮询不是银弹。任务多、轮询频繁时,SELECT ... FOR UPDATE 会成为数据库的负担;锁等待还会拖慢在线事务。任务超过几百个,就该考虑独立调度平台。

分布式锁解决不了业务幂等。锁只保证同一时刻只有一个执行者,不能保证执行结果正确。执行者拿到锁后处理到一半崩溃,下一个执行者仍可能重复处理,业务唯一键才是最后一道防线。

补跑会放大错误。如果任务本身有 bug,补跑十天的数据等于把错误重复十天。补跑前先在小范围验证,确认逻辑正确,再放开日期范围。

时区要写死。跨区域部署时,用 UTC 存时间、用业务时区解释「一天」的边界。依赖服务器本地时区,换一台机器就可能差八小时。

过度设计的信号:只有三五个任务、单实例,却上了分布式调度平台、租约、分片、检查点全套。先加执行记录表和唯一键,能解决大部分重复与漏跑。

当天可以自验的五件事

  1. 列出所有定时任务,标出哪些在多实例下会重复执行;没有执行记录表的,先补一张。
  2. 给最重要的任务加一条「计划时间已过仍是 pending」的查询,确认能发现漏跑。
  3. 用一个重复的业务键手工插入两次,确认第二次被唯一约束挡住,而不是产生两条数据。
  4. 在本地起两个 worker 抢同一条任务,观察是否只有一个执行;再杀掉持有者,看租约到期后能否接手。
  5. 把任务的处理时间范围和补跑方式写进 runbook,确认另一个人照着能补,而不是只有作者会。

下一篇讲日志、指标与链路追踪。任务和接口都跑稳之后,下一步是「出事时能不能快速知道哪一层坏了」。没有观测手段,前面这些幂等和限流设计,在故障现场都只能靠猜。