1.java定時任務可以借助 java.util.Timer 來實現

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定時任務可以用線程的等待來實現

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 來實現定時任務

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"前只能設置具體的數字,不允許區間"-").

# 序號(表示每月的第幾個周幾)，例如在周字段上設置"6#3"表示在每月的第三個周六.註意如果指定"#5",正好第五周沒有周六，則不會觸發該配置(用在母親節和父親節再合適不過了)

常用示例:

經過封裝的管理類：

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即可。如：

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. }

　第三步：創建任務調度，並執行

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. }

java實現定時任務 Schedule