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

这里有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:】

view
source

 

print?

1.val
trigger = newTrigger().

2.startAt(DateUtils.addSeconds(new Date(),
-10)).

3.build()

同样的trigger，但是明确设置了misfire instruction handler（失火处理者）:

view
source

 

print?

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：

view
source

 

print?

01.val
trigger = newTrigger().

02.startAt(dateOf(9, 0, 0)).

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()去获取。 view source   print? 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：

view
source

 

print?

01.val
trigger = newTrigger().

02.startAt(dateOf(9, 0, 0)).

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（失火处理指令）。

view
source

 

print?

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的操作，等待下次执行就好了。