Cron表达式解析器 - 字段解读、下次执行时间与Quartz/Linux方言

7753 字
39 分钟
Cron表达式解析器 - 字段解读、下次执行时间与Quartz/Linux方言

🌙 接手一个定时任务,先看懂那行表达式#

同事离职,你登上他留下的服务器,crontab -l 打出来七行:

0 3 * * * /opt/scripts/backup.sh
*/5 * * * * /usr/bin/curl -s http://127.0.0.1:8080/actuator/health
0 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 crontabQuartz
字段数56,或 7(带年)
是否含秒否,最小粒度 1 分钟是,最小粒度 1 秒
字段顺序分 时 日 月 星期秒 分 时 日 月 星期
日的取值范围1–311–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 * * ?。

除了倍数问题,补 * 还会踩到另外三个坑:

  1. **字段整体错位。**你以为第一位是分钟,其实 Quartz 把它当成了秒。原本「每 5 分钟」被读成「每 5 秒」的情形,就是这么来的。
  2. **星期编号体系不同。**Linux 里 1 是周一,Quartz 里 1 是周日。同一串数字换个方言,日期能差一周。
  3. 制造出非法表达式。* * * * * * 在 Quartz 里「日」和「星期」都写了值,两个都不是 ?,直接不符合规则。补 * 不是「补齐」,是把表达式改坏了。

所以这类工具都必须显式让你选方言,而不是自动猜。星点的 Cron 表达式解析 在界面上把方言作为必选项,解析器不会把五字段前置 * 变成六字段,也不会混着解释——同一串字符在两种方言下就是两套语义,混着读只会得出一个看起来合理、实际错误的结论。

📋 每个字段能填什么#

方言确定后,接下来看每个位置的取值范围。超出范围是最容易被抓到的错误,工具会把出错字段直接标出来。

Linux/Unix 五字段:

字段位置允许值说明
分10–59不支持 ?
时20–2324 点请写 0 点
日31–31超出当月天数的日期不会触发
月41–12 或 JAN–DEC名称大小写不敏感
星期50–7 或 SUN–SAT0 和 7 都表示周日

Quartz 六/七字段:

字段位置允许值说明
秒10–59写 60 视为错误
分20–59
时30–23
日41–31,可配 ? L W与「星期」互斥
月51–12 或 JAN–DEC
星期61–7 或 SUN–SAT,可配 ? L #1 是周日
年7(可选)1970–2099不写表示不限年份

特殊字符对照表:

字符含义例子LinuxQuartz只允许出现在
*该字段的任意值* 在「时」表示每小时支持支持所有字段
,列举多个值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 里也可能是「省略了秒」的错误写法,猜出来的结果反而误导人。

第二步:看字段解读#

「字段解读」标签下有三块内容:

  1. **校验结果。**合法就显示通过,不合法会定位到具体字段,比如「字段数错误:Linux 五字段,当前 6 段」「分钟超出 0–59」「Linux 方言不支持 ?」。错误定位到字段这一点很关键,长表达式靠肉眼找问题太慢。
  2. **自然语言摘要。**把整句翻成一句人话,用来快速确认「我写的是不是我想的」。
  3. **字段表格。**每个字段一行,列出字段名、原值、允许范围和这一位的解释。表里能一眼看出哪一位理解偏了,尤其是 */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 表达式解析工具 把这三步放在一个页面里,字段解读负责前两步,执行计划负责第三步,全部本地计算。写完表达式想再核对一遍,或者接手了一个看不懂的任务,直接粘进去就行。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

相关文章 智能推荐
1
Cron表达式生成器 - 在线生成Linux/Quartz定时任务表达式
时间工具 Cron 表达式生成器指南:先选 Linux 五字段或 Quartz 六字段方言,再用预设、表单、高级表达式三种方式生成定时任务表达式,实时校验并解释字段。含每分钟、每5分钟、每天2点、工作日 9:30、每周一、每月1日的两种写法对照,以及工作日不含节假日、每月 31 日、0 和 7 都是周日、时区由调度器决定等易错点,并说明如何带出验证下一次执行。
2
星点时间工具完整指南 - 时间戳/时区/日期计算/Cron 8个在线工具导航
时间工具 星点时间工具系列完整指南:时间戳转换、时区转换、日期时间格式化、时间差与日期差、日期计算器、时间字符串解析、Cron 表达式解析与生成共 8 个在线工具一站式导航。含按场景选工具、时间戳/UTC/IANA 时区/RFC3339/日历日/DST 概念对照表、三个典型工作流、五个常见误区与 FAQ,全部浏览器本地计算不上传。
3
时间字符串解析工具 - 识别日期格式、歧义与时区
时间工具 时间字符串解析工具:把接口、日志、Excel 和第三方数据里的时间文本解析成结构化字段,识别 ISO 8601 / RFC 3339、RFC 2822、日期时间、纯日期、时间戳与自定义模板;月日顺序歧义给出候选,纯数字先选时间戳单位,纯日期按所选时区解释,非法日期直接报错不归一化。含结果字段解读、常见错误与 FAQ。
4
时间差/日期差计算器 - 相隔天数、年月差与真实经过时长
时间工具 在线时间差与日期差计算器:把「两个时刻真实经过了多久」和「两个日期相差几天、几个月」分开算。时刻差给出总毫秒/秒/分/时/天与天时分秒分解,跨夏令时按实际经过;日期差给出相隔天数、周+余天、完整年月日与近似总月/年,可含起止日期。含两种口径对比表、跨夏令时实例、五个常见错误与操作步骤,浏览器本地计算。
5
Unix时间戳转换工具 - 时间戳与日期互转、秒/毫秒与当前时间戳
时间工具 在线 Unix 时间戳转换工具指南:时间戳与日期双向互转,秒/毫秒可自动判断也可手动指定,实时当前时间戳可暂停,秒与毫秒用 BigInt 精确换算。从日志排查、接口字段核对、数据库存秒、跨时区显示切入,讲清时间戳定义(1970-01-01T00:00:00Z 起算、不含闰秒),解释 UTC、RFC3339、星期与偏移,附精度对比表、2038 问题与常见错误。
随机文章 随机推荐
公告
🎉 已升级 2.0 版本,欢迎使用。
分类
标签
站点统计
文章
247
分类
31
标签
973
总字数
633,901
运行时长
0 天
最后活动
0 天前

目录