Quartz框架（一）—Quartz的基本配置
Quartz框架（二）—jobstore数据库表字段详解
Quartz框架（三）—任务的并行/串行执行
Quartz框架（四）—misfire处理机制
Quartz框架（五）— 有状态的job和无状态job
Quartz框架（六）— Trigger状态转换
Quartz框架（七）— Quartz集群原理
Quartz框架（八）— Quartz实现异步通知
Quartz框架（九）— 动态操作Quartz定时任务
Quartz框架（十）监听
若是多线程时，能够控制同一时刻相同的JOB只能有一个在执行。原因是由于定时执行频率是30s，然而可能30s后该job还没结束。结果另一个线程再次启用同一job下的方法。
我们希望前一个job结束后才能进行下一次的调用。那该如何设计呢？
1. 提出问题
任务类：
@Component
public class TestJob2 extends CustomQuartzJobBean{
private Logger logger = LoggerFactory.getLogger(TestJob2.class);
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
logger.info("【数据库配置定时】-【开始】");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
logger.info("【数据库配置定时】-【结束】");
}
}
但定时是[*/1 * * * * ?]，即1s执行一次。
2019-07-04 14:44:21,010 INFO [51877] [clusteredScheduler_Worker-10] [] (TestJob2.java:24): 【数据库配置定时】-【开始】
2019-07-04 14:44:21,011 INFO [51878] [clusteredScheduler_Worker-8] [] (TestJob2.java:30): 【数据库配置定时】-【结束】
2019-07-04 14:44:22,009 INFO [52876] [clusteredScheduler_Worker-5] [] (TestJob2.java:30): 【数据库配置定时】-【结束】
2019-07-04 14:44:22,010 INFO [52877] [clusteredScheduler_Worker-1] [] (TestJob2.java:24): 【数据库配置定时】-【开始】
2019-07-04 14:44:23,011 INFO [53878] [clusteredScheduler_Worker-3] [] (TestJob2.java:24): 【数据库配置定时】-【开始】
2019-07-04 14:44:23,010 INFO [53877] [clusteredScheduler_Worker-10] [] (TestJob2.java:30): 【数据库配置定时】-【结束】
可以看到，此时的任务是并发执行。
因为将scheduler存储在数据库中。由此我们可以看到该job【是否允许并发】字段为【no】。
2. 分析问题
Spring提供了两种配置JobDetail的方式，官方示例如下：
<!-- JobDetail配置 1 -->
<bean name="exampleJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
<property name="jobClass" value="example.ExampleJob"/>
<property name="jobDataAsMap">
<map>
<entry key="timeout" value="5"/>
</map>
</property>
</bean>
<!-- JobDetail配置 2 -->
<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="exampleBusinessObject"/>
<property name="targetMethod" value="doIt"/>
<property name="concurrent" value="false"/>
</bean>
JobDetailFactoryBean jobFactory = new JobDetailFactoryBean();
jobFactory.setName(jobName);
jobFactory.setBeanName(clazzName); //包名+类名
jobFactory.setJobClass((Class<? extends Job>) aClass);
jobFactory.setGroup(jobGroup);
jobFactory.setDurability(true);
jobFactory.afterPropertiesSet();
MethodInvokingJobDetailFactoryBean invokingJobDetailFactoryBean=new MethodInvokingJobDetailFactoryBean();
invokingJobDetailFactoryBean.setConcurrent(false);
invokingJobDetailFactoryBean.setName(jobName);
invokingJobDetailFactoryBean.setGroup(jobGroup);
invokingJobDetailFactoryBean.setTargetClass(aClass);
invokingJobDetailFactoryBean.setTargetMethod("xxx");
首先说MethodInvokingJobDetailFactoryBean配置，按照官方的意思是：在简单情况下，如果定时任务只是需要调用某个Spring对象的某个方法，可以使用这个简单配置下，concurrent设置为false可以防止任务的并发执行。但是这种方式功能不强，作用不大。
2.1 JobDetailFactoryBean方式配置
首先，需要配置jobClass属性，jobClass需要传入一个job实现类。Spring推荐直接继承QuartzJobBean类，官方示例如下
package example;
public class ExampleJob extends QuartzJobBean {
private int timeout;
/**
* Setter called after the ExampleJob is instantiated
* with the value from the JobDetailFactoryBean (5)
*/
public void setTimeout(int timeout) {
this.timeout = timeout;
}
protected void executeInternal(JobExecutionContext ctx) throws JobExecutionException {
// do the actual work
}
}
在executeInternal()中进行实际的逻辑
其次是配置jobDataAsMap属性，如上例中，jobDataAsMap配置了一个map
<entry key="timeout" value="5"/>
只要继承QuartzJobBean，就可以通过这种方式直接向Job属性中传递值。如上例中的：
private int timeout;
/**
* Setter called after the ExampleJob is instantiated
* with the value from the JobDetailFactoryBean (5)
*/
public void setTimeout(int timeout) {
this.timeout = timeout;
}
然后在executeInternal()方法中就可以直接使用timeout的值了。
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
System.out.println(timeout);
}
2.2 配置Trigger和Scheduler
Quartz中常用的Trigger只有两种：
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
<!-- see the example of method invoking job above -->
<property name="jobDetail" ref="jobDetail"/>
<!-- 10 seconds -->
<property name="startDelay" value="10000"/>
<!-- repeat every 50 seconds -->
<property name="repeatInterval" value="50000"/>
</bean>
<!-- trigger 2 -->
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
<property name="jobDetail" ref="exampleJob"/>
<!-- run every morning at 6 AM -->
<property name="cronExpression" value="0 0 6 * * ?"/>
</bean>
CronTriggerFactoryBean triggerFactoryBean = new
CronTriggerFactoryBean();
triggerFactoryBean.setName("corn_" + clazzName);
//jobDetails
triggerFactoryBean.setJobDetail(jobFactory.getObject());
triggerFactoryBean.setCronExpression(quartzCorn);
triggerFactoryBean.setGroup(QUARTZ_TRIGGER_GROUP);
triggerFactoryBean.afterPropertiesSet();
simpleTrigger每隔一段时间执行一次任务，jobDetail就是前面生成的jobDetail；startDelay表示系统启动起来后过多长时间开始执行任务，单位：毫秒；repeatInterval表示任务执行时间间隔，单位毫秒；
cornTrigger是corn表达式来执行的定时任务。
实际上，是登记qrtz_corn_triggers|qrtz_simple_triggers和qrtz_triggers这张表
3. 如何设置Quartz任务串行
在MethodInvokingJobDetailFactoryBean中，含有一个concurrent属性，可以用来控制任务是否并行执行。但在JobDetailFactoryBean中并没有这个属性。并且由于MethodInvokingJobDetailFactoryBean功能差，在实际开发中使用的并不多。所有，如何防止JobDetailFactoryBean并行呢？
package example;
//只需要在Job类上加上这个注解即可
@DisallowConcurrentExecution
public class ExampleJob extends QuartzJobBean {
private int timeout;
/**
* Setter called after the ExampleJob is instantiated
* with the value from the JobDetailFactoryBean (5)
*/
public void setTimeout(int timeout) {
this.timeout = timeout;
}
protected void executeInternal(JobExecutionContext ctx) throws JobExecutionException {
// do the actual work
}
}
在加上注解后，该表是否并行会在项目启动的时候，自动设置为1。不允许并行。
