任务调度
quartz框架
quartz框架实现了Spring的任务调度，用户可以随意的定义触发器调度时间表，并将触发器和任务进行映射。quartz通过调度器、触发器和任务实现任务调度。
Job：主要用来设计任务实现的逻辑，并且只有一个方法execute。
JobDetail：主要用来通过newInstance()方法创建Job实例，该角色主要通过一些静态信息来描述Job的名称等信息。
Triger：作为任务的触发器，有两个类：SimpleTriger和CronTriger。当只触发一次或者周期性触发选择SimpleTriger。当定时触发时可以选择CronTriger。
Calendar：作为时间点的集合。
Scheduler：任务调度容器，Scheduler中注册Triger和JobDetail，将Triger和JobDetail关联起来。
实现任务调度步骤：
1、创建任务，并设置名称和组名。2、创建触发器，并设置名称和组名。3、对触发器设置时间规则。4、定义任务调度容器，将触发器与任务加入容器，并这只关联。
SimpleTriger任务调度实例：
创建任务类
1package scheduler; 2 3import org.quartz.Job; 4import org.quartz.JobDetail; 5import org.quartz.JobExecutionContext; 6import org.quartz.JobExecutionException; 7 8public class SimpleJob implements Job{ 9 10 @Override 11 public void execute(JobExecutionContext arg0) throws JobExecutionException { 12 // TODO Auto-generated method stub 13 System.out.println("定时任务调度================="); 14 } 15 16}
将任务与触发器关联
1/** 2 * 3 */ 4/** 5 * @author Administrator 6 * 7 */ 8package scheduler; 9 10import java.util.Collection; 11 12import org.quartz.Job; 13import org.quartz.JobBuilder; 14import org.quartz.JobDetail; 15import org.quartz.Scheduler; 16import org.quartz.SchedulerException; 17import org.quartz.SchedulerFactory; 18import org.quartz.SimpleScheduleBuilder; 19import org.quartz.SimpleTrigger; 20import org.quartz.TriggerBuilder; 21import org.quartz.impl.StdSchedulerFactory; 22 23import sun.java2d.pipe.SpanShapeRenderer.Simple; 24 25public class SimpleTriggerRunner { 26 public static void main(String[] args){ 27 try{ 28 JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class).withIdentity("job_1", "group_1").build(); 29 SimpleTrigger trigger = TriggerBuilder 30 .newTrigger() 31 .withIdentity("trigger_1","group_triger") 32 .startNow() 33 .withSchedule(SimpleScheduleBuilder 34 .simpleSchedule() 35 .withIntervalInSeconds(5) 36 .repeatForever()) 37 .build(); 38 SchedulerFactory factory = new StdSchedulerFactory(); 39 Scheduler scheduler = factory.getScheduler(); 40 scheduler.scheduleJob(jobDetail, trigger); 41 scheduler.start(); 42 }catch(Exception e){ 43 e.printStackTrace(); 44 } 45 } 46}
CronTriger实现任务调度实例：
1import java.util.Collection; 2 3import org.quartz.Job; 4import org.quartz.JobBuilder; 5import org.quartz.JobDetail; 6import org.quartz.Scheduler; 7import org.quartz.SchedulerException; 8import org.quartz.SchedulerFactory; 9import org.quartz.SimpleScheduleBuilder; 10import org.quartz.SimpleTrigger; 11import org.quartz.TriggerBuilder; 12import org.quartz.impl.StdSchedulerFactory; 13 14import sun.java2d.pipe.SpanShapeRenderer.Simple; 15 16public class SimpleTriggerRunner { 17 public static void main(String[] args){ 18 try{ 19 JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class).withIdentity("job_1", "group_1").build(); 20 SimpleTrigger trigger = TriggerBuilder 21 .newTrigger() 22 .withIdentity("trigger_1","group_triger") 23 .startNow() 24 .withSchedule(SimpleScheduleBuilder 25 .simpleSchedule() 26 .withIntervalInSeconds(5) 27 .repeatForever()) 28 .build(); 29 SchedulerFactory factory = new StdSchedulerFactory(); 30 Scheduler scheduler = factory.getScheduler(); 31 scheduler.scheduleJob(jobDetail, trigger); 32 scheduler.start(); 33 }catch(Exception e){ 34 e.printStackTrace(); 35 } 36 } 37}
Spring中使用quartz
创建JobDetailBean
步骤：
1、创建JobDetail实例JobDetailBean。对JobDetailBean进行属性设置，jobClass：用来指定任务；beanName：设置任务的名称；JobDataAsMap为任务的JobDataMap提供值；applicationContextJobDataKey：为Job提供applicationContext。2、创建Trigger触发器，主要是通过SimpleTriggerBean、CronTriggerBean和CronTriggerFactoryBean进行创建，需要将任务实例配置其中。3、通过SchedulerFactoryBean类配置Scheduler，将Trigger加入Schedulerde的Trigger列表中。
实例：
定义任务类
1package scheduler; 2 3import java.util.Map; 4 5import org.quartz.Job; 6import org.quartz.JobExecutionContext; 7import org.quartz.JobExecutionException; 8import org.springframework.stereotype.Component; 9 10import bean.User; 11@Component("myJob") 12public class MyJob{ 13 14 public void myexecute() { 15 // TODO Auto-generated method stub 16 System.out.println("Spring开始任务调度========="); 17 System.out.println("Spring结束任务调度=========="); 18 } 19 20}
将任务加入触发器，并设置调度时间。将触发器加入调度。
1<?xml version="1.0" encoding="UTF-8"?> 2<beans 3 xmlns="http://www.springframework.org/schema/beans" 4 xmlns:context="http://www.springframework.org/schema/context" 5 xmlns:p="http://www.springframework.org/schema/p" 6 xmlns:util="http://www.springframework.org/schema/util" 7 xmlns:mvc="http://www.springframework.org/schema/mvc" 8 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 9 xsi:schemaLocation="http://www.springframework.org/schema/beans 10 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 11 http://www.springframework.org/schema/context 12 http://www.springframework.org/schema/context/spring-context-3.0.xsd 13 http://www.springframework.org/schema/mvc 14 http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 15 http://www.springframework.org/schema/util 16 http://www.springframework.org/schema/util/spring-util-3.0.xsd" 17 > 18<context:component-scan base-package="scheduler"/> 19<!-- jobDetail --> 20<bean id="jobnew" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> 21 <property name="targetObject" ref="myJob"/> 22 <property name="targetMethod" value="myexecute"/> 23<!--false表示等上一个任务执行完后再开启新的任务--> 24 <property name="concurrent" value="false"/> 25</bean> 26<!-- Trigger--> 27<bean id="oceanStatusCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean"> 28 <property name="jobDetail" ref="jobnew"/> 29 <property name="cronExpression" value="0 */2 * * * ?"/> 30</bean> 31<!--Scheduler --> 32<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 33 <property name="triggers"> 34 <list> 35 <ref bean="oceanStatusCronTrigger"/> 36 </list> 37 </property> 38</bean> 39</beans>
Spring中使用Timer
Timer
当使用调度比较频繁时，可以考虑使用Timer，并不适合固定时间点例如每周周一上午八点的调度策略。但是对于长时间执行的任务来说，该调度会严重影响性能，因为每一个Timer是在同一个线程，Timer中的有多个TimerTask，执行时间过长容易引起积压。
TmierTask
TimerTask相当于Job，TimerTask实现了Runnable接口，该类中主要有三个方法：任务执行逻辑，执行时间，取消执行。
实现任务调度的步骤：
1、创建TimerTask类。2、创建Timer类。3、将TimerTask实例注册到Timer中。
实例
创建任务实例
1package scheduler; 2 3import java.util.TimerTask; 4 5public class SimpleTimerTask extends TimerTask{ 6 private int count=0; 7 @Override 8 public void run() { 9 // TODO Auto-generated method stub 10 System.out.println("线程执行次数========="+count); 11 count++; 12 if(count>10){ 13 cancel(); 14 } 15 } 16}
将任务注册到Timer中
1package scheduler; 2 3import java.util.Timer; 4import java.util.TimerTask; 5 6public class TimerRunner { 7 8 public static void main(String[] args){ 9 Timer timer = new Timer(); 10 TimerTask timerTask = new SimpleTimerTask(); 11 timer.schedule(timerTask, 1000, 2000); 12 } 13}
Spring对Timer的使用
创建任务类
1package scheduler; 2 3import org.springframework.stereotype.Component; 4 5@Component("myService") 6public class MyService { 7 8 public void timerTest(){ 9 System.out.println("开始使用TimerTask========="); 10 } 11}
将任务类封装为TimerTask，并将TimerTask设置定时规则，将规则注入Timer。
1<!-- 通过生成任务TimerTask --> 2<bean id="timerTask" class="org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean" 3 p:targetObject-ref="myService" 4 p:targetMethod="timerTest"/> 5<!-- 定义调度规则 --> 6<bean id="scheduledTask" class="org.springframework.scheduling.timer.ScheduledTimerTask" 7 p:timerTask-ref="timerTask" 8 p:delay="1000" 9 p:period="1000"/> 10<!-- 将调度规则放入调度队列 --> 11<bean id="timerFactoryBean" class="org.springframework.scheduling.timer.TimerFactoryBean"> 12 <property name="scheduledTimerTasks"> 13 <list> 14 <ref bean="scheduledTask"/> 15 </list> 16 </property> 17 </bean>
Spring中使用Executor
Executor主要有两个任务：任务提交和任务执行。Executor只有一个方法：void execute(Runnable command)，该方法接收任何实现了Runnable的实例。
Executor的简单实现：
1package scheduler; 2 3import java.util.concurrent.Executor; 4 5public class SimpleExecutor implements Executor{ 6 7 @Override 8 public void execute(Runnable command) { 9 // TODO Auto-generated method stub 10 command.run(); 11 } 12 13}
可以为每个任务创建一个线程：
1package scheduler; 2 3import java.util.concurrent.Executor; 4 5public class TaskExecutor implements Executor{ 6 7 @Override 8 public void execute(Runnable command) { 9 // TODO Auto-generated method stub 10 //为每一个任务重新创建一个线程 11 new Thread(command).start(); 12 } 13 14}
可以将任务放到线程池调度中，每一个任务会通过获取线程，进行任务处理。SchedulerThreadPoolExecutor继承ThreadPoolExecutor，ThreadPoolExecutor继承了Executor和ExecutorService。而SchedulerThreadPoolExecutor通过newFixedThreadPool(int nThreads)创建一个线程池进行任务处理。
使用实例：
1package scheduler; 2 3public class SimpleRunnable implements Runnable{ 4 5 @Override 6 public void run() { 7 // TODO Auto-generated method stub 8 System.out.println("开启任务执行=========="); 9 } 10 11} 12 13package scheduler; 14 15import java.util.concurrent.Executor; 16import java.util.concurrent.Executors; 17 18public class ExecutorExample { 19 20 private Executor executor; 21 public void setExecutor(Executor executor){ 22 this.executor = executor; 23 } 24 25 public void executeTask(){ 26 for(int i=0;i<6;i++){ 27 executor.execute(new SimpleRunnable()); 28 } 29 } 30 public static void main(String args){ 31 ExecutorExample ee = new ExecutorExample(); 32 ee.setExecutor(Executors.newFixedThreadPool(3)); 33 ee.executeTask(); 34 } 35}
Spring任务调度的注解支持
@Schedule的实例
配置定时任务：
1<?xml version="1.0" encoding="UTF-8"?> 2<beans 3 xmlns="http://www.springframework.org/schema/beans" 4 xmlns:context="http://www.springframework.org/schema/context" 5 xmlns:p="http://www.springframework.org/schema/p" 6 xmlns:util="http://www.springframework.org/schema/util" 7 xmlns:mvc="http://www.springframework.org/schema/mvc" 8 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 9 xmlns:task="http://www.springframework.org/schema/task" 10 xsi:schemaLocation="http://www.springframework.org/schema/beans 11 http://www.springframework.org/schema/beans/spring-beans-4.0.xsd 12 http://www.springframework.org/schema/context 13 http://www.springframework.org/schema/context/spring-context-4.0.xsd 14 http://www.springframework.org/schema/mvc 15 http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd 16 http://www.springframework.org/schema/util 17 http://www.springframework.org/schema/util/spring-util-4.0.xsd 18 http://www.springframework.org/schema/task 19 http://www.springframework.org/schema/task/spring-task-4.0.xsd"> 20<context:component-scan base-package="scheduler"/> 21<!-- 启用注解驱动的定时任务 --> 22<task:annotation-driven scheduler="myScheduler"/> 23<!-- 推荐配置线程池，若不配置多任务下会有问题。后面会详细说明单线程的问题。 --> 24<task:scheduler id="myScheduler" pool-size="5"/> 25</beans>
创建任务类
1package scheduler; 2 3import java.util.Map; 4 5import org.quartz.Job; 6import org.quartz.JobExecutionContext; 7import org.quartz.JobExecutionException; 8import org.springframework.stereotype.Component; 9 10import bean.User; 11@Component("myJob") 12public class MyJob{ 13 14 public void myexecute() { 15 // TODO Auto-generated method stub 16 System.out.println("Spring开始任务调度========="); 17 System.out.println("Spring结束任务调度=========="); 18 } 19 20}