java实现定时任务 Schedule

https://blog.csdn.net/java_2017_csdn/article/details/78060204

1.java定时任务可以借助 java.util.Timer 来实现

[java]

1. import java.util.Calendar;
2. import java.util.Date;
3. import java.util.Timer;
4. import java.util.TimerTask;
6. public class Test {
7.     public static void main(String[] args) {
8.         //timer1();
9.         timer2();
10.         //timer3();
11.         //timer4();
12.     }
14.     // 第一种方法：设定指定任务task在指定时间time执行 schedule(TimerTask task, Date time)
15.     public static void timer1() {
16.         Timer timer = new Timer();
17.         timer.schedule(new TimerTask() {
18.             public void run() {
19.                 System.out.println(“——-设定要指定任务——–“);
20.             }
21.         }, 2000);// 设定指定的时间time,此处为2000毫秒
22.     }
24.     // 第二种方法：设定指定任务task在指定延迟delay后进行固定延迟peroid的执行
25.     // schedule(TimerTask task, long delay, long period)
26.     public static void timer2() {
27.         Timer timer = new Timer();
28.         timer.schedule(new TimerTask() {
29.             public void run() {
30.                 System.out.println(“——-设定要指定任务——–“);
31.             }
32.         }, 1000, 1000);
33.     }
35.     // 第三种方法：设定指定任务task在指定延迟delay后进行固定频率peroid的执行。
36.     // scheduleAtFixedRate(TimerTask task, long delay, long period)
37.     public static void timer3() {
38.         Timer timer = new Timer();
39.         timer.scheduleAtFixedRate(new TimerTask() {
40.             public void run() {
41.                 System.out.println(“——-设定要指定任务——–“);
42.             }
43.         }, 1000, 2000);
44.     }
46.     // 第四种方法：安排指定的任务task在指定的时间firstTime开始进行重复的固定速率period执行．
47.     // Timer.scheduleAtFixedRate(TimerTask task,Date firstTime,long period)
48.     public static void timer4() {
49.         Calendar calendar = Calendar.getInstance();
50.         calendar.set(Calendar.HOUR_OF_DAY, 12); // 控制时
51.         calendar.set(Calendar.MINUTE, 0);       // 控制分
52.         calendar.set(Calendar.SECOND, 0);       // 控制秒
54.         Date time = calendar.getTime();         // 得出执行任务的时间,此处为今天的12：00：00
56.         Timer timer = new Timer();
57.         timer.scheduleAtFixedRate(new TimerTask() {
58.             public void run() {
59.                 System.out.println(“——-设定要指定任务——–“);
60.             }
61.         }, time, 1000 * 60 * 60 * 24);// 这里设定将延时每天固定执行
62.     }
63. }

2. Java定时任务可以用线程的等待来实现

[java]

1. /**
2.  * 普通thread
3.  * 这是最常见的，创建一个thread，然后让它在while循环里一直运行着，
4.  * 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：
5.  * @author GT
6.  *
7.  */
8. public class Task1 {
9.     public static void main(String[] args) {
10.         // run in a second
11.         final long timeInterval = 1000;
12.         Runnable runnable = new Runnable() {
13.             public void run() {
14.                 while (true) {
15.                     // ——- code for task to run
16.                     System.out.println(“Hello !!”);
17.                     // ——- ends here
18.                     try {
19.                         Thread.sleep(timeInterval);
20.                     } catch (InterruptedException e) {
21.                         e.printStackTrace();
22.                     }
23.                 }
24.             }
25.         };
26.         Thread thread = new Thread(runnable);
27.         thread.start();
28.     }
29. }

3.Java可以用java.util.concurrent.ScheduledExecutorService 来实现定时任务

[java]

1. import java.util.concurrent.Executors;
2. import java.util.concurrent.ScheduledExecutorService;
3. import java.util.concurrent.TimeUnit;
5. /**
6.  *
7.  *
8.  * ScheduledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。
9.  * 相比于上两个方法，它有以下好处：
10.  * 1>相比于Timer的单线程，它是通过线程池的方式来执行任务的
11.  * 2>可以很灵活的去设定第一次执行任务delay时间
12.  * 3>提供了良好的约定，以便设定执行的时间间隔
13.  *
14.  * 下面是实现代码，我们通过ScheduledExecutorService#scheduleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间。
15.  *
16.  *
17.  * @author GT
18.  *
19.  */
20. public class Task3 {
21.     public static void main(String[] args) {
22.         Runnable runnable = new Runnable() {
23.             public void run() {
24.                 // task to run goes here
25.                 System.out.println(“Hello !!”);
26.             }
27.         };
28.         ScheduledExecutorService service = Executors
29.                 .newSingleThreadScheduledExecutor();
30.         // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
31.         service.scheduleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);
32.     }
33. }

4. 定时任务之-Quartz使用篇

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的日程序表。Jobs可以做成标准的Java组件或 EJBs。

CronTrigger配置格式:
格式: [秒] [分] [小时] [日] [月] [周] [年]

通配符说明:
* 表示所有值. 例如:在分的字段上设置 “*”,表示每一分钟都会触发。
? 表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为”?” 具体设置为 0 0 0 10* ?
– 表示区间。例如 在小时上设置 “10-12”,表示 10,11,12点都会触发。
, 表示指定多个值，例如在周字段上设置 “MON,WED,FRI” 表示周一，周三和周五触发
/ 用于递增触发。如在秒上面设置”5/15″ 表示从5秒开始，每增15秒触发(5,20,35,50)。在月字段上设置’1/3’所示每月1号开始，每隔三天触发一次。
L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于”7″或”SAT”。如果在”L”前加上数字，则表示该数据的最后一个。例如在周字段上设置”6L”这样的格式,则表示“本月最后一个星期五”
W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置”15W”，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 “1W”,它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，”W”前只能设置具体的数字,不允许区间”-“).

小提示	‘L’和 ‘W’可以一组合使用。如果在日字段上设置”LW”,则表示在本月的最后一个工作日触发(一般指发工资 )

# 序号(表示每月的第几个周几)，例如在周字段上设置”6#3″表示在每月的第三个周六.注意如果指定”#5″,正好第五周没有周六，则不会触发该配置(用在母亲节和父亲节再合适不过了)

常用示例:

经过封装的管理类：

[java]

1. import java.text.ParseException;
3. import org.quartz.CronTrigger;
4. import org.quartz.JobDetail;
5. import org.quartz.Scheduler;
6. import org.quartz.SchedulerException;
7. import org.quartz.SchedulerFactory;
8. import org.quartz.impl.StdSchedulerFactory;
10. /**
11.  * 定时任务管理类
12.  *
13.  */
14. public class QuartzManager {
15.     private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
16.     private static String JOB_GROUP_NAME = “EXTJWEB_JOBGROUP_NAME”;
17.     private static String TRIGGER_GROUP_NAME = “EXTJWEB_TRIGGERGROUP_NAME”;
19.     /**
20.      * 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
21.      *
22.      * @param jobName
23.      *            任务名
24.      * @param jobClass
25.      *            任务
26.      * @param time
27.      *            时间设置，参考quartz说明文档
28.      * @throws SchedulerException
29.      * @throws ParseException
30.      */
31.     public static void addJob(String jobName, String jobClass, String time) {
32.         try {
33.             Scheduler sched = gSchedulerFactory.getScheduler();
34.             JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, Class.forName(jobClass));// 任务名，任务组，任务执行类
35.             // 触发器
36.             CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组
37.             trigger.setCronExpression(time);// 触发器时间设定
38.             sched.scheduleJob(jobDetail, trigger);
39.             // 启动
40.             if (!sched.isShutdown()){
41.                 sched.start();
42.             }
43.         } catch (Exception e) {
44.             e.printStackTrace();
45.             throw new RuntimeException(e);
46.         }
47.     }
49.     /**
50.      * 添加一个定时任务
51.      *
52.      * @param jobName
53.      *            任务名
54.      * @param jobGroupName
55.      *            任务组名
56.      * @param triggerName
57.      *            触发器名
58.      * @param triggerGroupName
59.      *            触发器组名
60.      * @param jobClass
61.      *            任务
62.      * @param time
63.      *            时间设置，参考quartz说明文档
64.      * @throws SchedulerException
65.      * @throws ParseException
66.      */
67.     public static void addJob(String jobName, String jobGroupName,
68.             String triggerName, String triggerGroupName, String jobClass, String time){
69.         try {
70.             Scheduler sched = gSchedulerFactory.getScheduler();
71.             JobDetail jobDetail = new JobDetail(jobName, jobGroupName, Class.forName(jobClass));// 任务名，任务组，任务执行类
72.             // 触发器
73.             CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组
74.             trigger.setCronExpression(time);// 触发器时间设定
75.             sched.scheduleJob(jobDetail, trigger);
76.         } catch (Exception e) {
77.             e.printStackTrace();
78.             throw new RuntimeException(e);
79.         }
80.     }
82.     /**
83.      * 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
84.      *
85.      * @param jobName
86.      * @param time
87.      */
88.     public static void modifyJobTime(String jobName, String time) {
89.         try {
90.             Scheduler sched = gSchedulerFactory.getScheduler();
91.             CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName, TRIGGER_GROUP_NAME);
92.             if(trigger == null) {
93.                 return;
94.             }
95.             String oldTime = trigger.getCronExpression();
96.             if (!oldTime.equalsIgnoreCase(time)) {
97.                 JobDetail jobDetail = sched.getJobDetail(jobName, JOB_GROUP_NAME);
98.                 Class objJobClass = jobDetail.getJobClass();
99.                 String jobClass = objJobClass.getName();
100.                 removeJob(jobName);
102.                 addJob(jobName, jobClass, time);
103.             }
104.         } catch (Exception e) {
105.             e.printStackTrace();
106.             throw new RuntimeException(e);
107.         }
108.     }
110.     /**
111.      * 修改一个任务的触发时间
112.      *
113.      * @param triggerName
114.      * @param triggerGroupName
115.      * @param time
116.      */
117.     public static void modifyJobTime(String triggerName,
118.             String triggerGroupName, String time) {
119.         try {
120.             Scheduler sched = gSchedulerFactory.getScheduler();
121.             CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, triggerGroupName);
122.             if(trigger == null) {
123.                 return;
124.             }
125.             String oldTime = trigger.getCronExpression();
126.             if (!oldTime.equalsIgnoreCase(time)) {
127.                 CronTrigger ct = (CronTrigger) trigger;
128.                 // 修改时间
129.                 ct.setCronExpression(time);
130.                 // 重启触发器
131.                 sched.resumeTrigger(triggerName, triggerGroupName);
132.             }
133.         } catch (Exception e) {
134.             e.printStackTrace();
135.             throw new RuntimeException(e);
136.         }
137.     }
139.     /**
140.      * 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
141.      *
142.      * @param jobName
143.      */
144.     public static void removeJob(String jobName) {
145.         try {
146.             Scheduler sched = gSchedulerFactory.getScheduler();
147.             sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器
148.             sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器
149.             sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务
150.         } catch (Exception e) {
151.             e.printStackTrace();
152.             throw new RuntimeException(e);
153.         }
154.     }
156.     /**
157.      * 移除一个任务
158.      *
159.      * @param jobName
160.      * @param jobGroupName
161.      * @param triggerName
162.      * @param triggerGroupName
163.      */
164.     public static void removeJob(String jobName, String jobGroupName,
165.             String triggerName, String triggerGroupName) {
166.         try {
167.             Scheduler sched = gSchedulerFactory.getScheduler();
168.             sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器
169.             sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器
170.             sched.deleteJob(jobName, jobGroupName);// 删除任务
171.         } catch (Exception e) {
172.             e.printStackTrace();
173.             throw new RuntimeException(e);
174.         }
175.     }
177.     /**
178.      * 启动所有定时任务
179.      */
180.     public static void startJobs() {
181.         try {
182.             Scheduler sched = gSchedulerFactory.getScheduler();
183.             sched.start();
184.         } catch (Exception e) {
185.             e.printStackTrace();
186.             throw new RuntimeException(e);
187.         }
188.     }
190.     /**
191.      * 关闭所有定时任务
192.      */
193.     public static void shutdownJobs() {
194.         try {
195.             Scheduler sched = gSchedulerFactory.getScheduler();
196.             if(!sched.isShutdown()) {
197.                 sched.shutdown();
198.             }
199.         } catch (Exception e) {
200.             e.printStackTrace();
201.             throw new RuntimeException(e);
202.         }
203.     }
204. }

简单实现Schedule的Quartz的例子

第一步：引包

要使用Quartz，必须要引入以下这几个包：

1、log4j-1.2.16

2、quartz-2.1.7

3、slf4j-api-1.6.1.jar

4、slf4j-log4j12-1.6.1.jar

这些包都在下载的Quartz包里面包含着，因此没有必要为寻找这几个包而头疼。

第二步：创建要被定执行的任务类

这一步也很简单，只需要创建一个实现了org.quartz.Job接口的类，并实现这个接口的唯一一个方法execute(JobExecutionContext arg0) throws JobExecutionException即可。如：

[java]

1. import java.text.SimpleDateFormat;
3. import java.util.Date;
5. import org.quartz.Job;
6. import org.quartz.JobExecutionContext;
7. import org.quartz.JobExecutionException;
9. public class myJob implements Job {
11.     @Override
12.     public void execute(JobExecutionContext arg0) throws JobExecutionException {
13.         SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss SSS”);
14.         System.out.println(sdf.format(new Date()));
15.     }
17. }

第三步：创建任务调度，并执行

[java]

1. import java.text.SimpleDateFormat;
2. import java.util.Date;
4. import org.quartz.CronTrigger;
5. import org.quartz.JobDetail;
6. import org.quartz.Scheduler;
7. import org.quartz.SchedulerFactory;
8. import org.quartz.impl.StdSchedulerFactory;
10. public class Test {
11.     public void go() throws Exception {
12.         // 首先，必需要取得一个Scheduler的引用
13.         SchedulerFactory sf = new StdSchedulerFactory();
14.         Scheduler sched = sf.getScheduler();
15.         String time=”0 51 11 ? * *”;
16.         // jobs可以在scheduled的sched.start()方法前被调用
18.         // job 1将每隔20秒执行一次
19.         JobDetail job = new JobDetail(“job1”, “group1”, myJob.class);
20.         CronTrigger trigger = new CronTrigger(“trigger1”, “group1”);
21.         trigger.setCronExpression(time);
22.         Date ft = sched.scheduleJob(job, trigger);
23.         SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss SSS”);
24.         System.out.println(
25.                 job.getKey() + ” 已被安排执行于: ” + sdf.format(ft) + “，并且以如下重复规则重复执行: ” + trigger.getCronExpression());
27.         // job 2将每2分钟执行一次（在该分钟的第15秒)
28.         job = new JobDetail(“job2”, “group1”,myJob.class);
29.         trigger = new CronTrigger(“trigger2”, “group1”);
30.         trigger.setCronExpression(time);
31.         ft = sched.scheduleJob(job, trigger);
32.         System.out.println(
33.                 job.getKey() + ” 已被安排执行于: ” + sdf.format(ft) + “，并且以如下重复规则重复执行: ” + trigger.getCronExpression());
35.         // 开始执行，start()方法被调用后，计时器就开始工作，计时调度中允许放入N个Job
36.         sched.start();
37.         try {
38.             // 主线程等待一分钟
39.             Thread.sleep(60L * 1000L);
40.         } catch (Exception e) {
41.         }
42.         // 关闭定时调度，定时器不再工作
43.         sched.shutdown(true);
44.     }
46.     public static void main(String[] args) throws Exception {
48.         Test test = new Test();
49.         test.go();
50.     }
52. }

本文链接：https://www.aiunk.com/323/