quartz问题记录-missed their scheduled fire-time

时间:2024-07-05 19:03:38

这里有3个原因:
1.所有的woker thread(工作线程; 辅助线程)都在运行其他的job
2.scheduler(调度器)down了(关于这个down。我不太明确是shutdown了。。还是挂掉了。因此下文依旧用down。)
3.任务被安排在过去的某一时刻启动(此可能为代码错误)

我的

我的解决方法:修改quartz.properties文件中的org.quartz.threadPool.threadCount的值增大。(从原来的10增大到20),

      最近公司加了好多定时任务,导致线程不够用,至此quartz挂掉。

以下来源于网上:

可以简单地通过配置quartz.properties文件中的org.quartz.threadPool.threadCount,来增加worker thread的数量(默认为10)。但是当整个 application/server/scheduler (调度器)挂掉的时候,这方法仍然是无效的。这种Quartz无法启动指定触发器情况,叫做 misfire(http://fanyi.baidu.com/#en/zh/misfire 以下统一用misfire,汉语无法贴切表达)。
你知道当这种情况发生的时候,Quartz能做些什么吗? 其实,Quartz有许多的策略(叫misfire instructions,失火指示)可以处理问题,并且当你没有去想这方面问题的时候,它也有许多默认策略。但是为了使你的应用更加稳定和可预测(尤其是在高负载和可维护性上),你应该有意识的去确保triggers 和 jobs工作正常。

基于你用的trigger,会有不同的配置选项(对misfire instructions有效)。当然,不同的trigger也会使Quartz有不同的行为(叫做smart policy,明智的决策)。尽管文档中有misfire instructions的描述,但是我发现都很难理解它所想表达的意思,因此,我写下这篇简短的总结。

在我深入细节之前,还有一个配置需要说明下:org.quartz.jobStore.misfireThreshold(毫秒级),默认是60000(一分钟)。它定义了trigger被认为是misfired了的时限。

基于默认配置,如果trigger应该在30秒以前被触发,那么很愉快地,Quartz就把它搞定了。这种延迟(delay)不能叫失火。

然而当trigger被发现,延迟了61秒时,那么专门的“失火处理者(misfire handler thread)”就会按照misfire instructions去处理它了。

为了测试效果,我们将这个时间设置为1000(即1秒),这样就能很快的测试“失火”了。

第一个例子,是一个不需要重复触发的普通trigger,我们来看看普通trigger调度器是怎么处理“失火”,并让它运行一次的:

【原文:Simple
trigger without repeating In our first example we will see how
misfiring is handled by simple triggers scheduled to run only once:】

1.val
trigger = newTrigger().
2.startAt(DateUtils.addSeconds(new Date(),
-
10)).
3.build()

同样的trigger,但是明确设置了misfire instruction handler(失火处理者):

1.val
trigger = newTrigger().
2.startAt(DateUtils.addSeconds(new Date(),
-
10)).
3.withSchedule(
4.simpleSchedule().
5.withMisfireHandlingInstructionFireNow() //MISFIRE_INSTRUCTION_FIRE_NOW
6.).
7.build()

为了测试,我将trigger设置为10秒前被调度(即当创建后,就已经晚于启动时间10秒)。在实际使用时,我们基本上永远不会这么设置。

换句话说,如果我们正确的设置了trigger,但是当需要被调度的时候,调度器down了或者没有空闲的worker thread了。那么,Quartz怎么处理这种extraordinary(罕见,古怪)的情况呢?

在第一段代码中,没有设置misfire instruction(so called smart
policy is used in that case 这句不太会翻译。。。。)。

第二段代码中,明确指定了当misfire发生时,我们希望采取的行为。

来看下表:

指令 Instruction 意义 Meaning
smart policy -
default
See: withMisfireHandlingInstructionFireNow
withMisfireHandlingInstructionFireNow
MISFIRE_INSTRUCTION_FIRE_NOW
调度器发现misfire情况后,立即执行job。

这是smart policy。
例如:

你让一些系统清理功能在2点执行。但是很不幸,应用在那段时间由于维护,关闭了,直到3点才恢复。这样trigger就misfire了,然后调度器会尝试修复这种情况,在3点启动后,尽快执行。
withMisfireHandlingInstructionIgnoreMisfires
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY
See: withMisfireHandlingInstructionFireNow
withMisfireHandlingInstructionNextWithExistingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT
See: withMisfireHandlingInstructionNextWithRemainingCount
withMisfireHandlingInstructionNextWithRemainingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
什么都不做。misfire被忽略了,并且没有后续的执行。当你想要彻底放弃被misfire的执行时,可以使用这个指令。
例如:
trigger是要启动录制一个电视节目。但是被misfire了,2个小时候,才发现。  
【PS: 这个不是太理解,只是按照原文翻译过来,如果要用,请自行测试。。。】
withMisfireHandlingInstructionNowWithExistingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT
See: withMisfireHandlingInstructionFireNow
withMisfireHandlingInstructionNowWithRemainingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT
See: withMisfireHandlingInstructionFireNow

普通trigger重复执行指定次数。这种情形更加复杂。想象一下,我们有一些需要重复执行指定次数的job:

01.val
trigger = newTrigger().
02.startAt(dateOf(900)).
03.withSchedule(
04.simpleSchedule().
05.withRepeatCount(7).
06.withIntervalInHours(1).
07.WithMisfireHandlingInstructionFireNow()  //or
other
08.).
09.build()

在这个例子中,trigger从今天9点开始(startAt(dateOf(9,
0, 0)),共触发8次(第一次执行,和7次重复)。

按理,最后一次执行应该在下午4点被触发。假设由于某些原因,在9点和10点调度器没有执行job,并且直到10:15才被系统发现misfire,也就是misfire了2次。这种情况下,调度器会怎么样呢?

指令 Instruction 意义 Meaning
smart policy -
default
See:withMisfireHandlingInstructionNowWithExistingCount
withMisfireHandlingInstructionFireNow
MISFIRE_INSTRUCTION_FIRE_NOW
See:withMisfireHandlingInstructionNowWithRemainingCount
withMisfireHandlingInstructionIgnoreMisfires
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY
尽快启动所有被启动的trigger,并将调度置为正常。
例如:

在我们上面的例子中,调度器会立即执行9点和10点的任务,并等待11点时,继续按正常的调度执行。
备注:当处理misfire时,我们同样要注意到,实际job执行的时间,已经滞后于应该执行的时间。这意味着,你不能简单地的依赖当前系统时间,而是应该使用 JobExecutionContext
.getScheduledFireTime()去获取。
1.def execute(context:
JobExecutionContext) {
2.val
date = context.getScheduledFireTime
3.//...
4.}
withMisfireHandlingInstructionNextWithExistingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT
调度器不会马上有反应。它会等待下一次执行,然后根据应该调度次数去运行trigger。
See also: withMisfireHandlingInstructionNextWithRemainingCount
例如:

在10点15发现2次misfire。调度器会等到11点,继续执行,并会每小时执行1次,共执行8次调度操作,直到下午6点停止(本该4点停止的。)
withMisfireHandlingInstructionNextWithRemainingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
调度器会抛弃被misfire的操作,然后等待下次执行。这样,执行的总次数,就会小于配置的次数。
例如:在10点15,2次misfire的执行都被丢弃了。调度器会等到下个执行时间-11点,然后继续触发其余的trigger,直到4点。事实上,这种情况就像misfire从未发生过一样。
withMisfireHandlingInstructionNowWithExistingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT
第一次misfire的trigger会立即执行,而后会按设置的间隔,依次执行剩余的trigger。实际上,就像misfire的trigger的第一次触发时间,被平移到了当前时间。

例如:

调度器会在10点15第一次运行misfire的trigger,然后隔1个小时,在11点15执行第二次。共执行8次,最后一次,在下午5点15。

withMisfireHandlingInstructionNowWithRemainingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT


第一次misfire的操作,被立即执行。其余被misfire的操作,会被抛弃。

剩余没有被misfire的trigger,会按固定间隔被触发。

例如:

调度器会在10点15运行第一次被misfire的操作(9点的。)。然后,它抛弃其余被misfire的(10点那一次)。最后,它会等1小时继续触发6个trigger:

11:15,12:15.... 4:15 PM。

这是一个基于指定间隔、并重复无数次的trigger:

01.val
trigger = newTrigger().
02.startAt(dateOf(900)).
03.withSchedule(
04.simpleSchedule().
05.withRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY).
06.withIntervalInHours(1).
07.WithMisfireHandlingInstructionFireNow()  //or
other
08.).
09.build()

trigger应该从今天9点开始(startAt(dateOf(9, 0, 0)),每隔小时触发一次。然而调度器在9点到10点都没有执行job(比如关闭了系统、线程不够等等。。前面有介绍),并且在10点15时才被发现,misfire了2次。这种情况比那种执行执行次数的trigger更加普遍。

指令 Instruction 意义 Meaning
smart policy -
default
See:withMisfireHandlingInstructionNowWithExistingCount
withMisfireHandlingInstructionFireNow
MISFIRE_INSTRUCTION_FIRE_NOW
See: withMisfireHandlingInstructionNowWithRemainingCount
withMisfireHandlingInstructionIgnoreMisfires
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY
https://jira.terracotta.org/jira/browse/QTZ-283
调度器会立即执行所有misfire的trigger,然后继续正常调度。
例如:

9点和10点的trigger会立即执行,下次执行将按计划执行(下一次是11点执行)。

withMisfireHandlingInstructionNextWithExistingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT
See:withMisfireHandlingInstructionNextWithRemainingCount
withMisfireHandlingInstructionNextWithRemainingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
不做任何事情,misfire的情况被忽略掉。然后,调度器按设置的间隔等待下次执行。
例如:

9点和10点misfire的执行被忽略掉。第一次执行会在11点会开始。
Example scenario: Misfired
execution at 9 and 10 AM are discarded. The first execution occurs at 11 AM.

withMisfireHandlingInstructionNowWithExistingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT
See:withMisfireHandlingInstructionNowWithRemainingCount
withMisfireHandlingInstructionNowWithRemainingCount
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT



第一次misfire的执行会被立即运行,其余的被忽略。下次执行会在设置的间隔时间后被触发。实际上,就是第一次执行被推迟到了当前时间。

例如:

调度器在10点15立即执行misfire的trigger,然后等待一个小时后,在11点15时,执行第二次。以后会每隔一小时。

定时触发    CRON trigger

定时触发是Quartz中最常见的。它有另外两个有效的trigger:DailyTimeIntervalTrigger(比如每25分钟一次)和CalendarIntervalTrigger(比如5个月执行一次)。They
support triggering policies not possible in both CRON and simple triggers.(不会译- -!),但是他们和CRON trigger一样,支持同样的misfire
handling instructions(失火处理指令)。

1.val
trigger = newTrigger().
2.withSchedule(
3.cronSchedule("0
0 9-17 ? * MON-FRI"
).
4.withMisfireHandlingInstructionFireAndProceed()  //or
other
5.).
6.build()

这个例子是,trigger在每周一到周五的早上9点到下午5点间,每小时被触发一次。但是两次触发被misfire了,并且在10点15时,才发现这个情况。请注意,他们的失火指令效果与普通trigger是不同的:

指令 Instruction 意义 Meaning
smart policy -
default
See: withMisfireHandlingInstructionFireAndProceed
withMisfireHandlingInstructionIgnoreMisfires
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY
https://jira.terracotta.org/jira/browse/QTZ-283
所有被misfire的执行会被立即执行,然后按照正常调度继续执行trigger。

例如:
9点和10点的执行(misfire的2个)被立即执行,下次执行将在11点被准时执行。
withMisfireHandlingInstructionFireAndProceed
MISFIRE_INSTRUCTION_FIRE_ONCE_NOW
立即执行第一次misfire的操作,并且放弃其他misfire的(类似所有misfire的操作被合并执行了)。然后继续按调度执行。无论misfire多少次trigger的执行,都只会立刻执行1次。
例如:

9点和10点的被合并执行一次(换句话说,10点需要执行的那次,被pass了)。下次执行将在11点被准时执行。
withMisfireHandlingInstructionDoNothing
MISFIRE_INSTRUCTION_DO_NOTHING
所有被misfire的执行都被忽略掉,调度器会像平时一样等待下次调度。
例如:

9点和10点的被忽略掉,好像什么都没发生一样。下次执行将在11点被执行。
   

QTZ-283Note: QTZ-283:
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY not working with JDBCJobStore
 - apparently there is a bug when JDBCJobStore is
used, keep an eye on that issue. (在用JDBCJobStore 时,MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY 没有生效。显然,这是在使用JDBCJobStore时的一个bug,关注下。)

如你所有,根据实际的设定,不同的trigger会有不同的行为。此外,虽然它提供了smart
policy(明智的决策),但是真正使用时,还是要取决于业务需求。

从本质上看,主要有三种策略:忽略,立即运行然后继续正常执行,忽略misfire的并等待下次执行。( 原文: ignore, run
immediately and continue and discard
and wait for next. )

它们有不同的应用场景:

当你需要确保每次调度任务都要被执行的时候,即时它意味着多个misfire的trigger会被触发,那么用ignore policies。试想一下,有一个任务,需要每小时,都根据上一小时的订单去生成报表。如果服务被关闭了8个小时,那你可能仍然是尽快得到那些报表的。这种情况下,配置ignore policies,调度器会尽快将那8小时的调度任务运行一遍的。尽管晚了几个小时,但是仍然是被执行了(最终报告到手了。^_^)。

当你需要任务被定期执行,并且当出现misfire的情况后立即运行一次的时候,那么使用now* policies。试想一下,一个任务是每分钟清空文件夹 /tmp。如果调度器在20分钟内繁忙,最后终于可以执行这个任务了,那么你肯定不会希望它执行20次的!一次就足够了,但是要尽快执行。而后,再回到正常的执行间隔--1分钟。

当你希望任务能在特定时间点运行的时候,使用next* policies不错。比如你需要在每个整点后15分钟抓取股票的价格。它们的变化非常快,然后现在已经整点后20分了,那么不必烦恼。你刚好错过了5分钟,但是现在你已经不在乎(那时候的价格)了。这时,一个时间间隙总好过一个不准确的值。这种情况Quartz只要跳过misfire的操作,等待下次执行就好了。