Cron表达式解析器 - 字段解读、下次执行时间与Quartz/Linux方言
🌙 接手一个定时任务,先看懂那行表达式
同事离职,你登上他留下的服务器,crontab -l 打出来七行:
0 3 * * * /opt/scripts/backup.sh*/5 * * * * /usr/bin/curl -s http://127.0.0.1:8080/actuator/health0 0 2 * * ?前两行看着眼熟,第三行末尾那个 ? 让人停住。同一套代码里,Java 服务上写着 @Scheduled(cron = "0 30 9 ? * MON-FRI"),配置文件里还有 cron: 0 0/10 * * * ?。三种写法都像 cron,抄来抄去却跑不起来。
第二种场景更常见:任务明明配了,就是不按预期跑。有的报表本该凌晨两点出昨天的数,实际早上八点才落库;有的健康检查本该每五分钟一次,日志里却一分钟出现了六十条;还有的每月一号任务,二月份干脆没执行。你去翻表达式,肉眼看不出毛病,只能一行一行数星号。
第三种是跨语言协作时的老问题。后端是 Java,调度用 Quartz;运维是 Linux,任务写在 crontab;容器里又跑着 Kubernetes CronJob。三个地方都叫「cron 表达式」,语法却各有一套:字段数不同,星期几的编号不同,?、L、W、# 有的认有的不认。把一个 Quartz 表达式贴进 crontab,或者把 crontab 里的五段表达式塞进 @Scheduled,得到的要么是报错,要么是悄悄跑错时间。
这三件事表面不同,根子是同一个:**Cron 不是一种语言,是一族方言。**写法接近,含义不通用。而且表达式只描述「什么时候触发」,不描述「在哪个时区、从哪一刻开始算下一次」。少了后面这半句,同一个表达式在不同机器上能跑出完全不同的结果。
星点 Cron 表达式解析工具 处理的就是这两件事:先把表达式按方言拆开、逐字段翻译成人话并校验;再按你指定的基准时间和时区,算出严格晚于基准的下一次执行和未来多次执行。全文里的例子都可以直接在页面上粘贴验证。
🧬 两种方言:五字段和六/七字段
看表达式之前,先确认它属于哪一族。这是所有解读的起点,搞错这一层,后面每个字段都会读偏。
Linux/Unix:五个字段
经典 crontab 的表达式是五段,从左到右固定是:
分 时 日 月 星期* * * * *没有「秒」这一位。最小粒度是一分钟,也就是说 crontab 里写不出「每 30 秒执行一次」这种事,只能靠脚本自己循环或者换成别的调度器。
五字段里的「日」指一个月里的第几天(1–31),「星期」指周几。这两个字段在 Linux 里是或的关系:当两个字段都被限定(都不是 *)时,只要有一个匹配,任务就会执行。这一点后面单独讲,它是 Quartz 用户最容易踩空的地方。
Quartz:六个字段,可选第七个
Quartz 风格的表达式是六段,最前面多了一个「秒」:
秒 分 时 日 月 星期* * * * * *顺序是「秒 分 时 日 月 星期」,第七段可选,是「年」(1970–2099)。Spring 的 @Scheduled 走的是六段这一套,少写一段在启动阶段就会失败;Quartz 的 CronTrigger 则允许你补上年份,把任务限定在某几年内。
两个方言摆在一起,差异一眼能看出来:
| 对比项 | Linux/Unix crontab | Quartz |
|---|---|---|
| 字段数 | 5 | 6,或 7(带年) |
| 是否含秒 | 否,最小粒度 1 分钟 | 是,最小粒度 1 秒 |
| 字段顺序 | 分 时 日 月 星期 | 秒 分 时 日 月 星期 |
| 日的取值范围 | 1–31 | 1–31 |
| 星期的取值 | 0–7,0 和 7 都是周日 | 1–7,1 是周日 |
? | 不支持 | 支持,仅用于「日」「星期」 |
L W # | 不支持 | 支持 |
| 年字段 | 无 | 可选 |
| 日与星期同时限定 | 允许,取「或」 | 不允许,必须有一个写 ? |
为什么不能「前置一个 *」把五字段当六字段
有人图省事,把五字段表达式前面补一个 *,就当六字段用。这个做法在所有情况下都是错的,而且错得很隐蔽。
拿 Linux 的 */5 * * * *(每 5 分钟一次,一小时 12 次,一天 288 次)举例。补一个 * 得到:
* */5 * * * *Quartz 会这样读:秒 = *,分 = */5。含义变成「在第 0、5、10……55 分钟里的每一秒都触发」。一天 288 × 60 = 17280 次,比原意多了 60 倍。如果这行是发短信、调接口、写日志的任务,后果自己算。
反过来也一样。Linux 的 0 2 * * * 是每天 02:00 执行一次,补 * 得到 * 0 2 * * *,含义是「02:00 这一分钟内的每一秒都执行」,一次变六十次。想要「每天 02:00 一次」,Quartz 的正确写法是 0 0 2 * * ?。
除了倍数问题,补 * 还会踩到另外三个坑:
- **字段整体错位。**你以为第一位是分钟,其实 Quartz 把它当成了秒。原本「每 5 分钟」被读成「每 5 秒」的情形,就是这么来的。
- **星期编号体系不同。**Linux 里
1是周一,Quartz 里1是周日。同一串数字换个方言,日期能差一周。 - 制造出非法表达式。
* * * * * *在 Quartz 里「日」和「星期」都写了值,两个都不是?,直接不符合规则。补*不是「补齐」,是把表达式改坏了。
所以这类工具都必须显式让你选方言,而不是自动猜。星点的 Cron 表达式解析 在界面上把方言作为必选项,解析器不会把五字段前置 * 变成六字段,也不会混着解释——同一串字符在两种方言下就是两套语义,混着读只会得出一个看起来合理、实际错误的结论。
📋 每个字段能填什么
方言确定后,接下来看每个位置的取值范围。超出范围是最容易被抓到的错误,工具会把出错字段直接标出来。
Linux/Unix 五字段:
| 字段 | 位置 | 允许值 | 说明 |
|---|---|---|---|
| 分 | 1 | 0–59 | 不支持 ? |
| 时 | 2 | 0–23 | 24 点请写 0 点 |
| 日 | 3 | 1–31 | 超出当月天数的日期不会触发 |
| 月 | 4 | 1–12 或 JAN–DEC | 名称大小写不敏感 |
| 星期 | 5 | 0–7 或 SUN–SAT | 0 和 7 都表示周日 |
Quartz 六/七字段:
| 字段 | 位置 | 允许值 | 说明 |
|---|---|---|---|
| 秒 | 1 | 0–59 | 写 60 视为错误 |
| 分 | 2 | 0–59 | |
| 时 | 3 | 0–23 | |
| 日 | 4 | 1–31,可配 ? L W | 与「星期」互斥 |
| 月 | 5 | 1–12 或 JAN–DEC | |
| 星期 | 6 | 1–7 或 SUN–SAT,可配 ? L # | 1 是周日 |
| 年 | 7(可选) | 1970–2099 | 不写表示不限年份 |
特殊字符对照表:
| 字符 | 含义 | 例子 | Linux | Quartz | 只允许出现在 |
|---|---|---|---|---|---|
* | 该字段的任意值 | * 在「时」表示每小时 | 支持 | 支持 | 所有字段 |
, | 列举多个值 | 1,15,30 | 支持 | 支持 | 所有字段 |
- | 范围 | MON-FRI、9-17 | 支持 | 支持 | 所有字段 |
/ | 步长 | */5、0/15 | 支持 | 支持 | 所有字段 |
? | 不指定(占位) | 0 0 2 * * ? | 不支持 | 支持 | 仅「日」「星期」 |
L | 最后 | L 当月最后一天;6L 最后一个周五 | 不支持 | 支持 | 日、星期 |
W | 最近的工作日 | 15W 离 15 号最近的工作日 | 不支持 | 支持 | 仅「日」 |
# | 第几个星期几 | 6#3 第三个周五 | 不支持 | 支持 | 仅「星期」 |
几个字符需要单独说清楚,因为它们最容易被望文生义。
*** 不是「每秒」或「每次」。**它只在当前字段的维度上表示「全都要」。0 0 2 * * ? 里的三个 * 分别表示「每月」「任意日」「每天」,整句合起来才是「每天 02:00:00 一次」。把 * 单独拎出来理解,永远读不对。
, 是列举,不是并集运算。0 9,18 * * * 是每天 9 点和 18 点各一次,不是 9 点到 18 点之间。想要区间用 -。
- 只是范围,不改变步长。0 9-17 * * * 是 9 点到 17 点之间每个整点都执行(9、10、11……17,共 9 次),不是「从 9 点干到 17 点一次」。
/ 的起点很关键。*/5 在分钟字段里表示 0、5、10……55,从 0 开始;3/5 表示 3、8、13……58,从 3 开始。同一个步长,换个起点,触发时刻全变。这一步不看清楚,「每 5 分钟」和「从第 3 分钟起每 5 分钟」就会混。
**? 不是「任意」,是「这块我不管」。**Quartz 里「日」和「星期」必须有一个写 ?,因为这两个字段在语义上冲突(比如「每月 1 号」和「每周一」不可能同时成立)。写了 ? 表示这个维度不参与限定。Linux 没有这个符号,五字段里写 ? 会直接报错——这是切换方言时最高频的失败原因。
**L 有两种读法。**放在「日」字段单独一个 L,表示当月最后一天;放在「星期」字段单独一个 L,表示 7,也就是周六;跟在数字后面(如 6L)表示「这个月的最后一个星期 X」。三种用法含义不同,位置决定含义。
W 只认工作日。15W 表示「离 15 号最近的那个周一至周五」。如果 15 号本身是周六,取 14 号(周五);是周日则取 16 号(周一)。跨月的情况,Quartz 会落在当月内,不会溢出到上一个月或下一个月。
# 指定第几个。6#3 是「每月第三个周五」。注意 Quartz 里 6 是周五(1 是周日),不是 Linux 里的周六。# 后面的数字只能是 1–5,因为一个月里同一天最多出现五次。
另外提一句:Quartz 还有 C(日历)之类的扩展字符,各家实现支持程度不一,星点这个工具首版覆盖的是 ? L W # 和名称别名,用了别的字符会在校验阶段被标出来,而不是被静默忽略。
🔍 六个表达式,逐个字段拆开看
下面挑几组实际工作中最常见的写法,按字段拆一遍。每个例子的表格都能对应到工具「字段解读」里的那三列:字段名、原值、解释。
例 1:0 */5 * * * ?(Quartz)
这是被问得最多的一个,也是很多人第一次见到 ? 的地方。
| 字段 | 值 | 含义 |
|---|---|---|
| 秒 | 0 | 每分钟的第 0 秒 |
| 分 | */5 | 从 0 起每 5 分钟:0、5、10……55 |
| 时 | * | 每小时 |
| 日 | * | 每天 |
| 月 | * | 每月 |
| 星期 | ? | 不限定 |
整句的意思是:每 5 分钟执行一次,落在整 5 分的那一秒。一小时 12 次,一天 288 次。写法上等价于 0 0/5 * * * ?。注意它不是在「上一次执行后五分钟」触发,而是固定在 0、5、10 这些整分点上——如果任务本身跑了 7 分钟,下一次仍然在整 5 分的网格上,中间会重叠或者被调度器丢弃,具体看实现。
例 2:0 0 2 * * ?(Quartz)
| 字段 | 值 | 含义 |
|---|---|---|
| 秒 | 0 | 第 0 秒 |
| 分 | 0 | 第 0 分 |
| 时 | 2 | 凌晨 2 点 |
| 日 | * | 每天 |
| 月 | * | 每月 |
| 星期 | ? | 不限定 |
每天早上 02:00:00 执行一次。这是「凌晨跑批」最标准的写法。如果写成 0 0 2 * * *,在 Quartz 里会因为「日」和「星期」都被写了值而不合法,必须把最后一位换成 ?。
例 3:0 30 9 ? * MON-FRI(Quartz)
| 字段 | 值 | 含义 |
|---|---|---|
| 秒 | 0 | 第 0 秒 |
| 分 | 30 | 第 30 分 |
| 时 | 9 | 上午 9 点 |
| 日 | ? | 不限定(由星期字段负责) |
| 月 | * | 每月 |
| 星期 | MON-FRI | 周一到周五 |
工作日早上 09:30:00 执行。这里 ? 出现在「日」上,是因为限定条件已经交给了「星期」。MON-FRI 也可以写成 2-6(Quartz 里 2 是周一、6 是周五),但写名称更不容易算错。
需要强调:**这里的「工作日」只是周一到周五,不包含任何法定节假日判断。**春节、国庆、调休上班的周六,它一概不知。想要真正的节假日日历,得在业务代码里判断,或者换成带节假日数据的调度方案。
例 4:*/10 * * * *(Linux)
| 字段 | 值 | 含义 |
|---|---|---|
| 分 | */10 | 每 10 分钟:0、10、20……50 |
| 时 | * | 每小时 |
| 日 | * | 每天 |
| 月 | * | 每月 |
| 星期 | * | 每天(不限定) |
每 10 分钟一次。这里没有秒字段,所以最小就是一分钟。如果从别处抄来的是 0 */10 * * * ?(六个字段),贴进 crontab 会直接失败——crontab 只认五段,多出来的那一段会被当作命令的一部分。
例 5:30 8 * * 1-5(Linux)
| 字段 | 值 | 含义 |
|---|---|---|
| 分 | 30 | 第 30 分 |
| 时 | 8 | 上午 8 点 |
| 日 | * | 任意日 |
| 月 | * | 任意月 |
| 星期 | 1-5 | 周一至周五 |
工作日早上 08:30 执行。Linux 里 1 是周一、5 是周五,这一点和 Quartz 正好错开一位:同一个 1-5,在 Quartz 里是「周日到周四」。
例 6:0 15 10 L * ?(Quartz)
每月最后一天的 10:15:00。L 在「日」字段单独出现,表示当月最后一天,28、29、30、31 都可能,由当月实际天数决定。月末结算、月度对账常这么写。如果业务要求「最后一个工作日」,L 做不到,得用 W 配合具体日期,或者干脆在代码里算。
例 7:0 0 12 ? * 6#3(Quartz)
每月第三个周五的 12:00:00。6#3 拆开是「6 号星期(周五)+ 第 3 个」。# 只能出现在星期字段,前面的数字是星期编号,后面的数字是当月第几次。如果某个月只有四个周五,这个表达式仍然有效,只是落在那个月的第三个周五上。
例 8:0 0 29 2 *(Linux)
只在闰年的 2 月 29 日 00:00 执行。非闰年没有 2 月 29 日,于是这些年份一次都不跑。这不算 bug,是表达式的必然结果:日期不存在,就不触发。类似的还有「每月 31 日」,在小月里会自动跳过。
对照着看这八个例子,会发现读表达式的顺序其实很固定:先确定方言和字段数,再逐位对号入座,最后把「日」和「星期」的关系处理清楚。工具里那三列(字段名、原值、解释)就是把这一步可视化,省得在纸上数位置。
⏱ 「下一次执行」到底按什么算
字段读懂只完成了一半。「这个任务下次什么时候跑」是另一个问题,而且答案依赖三个变量:基准时间、时区、方言实现。
严格晚于基准时间
工具算的是严格晚于基准时间的下一次。这一条必须说清楚,因为它决定了「刚好命中」时的行为。
假设基准时间是 2026-10-25 09:30:00,表达式是 0 30 9 ? * MON-FRI。09:30:00 这一刻正好是触发点,那么结果不是「就是现在」,而是下一个工作日(或下一个周一)的 09:30:00。
为什么这样定义?因为「下一次」在语义上指的是还没有发生的那一次。如果你要确认「现在这一秒是不是刚好在跑」,那是另一个问题,不该混进「下一次执行」里。有些调度器在补跑、追赶(misfire)场景下会返回当前时刻,那是调度器自己的补偿逻辑,和表达式解析不是一回事。
基准时间的来源
基准可以取「当前时间」,也可以手工指定一个过去或未来的时刻。手工指定在两种情况下特别有用:
- 排查历史问题:想知道上周三 14:00 那一刻之后,任务应该在哪几个时刻触发,用来和日志比对;
- 验证未来计划:上线前确认未来一周的触发点,尤其是「每月 1 日」「每月最后一天」「第三个周五」这类不规则节奏。
基准时间的精度也要留意。表达式的粒度是秒(Quartz)或分钟(Linux),基准却可能带毫秒。基准是 09:29:59.800 时,下一次是 09:30:00.000;基准是 09:30:00.000 时,下一次就跳到再下一次。差 200 毫秒,结果差一整个周期,这是排查「为什么少跑了一次」时的常见盲点。
时区:表达式本身没有时区
这是最容易出事、也最容易被忽略的一层。**Cron 表达式里不带时区信息。**同一个 0 0 2 * * ?,在 UTC 机器上意味着北京时间上午 10 点,在北京时间机器上才是凌晨 2 点。
谁决定时区?看谁在执行:
- Linux crontab:默认用守护进程所在系统的本地时区。容器里很常见的情况是基础镜像默认 UTC,于是「凌晨 2 点」实际跑在北京时间上午 10 点。部分实现支持在 crontab 里用
CRON_TZ指定时区,但这属于扩展,不是所有发行版都认。 - Quartz:由
Scheduler的TimeZone决定,CronTrigger也可以单独指定。所以一个 JVM 里可以同时存在按 UTC 和按 Asia/Shanghai 触发的任务,只看表达式看不出来。 - Kubernetes CronJob:按控制器所在时区解释,不写时区就按集群默认。
工具里时区是可选项,默认取你本机时区。要复现服务器行为,就把时区改成服务器实际使用的那个,再对一遍结果。如果两边的差异正好是整数小时(比如 8 小时),基本可以确定是 UTC 与东八区的问题,用 时区转换工具 把同一个瞬间摊到两个时区上一看就清楚了。
夏令时:一年两次的坑
使用夏令时(DST)的时区,每年有两次「不正常」的时段:
- 春季拨快:本地时间从 02:00 直接跳到 03:00,02:00–02:59 这一小时在当地不存在。写
0 30 2 * * ?的任务,在那一天会落空。不同实现的处理不一样:有的跳过当天,有的在时钟拨快后立刻补跑一次。 - 秋季拨慢:本地时间从 02:00 退回 01:00,01:00–01:59 出现两次。写在这一小时里的任务,可能被触发两次,也可能只触发一次,取决于调度器是否做去重。
这不是理论问题。做跨境业务、服务器在欧美区域的团队,每年都会遇到一两次「任务少跑」或「任务重复跑」的工单。判断方法很直接:看触发时间是不是落在切换日的那一小时里。
工具按所选时区的规则计算,遇到切换附近的时刻会在结果里给出提示,不会假装一切正常。真要精确到「一年跑 365 次还是 366 次」,本地时间的 cron 本身就不适合,得换成 UTC 或者用固定间隔调度。
窗口和次数
「未来多次执行」解决的是另一类问题:光看下一次不够,得看一段窗口内的分布。典型场景是对账任务——如果表达式算出来一天 288 次,而你预期是 24 次,那多半是把「每 5 分钟」和「每小时的第 5 分钟」搞混了。
密集表达式会触发频率提醒。像 * * * * * ? 这种每秒一次的写法,工具会明确告诉你它有多密,因为这类表达式在日志里几乎必然造成刷屏,也常常是配置失误的产物。
⚠️ 八类常见错误
下面这些,是在真实项目里反复出现的。每一条都能用工具复现,改完再算一遍就能确认。
1. 字段数不对
最典型的是把六字段贴进 crontab,或者把五字段塞进 @Scheduled。
- crontab 多一段:解析失败,或者多出来的那一截被当成命令的一部分,任务根本不执行;
@Scheduled少一段:Spring 启动时报「Cron expression must consist of 6 fields」,应用起不来;- Quartz 少一段:秒被当成分钟读,整体提前一小时甚至错位一整天。
数星号是最笨也最快的检查方法:0 */5 * * * ? 是六段,*/5 * * * * 是五段。数完再决定它属于哪一族。
2. 分钟、小时范围超限
60 * * * *(想表达「每小时的第 60 分」)、0 24 * * *(想表达「24 点」)、0 0 0 32 * *(32 号),这类写法都越界了。分钟和小时的有效范围是半开区间,0–59、0–23,24 点要写 0 点,跨天由「日」字段负责。
越界值的表现因实现而异:有的直接报错,有的取模回绕(60 变成 0),后者更危险——不报错,但跑在了错误的时间。工具的做法是把错误定位到具体字段,提示「分钟超出 0–59」,而不是猜你想表达什么。
3. 在 Linux 里用 ?
? 是 Quartz 的语法,经典 crontab 没有这个字符。把 0 0 2 * * ? 直接贴进 crontab,第五个字段是 ?,会解析失败。
正确的做法是二选一:要么把方言改成 Quartz,按六字段理解;要么改写成合法五字段,比如 0 2 * * *(每天 2:00)。注意改写时字段要整体左移一位,秒字段直接去掉,不能只删掉一个字符。
4. Quartz 里「日」和「星期」同时指定
0 0 2 * * * 在 Quartz 里不合法,因为「日」是 *、「星期」也是 *,两个维度都写了值。Quartz 要求这两个字段互斥,必须有一个是 ?。
固定日期的任务写成 0 0 2 1 * ?(每月 1 日 2 点),固定星期的任务写成 0 0 2 ? * MON(每周一 2 点)。二者不能同时限定——「每月 1 号且每周一」这种条件,cron 表达式本身表达不了。
反过来,Linux 允许两个都限定,而且语义是「或」。0 2 1 * 1 表示「每月 1 日 或 每周一」的 2 点,不是「1 号且是周一」。这个语义差异是跨方言迁移时最隐蔽的坑:表达式搬过去了,跑的次数却翻了好几倍。
5. 把 0 和 7 当星期日,或者搞混两套编号
Linux 的星期字段是 0–7,0 和 7 都表示周日,1 到 6 是周一到周六。Quartz 是 1–7,1 是周日,7 是周六。
后果很直接:想在周日跑的任务,Linux 写 0、Quartz 写 1;写反了就跑在周一。想避开周末,Linux 写 1-5,Quartz 写 2-6。用名称(SUN、MON)能规避一部分问题,但名称在个别老实现里不被支持,跨方言时仍然要确认。
还有一种混淆是把 7 当周六:在 Linux 里 7 是周日,在 Quartz 里 7 是周六。同一个数字,两边差了一天。
6. 以为「工作日」会自动跳过节假日
MON-FRI、1-5 只表示周一到周五。春节、国庆、调休上班的周末,它都不知道。五一假期里任务照跑,调休的周六它照休。
如果业务真的需要按节假日走,cron 表达式解决不了,得在任务内部判断交易日历,或者用支持节假日配置的调度系统。把这件事写进表达式里,是不可能的。
7. 每月 31 日和 2 月 30 日
0 0 3 31 * ? 只在有 31 号的月份执行:1、3、5、7、8、10、12 月。4、6、9、11 月直接跳过,2 月也跳过。
0 0 3 30 2 ? 这种写法更极端:2 月永远没有 30 号,任务一次都不会跑。工具不会把它「修正」成 2 月最后一天,因为那等于替你改了需求。要「每月最后一天」,用 L;要「2 月最后一天」,也在 Quartz 里用 L,Linux 则需要在脚本里判断。
8. 步长不是均匀间隔
*/7 在分钟字段里是 0、7、14、21、28、35、42、49、56,然后下一小时从头开始。56 到下一个 0 之间只隔 4 分钟,不是 7 分钟。
这在做「每 7 分钟拉一次数据」时会造成节奏不均,累积起来还会影响限流计算。要严格等间隔,cron 做不到,得用固定延迟调度或者自己记录上次执行时间。步长表达的是「在网格上每隔 N 取一个点」,不是「间隔 N 分钟」。
除了这八条,还有一个操作性错误值得单独提:**改完表达式没有重新加载。**crontab 改完要确认守护进程读到了新内容,Java 服务改完 @Scheduled 要重启或者走配置刷新。这类问题不是表达式的错,但排查时经常被算到表达式头上。
🛠 在工具里走一遍
页面分成「字段解读」和「执行计划」两个标签,对应上面说的两半工作。
第一步:选方言,贴表达式
打开 Cron 表达式解析,先在方言里选 Linux 或 Quartz,再把表达式粘进输入框。方言是必选的,工具不会根据字段数自动猜——因为五字段在 Quartz 里也可能是「省略了秒」的错误写法,猜出来的结果反而误导人。
第二步:看字段解读
「字段解读」标签下有三块内容:
- **校验结果。**合法就显示通过,不合法会定位到具体字段,比如「字段数错误:Linux 五字段,当前 6 段」「分钟超出 0–59」「Linux 方言不支持
?」。错误定位到字段这一点很关键,长表达式靠肉眼找问题太慢。 - **自然语言摘要。**把整句翻成一句人话,用来快速确认「我写的是不是我想的」。
- **字段表格。**每个字段一行,列出字段名、原值、允许范围和这一位的解释。表里能一眼看出哪一位理解偏了,尤其是
*/5和0/5这种只差一个字符的写法。
第三步:切到执行计划
「执行计划」需要三个输入:基准时间、时区、要看的次数。
- 基准时间默认是当前时间,可以改成任意时刻,用来复现历史或者预演未来;
- 时区默认取本机,验证服务器行为时改成服务器实际时区;
- 次数决定往后看多少条。
结果区给出严格晚于基准的下一次执行,以及后续多次执行的时间点,每条都带当地时间和 UTC、时区偏移、距离基准时间多久。密集表达式会额外给出频率提醒。跨夏令时切换的时刻会有提示,不会悄悄跳过。
第四步:复制或导出
单条结果可以直接复制,粘到工单、文档、群里都行。需要整段核对时用「导出 CSV」,把未来多次执行拉成表格,方便和日志、监控、对账记录逐行比对。CSV 里保留了时间、UTC 和偏移,跨时区核对时不用再手工换算。
反向操作:从计划生成表达式
如果手上只有「每周一早上 9 点半」这样的需求,先去 Cron 表达式生成器 用预设或表单生成表达式,再带回解析页验证下一次执行。生成和解析是一对:生成负责写对,解析负责确认写对了。生成器支持把表达式「同步到表单」拆回字段,也支持直接带出到执行预览,来回切换不用重新输入。
整条链路都在浏览器本地跑,表达式和基准时间不会上传。
❓ 常见问题
0 */5 * * * ? 到底是什么含义?
Quartz 六字段:秒 0、分每 5 分钟、时/日/月不限、星期用 ? 占位。合起来是「每 5 分钟的第 0 秒执行一次」,一小时 12 次,一天 288 次。等价写法是 0 0/5 * * * ?。
为什么在 Linux 模式下报 ? 不支持?
? 是 Quartz 的语法,经典 crontab 的五字段没有这个字符。要么把方言切成 Quartz,要么把它改写成合法五字段(去掉秒字段,整体左移一位)。
「下一次执行」为什么不是当前这一刻?
工具按「严格晚于基准时间」计算。基准时刻正好命中触发点时,返回的是它之后的下一次。这样定义是为了让「下一次」始终指向尚未发生的那一次,避免和「现在是否正在执行」混淆。
0 0 2 * * ? 为什么在服务器上是上午 10 点跑?
表达式不带时区。如果服务器系统时区是 UTC,2 点指的是 UTC 02:00,对应北京时间 10:00。把工具的时区改成服务器实际时区再算一遍就能对上;也可以把服务器的时区统一到业务时区,减少这类歧义。
? 和 * 有什么区别?
* 表示「这个字段取任意值」,? 表示「这个字段不参与限定」。在 Quartz 里「日」和「星期」必须有一个写 ?,因为两者语义冲突;写 * 仍然算「指定了值」,会触发互斥校验。Linux 没有 ?。
工作日会自动跳过法定节假日吗?
不会。MON-FRI、1-5 只认周一到周五,节假日和调休一概不知。需要按节假日调度,只能在任务内部判断交易日历,或者换用支持节假日配置的调度系统。
每月 31 日、2 月 29 日的任务会怎样?
当月没有这个日期时,任务不触发。0 0 3 31 * ? 在 4 月、6 月、9 月、11 月和 2 月都不跑;0 0 29 2 * 只在闰年跑。工具会照实计算,不会自动改写成「当月最后一天」。要最后一天请用 L。
Kubernetes、Spring、Jenkins 的写法都能解析吗?
工具首版显式支持两种方言:Linux/Unix 五字段与 Quartz 六/七字段。Kubernetes CronJob、Spring @Scheduled、Jenkins 等实现各有细节差异(字段数、是否支持 ?、星期编号),请在对应方言下验证,并以你实际使用的调度器行为为准。crontab 文件里的 @daily、@reboot 这类宏属于文件语法,不在表达式范围内。
表达式会上传吗?
不会。解析和计算都在浏览器本地完成,不产生网络请求。
收个尾
Cron 表达式本身不难,六个字段、几个符号,半小时能背下来。真正麻烦的是三件事:方言不统一、语义有边界、时区不写在表达式里。
方言不统一,所以贴之前先确认字段数和编号体系;语义有边界,所以「工作日不等于节假日」「31 号不是每个月都有」「步长不是等间隔」这些要先想清楚;时区不写在表达式里,所以拿到结果之后,还要问一句「这是哪个时区的几点」。
把这三件事拆开处理,剩下的就是机械劳动:逐位对号,算下一次,和日志比对。星点 Cron 表达式解析工具 把这三步放在一个页面里,字段解读负责前两步,执行计划负责第三步,全部本地计算。写完表达式想再核对一遍,或者接手了一个看不懂的任务,直接粘进去就行。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!