在项目中需要用到定时器的功能，比如在特定的时间定时或者在每个一段时间执行一个任务，这里就需要使用到定时器。

本文提供两种方式来实现定时器：jdk的Timer以及使用spring的触发器

使用Timer定时器方式：

第一、编写任务类继承TimerTask，重写run方法

package com.syc.timer;

import java.util.TimerTask;

public class MyTimerTask extends TimerTask{
	private String name;

	public MyTimerTask(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		System.out.println("输入的姓名是："+name);
	}
	
}

第二、测试类中创建Timer对象，设置任务及调度策略

package com.syc.timer;

import java.util.Timer;

public class TestTimerTask {
	public static void main(String[] args) {
		MyTimerTask myTimerTask = new MyTimerTask("李沁");
		Timer timer = new Timer();
		timer.schedule(myTimerTask, 2000,1000);
	}
}

本文重点不在介绍Timer的使用，项目中Quartz集成spring的方式才是最为常用的，即QuartzJobBean的使用。关键对象分为三个：

1、调度工作类：org.springframework.scheduling.quartz.JobDetailBean，该对象通过jobClass属性指定调度工作类；

2、调度触发器：org.springframework.scheduling.quartz.CronTriggerBean，该对象通过jobDetail属性指定工作类，通过

cronExpression属性指定调度频率；

3、调度工厂类：org.springframework.scheduling.quartz.SchedulerFactoryBean，该对象通过triggers属性指定单个或多个触发器。

一、所需的jar包

将spring需要用到的4+1先全部导入（4个核心一个依赖）spring-core-3.2.0.RELEASE.jar，spring-beans-3.2.0.RELEASE.jar， spring-context-3.2.0.RELEASE.jar， spring-expression-3.2.0.RELEASE.jar，com.springsource.org.apache.commons.logging-1.1.1.jar

再导入另外几个包：spring-support-2.0.8.jar，spring-tx-3.2.0.RELEASE.jar，commons-collections-3.2.jar，commons-logging-1.1.jar，quartz-1.7.3.jar

二、创建项目导入jar包

将上述包导入，其中mysql和ojdbc是我的项目中两个数据库的驱动，可以不用导入

三、编写工作类

package com.syc.springTrigger;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

//工作类
public class Job extends QuartzJobBean{
	private int timeout = 10;//间隔多长时间调度开始
	private static int i = 0;
	
	//JobDetailBean通过jobDataAsMap注入此属性值，指定当服务器启动后过多少秒钟首次调用工作类
	public void setTimeout(int timeout) {
		this.timeout = timeout;
	}

	//需要调度的任务
	@Override
	protected void executeInternal(JobExecutionContext arg0)
			throws JobExecutionException {
		System.out.println("QuartzJobBean调度"+ i +"进行中...");
		i++;
	}

}

四、spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       	                   http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- JobDetailBean 1、工作类配置 -->
	 <bean name="job" class="org.springframework.scheduling.quartz.JobDetailBean">
		 <property name="jobClass" value="com.syc.springTrigger.Job" />
		 <property name="jobDataAsMap">
			 <map>
			 <entry key="timeout" value="10" /><!-- Job中的 timeout属性，10秒后启用调度-->
			 </map>
		 </property>
	 </bean>
	 <!-- CronTriggerBean 2、触发器配置-->
	 <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
	 	<property name="jobDetail" ref="job" /><!-- 注入1步骤中的工作类 -->
		<!-- 每隔一秒调度一次 -->
		<property name="cronExpression" value="0/1 * * * * ?" />
	 </bean>
	<!-- SchedulerFactoryBean 3、配置调度工厂 -->
	 <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		 <property name="triggers">
			 <list>
			 	<ref bean="cronTrigger" /><!-- 注入2步骤中触发器 -->
			 </list>
		 </property>
	 </bean>
</beans>

五、测试类（只需加载spring的配置文件即可）

package com.syc.springTrigger;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestJob {
	public static void main(String[] args) {
		String xmlPath = "com/syc/springTrigger/beans.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
	}

}

调度结果：

六、补充时间调度方法：

具体时间设定可参考 
"0/10 * * * * ?" 每10秒触发 
"0 0 12 * * ?" 每天中午12点触发 
"0 15 10 ? * *" 每天上午10:15触发 
"0 15 10 * * ?" 每天上午10:15触发 
"0 15 10 * * ? *" 每天上午10:15触发 
"0 15 10 * * ? 2005" 2005年的每天上午10:15触发 
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发 
"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发 
"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发 
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发 
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发 
"0 15 10 15 * ?" 每月15日上午10:15触发 
"0 15 10 L * ?" 每月最后一日的上午10:15触发 
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发 
"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发 
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发 
每隔5秒执行一次：*/5 * * * * ? 
每隔1分钟执行一次：0 */1 * * * ? 
每天23点执行一次：0 0 23 * * ? 
每天凌晨1点执行一次：0 0 1 * * ? 
每月1号凌晨1点执行一次：0 0 1 1 * ? 
每月最后一天23点执行一次：0 0 23 L * ? 
每周星期天凌晨1点实行一次：0 0 1 ? * L 
在26分、29分、33分执行一次：0 26,29,33 * * * ? 
每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?

参考：https://blog.csdn.net/dwz538878/article/details/81563588

在开触发器时，会自动开启一个线程处理任务。不用担心和主程序的阻塞问题，但需注意任务之间的阻塞问题，如果是异步则会为每个任务都开启，无需担心任务之间的阻塞问题。

1. 在spring-boot启动类上添加@EnableScheduling注解，代表开启定时器，图1。
2. 单纯只做一个任务且项目启动时就开始或者延时一段时间开始,在需要做任务的类上添加@Component注解，让spring-boot扫码组件，在方法上注解@Scheduled(initialDelay = 1000，fixedDelay = 2000)第一个参数是延迟多久开始，第二个参数是间隔多久执行一次，图2。
3. 如果有多个任务执行，可能需要开线程执行任务，这时只需在任务类上多加一个@EnableAsync注解和任务方法上@Async即可，图3。
4. 需要指定时间启动，在任务方法上加@Scheduled(cron = "0,5 6/1 18 10 8 2")即可，再根据需要写cron表达式。其中
   依次是秒 分 时 天 月 星期（1代表星期1，2代表星期2）
   ","代表这个和这个都要执行
   "/“代表左边这个时间开始，每隔”/"右边的数就执行一次，代表通配，什么都执行
   全都为""时，就没过1s执行一次
   这是spring的只有6个域，图4。

图1，启动类添加注解

@EnableScheduling
@SpringBootApplication
public class TimApplication {
    public static void main(String[] args) {
        SpringApplication.run(TimApplication.class, args);
    }
}

图2，单个任务，当两个任务同时时，会等待前一个执行完再执行

@Component
public class NoThread {
    @Scheduled(initialDelay = 1000,fixedDelay = 2000)
    public void pt(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是pt");
    }
    @Scheduled(initialDelay = 1000,fixedDelay = 2000)
    public void pt1(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是pt1");
    }
}

图3，也是两个任务同时进行，但是采用异步，不用等待前一个执行就可执行

@EnableAsync
@Component
public class Threads {
    @Async
    @Scheduled(initialDelay = 1000,fixedDelay = 2000)
    public void pt(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是pt2");
    }
    @Async
    @Scheduled(initialDelay = 1000,fixedDelay = 2000)
    public void pt1(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是pt3");
    }
}

图4，有定时需求启动时采用，下面的cron代表8月10号周2的下午17点42分0秒和5秒开始输出一次，且开始每过1分钟继续执行

@EnableAsync
@Component
public class cron {
    //依次是秒 分 时 天 月 星期（1代表星期1，2代表星期2）
    // ","代表这个和这个都要执行
    // "/"代表左边这个时间开始，每隔"/"右边的数就执行一次，*代表通配，什么都执行
    // 全都为"*"时，就没过1s执行一次
    @Scheduled(cron = "0,5 42/1 17 10 8 2")
    @Async
    public void pt4(){
        System.out.println("我是pt4");
    }
}

在Spring中配置Quartz

前面介绍过了Timer在Spring中的实现，今天接前文介绍Quartz在Spring中的配置.
而Quartz类库不但有着上述JDK的Timer类库类似的配置，更重要的，它还有着类似于unix的cron服务的配置; 正是基于cron服务的配置使Quartz能方便、清晰指定启动时间，让开发者更青睐于它。

  在调度方式上，不同于Timer,Quartz可以通过两种方式来调度程序：一是使用Spring提供的 MethodInvokingJobDetailFactoryBean代理类，Quartz通过该代理类直接调度任务类的某个函数；二是任务类继承并实现Quartz接口，Quartz通过该接口进行调度。如果采用第一种方式，即由Quartz直接调度任务类的某个接口，那么，业务类是不必进行任何修改的。我们的业务类大概如下:

 public class OpenVirtualService {
            public void open(){ //虚机开通
               //业务逻辑
            }
      }

第一步，在Spring配置文件中增加本业务类

  <bean id="openVirtualService" class="com.stone.product.virtual.service.OpenVirtualService"/>

第二步，定义任务。在Spring配置文件中配置代理类MethodInvokingJobDetailFactoryBean，定义任务的详细信息。

 <bean id="openVirtualTask" class= "org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
         <property name="targetObject" ref = "openVirtualService" />
         <property name="targetMethod" value ="open" />
         <property name="concurrent" value =" false " />
      </bean>

这个配置告诉Spring，我们的任务是执行id为businessReport的bean中的perform函数。其中参数concurrent告诉Spring，不要并发运行

这个任务。

  第三步，配置一个触发器。在Spring配置文件中配置触发器类CronTriggerBean 。

 <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
          <property name="jobDetail" ref="openVirtualTask" />
         <property name="cronExpression" value="0 0 1 1 * ?" />
      </bean>

触发器将告诉Quartz两件事：在何时触发任务、触发哪个任务。其中属性参数cronExpression为 调度时间，格式和unix上的crontab类

似，具体见下表1。“0 0 1 1 * ?”表示每月1日凌晨1点运行。其中问号表示忽略该位置（星期）上的值。属性参数jobDetail指向具体的任务

bean：reportTask 。如果你有多个任务，每个任务的触发时间都不一样，则你可以在此配置多个不同的触发器。

  表1. cronExpression的时间格式
  位置 - 含义-
  1 - 秒(0–59)
  2 - 分(0–59)
  3 - 时(0–23)
  4 - 日(1–31)
  5 - 月(1–12)
  6 - 星期(SUN–SAT or 1–7)
  7 - 年(可选, 1970–2099)


 第四步，配置一个调度器。在Spring配置文件中配置调度器类SchedulerFactoryBean。

 <bean class= "org.springframework.scheduling.quartz.SchedulerFactoryBean">
         <property name="triggers">
            <list>
               <ref bean="cronTrigger" />
            </list>
         </property>
     </bean>

该调度器用于管理触发器。只有在调度器中列表出现的触发器才被Quartz系统调度执行。至此，所有的配置已完成，任务已能正常跑了。

 如果采用第二种方式，那业务类是要进行小小的修改。整个过程如下。

 第一步，修改上述的业务类，修改如下：

  public class RenewVirtualService implements org.quartz.Job { //继承quartz 的job接口
         //实现job接口的execute函数，在其中简单调用perform()函数就可以了。
       public void execute(org.quartz.JobExecutionContext context){ //执行报表统计入口函数
            renew();
       }
       //其它的保持不变。

       public void renew(){ 
        //业务逻辑
        }
    }

修改过程比较简单，只增加了两三行代码;业务类在Spring的Bean配置不动。

第二步，定义任务。在Spring配置文件中配置如下任务的详细信息：

 <bean name="renewVirtualTask" class= "org.springframework.scheduling.quartz.JobDetailBean">
        <property name="jobClass" value="RenewVirtualService" />
    </bean>

此配置告诉Quartz，我们的任务类的名字为RenewVirtualService。在定时触发时，Quartz会利用该类名来创建任务的实例，并执行该实

例的execute方法。

第三、第四步与第一种的调度方式相应的步骤一样。

附:cronExpression表达式解释:

字段 允许值 允许的特殊字符
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日期 1-31 , - * ? / L W C
月份 1-12 或者 JAN-DEC , - * /
星期 1-7 或者 SUN-SAT , - * ? / L C #
年（可选） 留空, 1970-2099 , - * /

0 0 12 * * ?—————在每天中午12：00触发
0 15 10 ? * *—————每天上午10:15 触发
0 15 10 * * ?—————每天上午10:15 触发
0 15 10 * * ? *—————每天上午10:15 触发
0 15 10 * * ? 2005—————在2005年中的每天上午10:15 触发
0 * 14 * * ?—————每天在下午2：00至2：59之间每分钟触发一次
0 0/5 14 * * ?—————每天在下午2：00至2：59之间每5分钟触发一次
0 0/5 14,18 * * ?—————每天在下午2：00至2：59和6：00至6：59之间的每5分钟触发一次
0 0-5 14 * * ?—————每天在下午2：00至2：05之间每分钟触发一次
0 10,44 14 ? 3 WED—————每三月份的星期三在下午2：00和2：44时触发
0 15 10 ? * MON-FRI—————从星期一至星期五的每天上午10：15触发
0 15 10 15 * ?—————在每个月的每15天的上午10：15触发
0 15 10 L * ?—————在每个月的最后一天的上午10：15触发
0 15 10 ? * 6L—————在每个月的最后一个星期五的上午10：15触发
0 15 10 ? * 6L 2002-2005—————在2002, 2003, 2004 and 2005年的每个月的最后一个星期五的上午10：15触发
0 15 10 ? * 6#3—————在每个月的第三个星期五的上午10：15触发
0 0 12 1/5 * ?—————从每月的第一天起每过5天的中午12：00时触发
0 11 11 11 11 ?—————在每个11月11日的上午11：11时触发

=====================================================================================

spring Quartz配置：调度方式：通过spring的MethodInvocationJobDetailFactoryBean代理类，Quartz通过代理类调用业务类：二：业务类实现Quartz接口

public class DepartmentService{
    public void save();
}
//业务类
<bean id="departmentService" class="com.Liaq.DepartmentService"/>
//配置MethodInvocatoinJobDetailFactoryBean
<bean id="QuartzTest" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property name="targetObject" ref="departmentService"></property>
    <property name="targetMethod" value="save"></property>
    <property name="concurrent" value="false"></property>
</bean>
//配置触发器
<bean id="triigerEvent" class="org.springframework.scheduling.quartz.CronTriggerBean">
    <property name="jobDetail" value="QuartzTest"></property>
    <property name="cronExpression" value="QuartzTest"></property>
</bean>
//配置调度器
<bean id="triggersControl" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="triggers">
        <list>
            <ref bean="triigerEvent" />
        </list>
    </property>
</bean>

============================================================================

timer实现：

1. spring+java.util.TimerTask
   a. 定义工作任务:
   工作任务类继承timerTask,并实现工作任务run.
   b. 定义任务调度器:
   把工作任务注入spring的定时任务调度器: ScheduledTimerTask,指定任务的执行时间.
   c. 启动调度器:
   通过spring的定时任务启动器TimerFactoryBead启动任务调度器,可以加载多个任务调度器

Java Timer定时 ：

    import java.util.TimerTask;   
    public class EmailReportTask extends TimerTask{   
        @Override   
        public void run() {   
            ...   
        }     
    }   

scheduledTimerTasks里显示一个需要启动的定时器任务的列表。   
可以通过设置delay属性延迟启动   
<bean id="scheduleReportTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">   
<property name="timerTask" ref="reportTimerTask" />   
<property name="period">   
<value>86400000value>   
property>   
<property name="delay">   
<value>3600000value>   
property>   
<bean>   


启动Spring定时器

Spring的TimerFactoryBean负责启动定时任务

<bean class="org.springframework.scheduling.timer.TimerFactoryBean">   
<property name="scheduledTimerTasks">   
   <list><ref bean="scheduleReportTask"/>list>   
property>   
bean>