TImer定时器的方法schedule和scheduleAtFixedRate区别已经动态修改定时计划的实现

====schedule和scheduleAtFixedRate区别=====

区别在于当当前时间已经超过了设定执行时间，schedule方法会立即执行，第二次执行则是按当前执行时间+间隔时间来算的（当然任务执行时间超过了间隔时间，则在第一次执行完毕后，立马会执行第二次）。而scheduleAtFixedRate方法，同样是立即执行一次，但是它第二次执行则是按照（当前执行时间-设定的时间）/时间间隔来计算从设定时间到现在还需要执行多少次。

       举个例子：任务调度需要执行2s，间隔时间是10s，我设定的是8点执行。当前时间为8点0分10秒，如果是schedule方法，则会立即执行一次，第二次执行时间则是08:00:20。如果是scheduleAtFixedRate方法，则会立即执行一次，然后计算08:00:10-08:00:00整好还可以执行一次，所以会在08:00:12时，会立即再执行一次，第三次执行则是在08:00:20时执行，以后每隔10s执行一次。

========动态修改定时计划===================

1. /** 
2.  * 任务调度管理器 
3.  * 
4.  */  
5. public class DynamicTaskManager {  
6.     private static final long PERIOD = 5 * 1000;// 5秒钟  
7.       
8.     /** 
9.      * 单例对象 
10.      */  
11.     private static DynamicTaskManager taskManager = null;     
12.       
13.     /** 
14.      * 时间调度对象 
15.      */  
16.     private static Timer timer = new Timer();  
17.       
18.     /** 
19.      * 任务 
20.      */  
21.     private static DynamicTimerTask task = null;  
22.   
23.     static {  
24.         taskManager = new DynamicTaskManager();  
25.     }  
26.       
27.     public static DynamicTaskManager getInstance(){  
28.         if(taskManager==null){  
29.             taskManager = new DynamicTaskManager();  
30.         }  
31.         return taskManager;  
32.     }  
33.   
34.     public DynamicTaskManager() {  
35.     }  
36.   
37.     @SuppressWarnings("deprecation")  
38.     public void startTask(Date startTime, long period){  
39.           
40.         System.out.println("设置启动时间: "+startTime.toLocaleString());  
41.         //如果当前时间超过了设定时间，会立即执行一次  
42.         task = new DynamicTimerTask();  
43.         timer.schedule(task, startTime,period);  
44.           
45.     }  
46.       
47.   
48.     /** 
49.      * 启动定时器 
50.      */  
51.     public void start() {  
52.         //启动任务，10点40启动任务  
53.         start(DateUtils.bookTime(10,40,0));  
54.     }  
55.       
56.     /** 
57.      * 启动定时器 
58.      */  
59.     public void start(long preiod) {  
60.         //启动任务，10点40启动任务  
61.         start(DateUtils.bookTime(10,40,0),preiod);  
62.     }  
63.       
64.     /** 
65.      * 启动定时器 
66.      */  
67.     public void start(Date startTime) {  
68.         start(startTime,PERIOD);  
69.     }  
70.       
71.     /** 
72.      * 启动定时器 
73.      */  
74.     public void start(Date startTime,long preiod) {  
75.         startTask(startTime,preiod);  
76.     }  
77.       
78.     /** 
79.      * 重新启动 
80.      */  
81.     public void restart() {  
82.         clean();  
83.         start();  
84.     }  
85.   
86.     /** 
87.      * 清空timer 
88.      */  
89.     public void clean() {  
90.         if(task != null){  
91.             task.cancel();  
92.         }  
93.         timer.purge();  
94.     }  
95.       
96.     /** 
97.      * 停止任务 
98.      */  
99.     public void stop(){  
100.         System.out.println("--------任务正在停止---------");  
101.         clean();      
102.         System.out.println("---------任务已停止----------");  
103.     }  
104.       
105.     static class DateUtils{  
106.         /** 
107.          * 增加或减少天数 
108.          *  
109.          * @param date 
110.          * @param CalendarFlag   
111.          *              取值 Calendar.DAY_OF_MONTH, Calendar.HOUR_OF_DAY， 
112.          *                     Calendar.MINUTE，Calendar.SECOND，Calendar.MILLISECOND 
113.          * @param num 
114.          * @return 
115.          */  
116.         public static Date addDay(Date date, int CalendarFlag, int num) {  
117.             Calendar startDT = Calendar.getInstance();  
118.             startDT.setTime(date);  
119.             startDT.add(CalendarFlag, num);  
120.             return startDT.getTime();  
121.         }  
122.           
123.         /** 
124.          * 设定时间 
125.          *  
126.          * @param hour 
127.          * @param minute 
128.          * @param second 
129.          * @return 
130.          */  
131.         public static Date bookTime(int hour, int minute, int second) {  
132.             Calendar calendar = Calendar.getInstance();  
133.             calendar.set(Calendar.HOUR_OF_DAY, hour);  
134.             calendar.set(Calendar.MINUTE, minute);  
135.             calendar.set(Calendar.SECOND, second);  
136.             Date date = calendar.getTime();  
137.             return date;  
138.         }  
139.     }  
140.       
141.       
142.     @SuppressWarnings("deprecation")  
143.     public static void main(String[] args) {  
144.         DynamicTaskManager manager = DynamicTaskManager.getInstance();  
145.         //启动任务，会立即执行一次，2s时执行完毕，5s时第二次执行，7s时第二次执行完毕  
146.         manager.start();  
147.           
148.         for(int i=0;i<8;i++){  
149.             try {  
150.                 Thread.sleep(1000);  
151.             } catch (InterruptedException e) {  
152.                 e.printStackTrace();  
153.             }  
154.         }  
155.         //8s时，stop原任务，动态更改启动时间  
156.         manager.stop();  
157.         System.out.println("当前时间："+new Date().toLocaleString());  
158.           
159.         System.out.println("修改原计划，5s后重新执行");  
160.         //5s后再启动，即13s时再启动  
161.         manager.start(DateUtils.addDay(new Date(), Calendar.SECOND, 5));  
162.     }  
163. }