JDK、Spring、Quartz等几种不同定时器的用法，以及cronExpression表达式定义

第一种：Timer和TimerTask

Timer实际上是个线程，它可以定时调度一个TimerTask对象。一个TimerTask实际上就是一个拥有run方法的类，需要定时执行的代码放到run方法体内。 

Timer及其方法：

1. java.util.Timer timer = new java.util.Timer( true); // true表示这个timer以daemon方式运行（优先级低，程序结束或其他用户线程都结束时timer也自动结束）
3. TimerTask task = new TimerTask() {
4. public void run() {
5. //每次需要执行的代码
6. }
7. };
9. //以下是几种调度task的方法：
10. timer.schedule(task, time); // time为Date类型：在指定时间执行一次。
11. timer.schedule(task, firstTime, period); // firstTime为Date类型,period为long，从firstTime时刻开始，每隔period毫秒执行一次。
12. timer.schedule(task, delay) // delay 为long类型：从现在起过delay毫秒执行一次</span>
13. timer.schedule(task, delay, period) // delay为long,period为long：从现在起过delay毫秒以后，每隔period毫秒执行一次。
15. //下面这两种方法的参数和前面两种一样，不同的是它们可以把执行间隔受到其他任务的影响降到最低。如果由于任何原因（如垃圾回收或其他背景活动）而延迟了某次执行，则将快速连续地出现两次或更多的执行，从而使后续执行能够“追赶上来”，从而平均执行间隔极大地逼近period。
16. timer.scheduleAtFixedRate(task, delay, period);
17. timer.scheduleAtFixedRate(task, firstTime, period);

一个完整的例子：

1. import java.util.Date;
2. import java.util.TimerTask;
4. public class MyTimerTask extends TimerTask {
5. @Override
6. public void run() {
7. System.out.println( "定时器开始执行任务……" + new Date());
8. }
9. }

1. import java.util.Timer;
3. public class MyTimer {
4. public static void main(String[] args) {
5. Timer timer = new Timer();
6. int delay = 2* 1000; //2秒后开始
7. int period = 3* 1000; //每3秒执行一次
8. timer.scheduleAtFixedRate( new MyTimerTask(), delay, period);
9. }
10. }

实现方法：

第一步：建立一个Java类，并实现Runnable接口：

1. package com.xjj.anes.schedule;
3. public class StartupTask implements Runnable{
4. @Override
5. public void run() {
6. //doSomething();
7. }
8. }

1. <bean id= "startupTask" class= "com.xjj.anes.schedule.StartupTask" />
2. <bean id= "startupScheduledTask" class= "org.springframework.scheduling.concurrent.ScheduledExecutorTask">
3. <property name= "delay" value= "3000" />
4. <property name= "period" value= "0" /> <!-- 0表示只执行一次，毫秒 -->
5. <property name= "runnable" ref= "startupTask" />
6. </bean>
8. <bean id= "timerFactory" class= "org.springframework.scheduling.concurrent.ScheduledExecutorFactoryBean">
9. <property name= "scheduledExecutorTasks">
10. <list>
11. <ref bean= "startupScheduledTask" />
12. </list>
13. </property>
14. </bean>

或直接使用注解：

1. <task:annotation-driven scheduler="myScheduler" />
2. <task:scheduler id="myScheduler" pool-size="10" />

1. @Scheduled(fixedDelay= 5000)
2. public void doSomething() {
3. System.out.println( "每5秒钟执行一次。");
4. }
6. @Scheduled(fixedRate= 5000)
7. public void doSomething() {
8. // something that should execute periodically
9. }
11. @Scheduled(initialDelay= 1000, fixedRate= 5000)
12. public void doSomething() {
13. // something that should execute periodically
14. }
16. @Scheduled(cron= "*/5 * * * * MON-FRI")
17. public void doSomething() {
18. // something that should execute on weekdays only
19. }

或完全使用配置：

1. <task:scheduled-tasks scheduler="myScheduler">
2. <task:scheduled ref="beanA" method="methodA" fixed-delay="5000" initial-delay="1000"/>
3. <task:scheduled ref="beanB" method="methodB" fixed-rate="5000"/>
4. <task:scheduled ref="beanC" method="methodC" cron="*/5 * * * * MON-FRI"/>
5. </task:scheduled-tasks>
7. <task:scheduler id="myScheduler" pool-size="10"/>

第一步：引入相关的依赖包

1. <dependency>
2. <groupId>org.springframework</groupId>
3. <artifactId>spring-context-support</artifactId>
4. <version> 4.1.2.RELEASE</version>
5. </dependency>
6. <dependency>
7. <groupId>org.quartz-scheduler</groupId>
8. <artifactId>quartz</artifactId>
9. <version> 2.2.1</version>
10. </dependency>

1. public class MyTask{
2. public void putDataToCache() {
3. log.info( "Alert! putDataToCache........" + new Date());
4. }
5. }

第三步：Spring配置

1. <bean id="myTask" class="com.xjj.anes.schedule.MyTask" />
3. <!-- 调度触发器 -->
4. <bean id="putDataToCacheTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
5. <property name="jobDetail">
6. <!-- 设置被调度的对象和方法 -->
7. <bean class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
8. <property name="concurrent" value="false"/>
9. <property name="targetObject" ref="myTask"/>
10. <property name="targetMethod" value="putDataToCache"/>
11. </bean>
12. </property>
13. <property name="cronExpression" value="0 0 0/2 * * ?"/> <!-- 每两个小时执行一次 -->
14. </bean>
16. <!-- 调度工厂 -->
17. <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
18. <property name="triggers">
19. <list>
20. <ref bean="putDataToCacheTrigger" />
21. </list>
22. </property>
23. <property name="startupDelay" value="6"/>
24. </bean>

一些表达式的例子： 

（转载自：http://blog.csdn.net/clementad/article/details/42042111）