schedule与scheduleAtFixedRate比较

schedule与scheduleAtFixedRate：

不延时：

　　schedule(TimerTask, Date runDate, long period)方法任务不延时----Date类型

 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 import java.util.TimerTask;
 5 
 6 /**
 7  * schedule(TimerTask, Date runDate, long period)方法任务不延时----Date类型
 8  */
 9 public class Test {
10     
11     public static class MyTask extends TimerTask{
12         @Override
13         public void run() {
14             try {
15                 System.out.println("begin timer =" + System.currentTimeMillis());
16                 Thread.sleep(1000);
17                 System.out.println("end timer =" + System.currentTimeMillis());
18             } catch (InterruptedException e) {
19                 e.printStackTrace();
20             }
21         }
22     }
23     
24     /**
25      * 从运行结果可以看出,当没有延时,则下一次执行任务的开始时间是上一次任务的开始时间加上period时间(循环间隔)
26      */
27     public static void main(String[] args) {
28         MyTask task = new MyTask();
29         Calendar calendar = Calendar.getInstance();
30         Date runDate = calendar.getTime();
31         Timer timer = new Timer();
32         timer.schedule(task, runDate, 4000);
33     }
34 }

　　schedule(TimerTask, long delay, long period)方法任务不延时----long类型

 1 import java.util.Timer;
 2 import java.util.TimerTask;
 3 
 4 /**
 5  * schedule(TimerTask, long delay, long period)方法任务不延时----long类型
 6  */
 7 public class Test2 {
 8     
 9     public static class MyTask extends TimerTask{
10         @Override
11         public void run() {
12             try {
13                 System.out.println("begin timer =" + System.currentTimeMillis());
14                 Thread.sleep(1000);
15                 System.out.println("end timer =" + System.currentTimeMillis());
16             } catch (InterruptedException e) {
17                 e.printStackTrace();
18             }
19         }
20     }
21     
22     /**
23      *         从运行结果可以看出,当没有延时,则第一次执行任务的时间是任务的开始时间加上delay(延迟时间),
24      *         接下来执行任务的时间是上一次任务的开始时间加上period(循环间隔时间)
25      */
26     public static void main(String[] args) {
27         MyTask task = new MyTask();
28         System.out.println("当前时间为：" + System.currentTimeMillis());
29         Timer timer = new Timer();
30         timer.schedule(task, 3000, 4000);
31     }
32 }

　　scheduleAtFixedRate(TimerTask, Date runDate, long period)方法任务不延时----Date类型

 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 import java.util.TimerTask;
 5 
 6 /**
 7  * scheduleAtFixedRate(TimerTask, Date runDate, long period)方法任务不延时----Date类型
 8  */
 9 public class Test {
10     
11     public static class MyTask extends TimerTask{
12         @Override
13         public void run() {
14             try {
15                 System.out.println("begin timer =" + System.currentTimeMillis());
16                 Thread.sleep(1000);
17                 System.out.println("end timer =" + System.currentTimeMillis());
18             } catch (InterruptedException e) {
19                 e.printStackTrace();
20             }
21         }
22     }
23     
24     /**
25      * 从运行结果可以看出,当没有延时,则下一次执行任务的时间是上一次任务的开始时间加上period时间(循环间隔)
26      */
27     public static void main(String[] args) {
28         MyTask task = new MyTask();
29         Calendar calendar = Calendar.getInstance();
30         Date runDate = calendar.getTime();
31         Timer timer = new Timer();
32         timer.scheduleAtFixedRate(task, runDate, 4000);
33     }
34 }

　　scheduleAtFixedRate(TimerTask, long delay, long period)方法任务不延时----long类型

 1 import java.util.Timer;
 2 import java.util.TimerTask;
 3 
 4 /**
 5  * scheduleAtFixedRate(TimerTask, long delay, long period)方法任务不延时----long类型
 6  */
 7 public class Test2 {
 8     
 9     public static class MyTask extends TimerTask{
10         @Override
11         public void run() {
12             try {
13                 System.out.println("begin timer =" + System.currentTimeMillis());
14                 Thread.sleep(1000);
15                 System.out.println("end timer =" + System.currentTimeMillis());
16             } catch (InterruptedException e) {
17                 e.printStackTrace();
18             }
19         }
20     }
21     
22     /**
23      *     从运行结果可以看出,当没有延时,如果执行任务的时间没有被延时,则第一次执行任务的时间是任务的开始时间加上delay(延迟时间),
24      *     接下来执行任务的时间是上一次任务的开始时间加上period(循环间隔时间)
25      */
26     public static void main(String[] args) {
27         MyTask task = new MyTask();
28         System.out.println("当前时间为：" + System.currentTimeMillis());
29         Timer timer = new Timer();
30         timer.scheduleAtFixedRate(task, 3000, 4000);
31     }
32 }

延迟：

　　schedule(TimerTask, Date runDate, long period)方法 任务延时----Date类型

 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 import java.util.TimerTask;
 5 
 6 /**
 7  * schedule(TimerTask, Date runDate, long period)方法 任务延时----Date类型
 8  */
 9 public class Test3 {
10     
11     public static class MyTask extends TimerTask{
12         @Override
13         public void run() {
14             try {
15                 System.out.println("begin timer =" + System.currentTimeMillis());
16                 Thread.sleep(5000);
17                 System.out.println("end timer =" + System.currentTimeMillis());
18             } catch (InterruptedException e) {
19                 e.printStackTrace();
20             }
21         }
22     }
23     
24     /**
25      * 从运行结果可以看出,当有延时的情况下,如果执行任务的时间被延时,则下一次任务的执行时间是上一次任务结束时的时间作为参考计算
26      */
27     public static void main(String[] args) {
28         MyTask task = new MyTask();
29         Calendar calendar = Calendar.getInstance();
30         Date runDate = calendar.getTime();
31         Timer timer = new Timer();
32         timer.schedule(task, runDate, 2000);
33     }
34 }

　　schedule(TimerTask, long delay, long period)方法任务延时----long类型

 1 import java.util.Timer;
 2 import java.util.TimerTask;
 3 
 4 /**
 5  * schedule(TimerTask, long delay, long period)方法
 6  *         任务延时----long类型
 7  */
 8 public class Test4 {
 9     
10     public static class MyTask extends TimerTask{
11         @Override
12         public void run() {
13             try {
14                 System.out.println("begin timer =" + System.currentTimeMillis());
15                 Thread.sleep(5000);//延时5秒
16                 System.out.println("end timer =" + System.currentTimeMillis());
17             } catch (InterruptedException e) {
18                 e.printStackTrace();
19             }
20         }
21     }
22     
23     /**
24      *     从运行结果可以看出,当有延时的情况下,如果执行任务的时间被延时,那么下一次任务的执行时间是上一次任务结束时的时间作为参考计算
25      */
26     public static void main(String[] args) {
27         MyTask task = new MyTask();
28         System.out.println("当前时间为：" + System.currentTimeMillis());
29         Timer timer = new Timer();
30         timer.schedule(task, 3000, 2000);
31     }
32 }

　　scheduleAtFixedRate(TimerTask, Date runDate, long period)方法 任务延时----Date类型

 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 import java.util.TimerTask;
 5 
 6 /**
 7  * scheduleAtFixedRate(TimerTask, Date runDate, long period)方法 任务延时----Date类型
 8  */
 9 public class Test3 {
10     
11     public static class MyTask extends TimerTask{
12         @Override
13         public void run() {
14             try {
15                 System.out.println("begin timer =" + System.currentTimeMillis());
16                 Thread.sleep(5000);
17                 System.out.println("end timer =" + System.currentTimeMillis());
18             } catch (InterruptedException e) {
19                 e.printStackTrace();
20             }
21         }
22     }
23     
24     /**
25      * 从运行结果可以看出,当有延时的情况下,如果执行任务的时间被延时,则下一次任务的执行时间是上一次任务结束时的时间作为参考计算
26      */
27     public static void main(String[] args) {
28         MyTask task = new MyTask();
29         Calendar calendar = Calendar.getInstance();
30         Date runDate = calendar.getTime();
31         Timer timer = new Timer();
32         timer.scheduleAtFixedRate(task, runDate, 2000);
33     }
34 }

　　scheduleAtFixedRate(TimerTask, long delay, long period)方法任务延时----long类型

 1 import java.util.Timer;
 2 import java.util.TimerTask;
 3 
 4 /**
 5  * scheduleAtFixedRate(TimerTask, long delay, long period)方法
 6  *         任务延时----long类型
 7  */
 8 public class Test4 {
 9     
10     public static class MyTask extends TimerTask{
11         @Override
12         public void run() {
13             try {
14                 System.out.println("begin timer =" + System.currentTimeMillis());
15                 Thread.sleep(5000);//延时5秒
16                 System.out.println("end timer =" + System.currentTimeMillis());
17             } catch (InterruptedException e) {
18                 e.printStackTrace();
19             }
20         }
21     }
22     
23     /**
24      *     从运行结果可以看出,当有延时的情况下,如果执行任务的时间被延时,那么下一次任务的执行时间是上一次任务结束时的时间作为参考计算
25      */
26     public static void main(String[] args) {
27         MyTask task = new MyTask();
28         System.out.println("当前时间为：" + System.currentTimeMillis());
29         Timer timer = new Timer();
30         timer.scheduleAtFixedRate(task, 3000, 2000);
31     }
32 }

 

测试schedule()方法不具有追赶执行性：

 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 import java.util.TimerTask;
 5 
 6 public class Test {
 7 
 8     public static class MyTask extends TimerTask {
 9         @Override
10         public void run() {
11             System.out.println("begin timer：" + new Date());
12             System.out.println("end timer：" + new Date());
13         }
14     }
15     
16     /**
17      *     测试schedule()方法不具有追赶执行性
18      *         也就是如果计划时间在当前时间之前,那么当运行程序时,任务从当前时间开始执行,
19      *         计划时间到当前之间这段时间的任务就被取消了,不被执行,也就是任务不追赶
20      */
21     public static void main(String[] args) {
22         MyTask task = new MyTask();
23         System.out.println("现在执行时间：" + new Date());
24         Calendar calendar = Calendar.getInstance();
25         calendar.set(Calendar.SECOND, calendar.get(Calendar.SECOND)-20);
26         Date runDate = calendar.getTime();
27         System.out.println("计划执行时间为：" + runDate);
28         Timer timer = new Timer();
29         timer.schedule(task, runDate, 2000);
30     }
31 }

测试scheduleAtFixedRate()方法具有追赶执行性：

 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 import java.util.TimerTask;
 5 
 6 public class Test2 {
 7 
 8     public static class MyTask extends TimerTask {
 9         @Override
10         public void run() {
11             System.out.println("begin timer：" + new Date());
12             System.out.println("end timer：" + new Date());
13         }
14     }
15     
16     /**
17      *     测试scheduleAtFixedRate()方法具有追赶执行性
18      *         从运行结果可以看到,计划执行时间和当前时间之间对应的任务被补充性的执行,这就是task任务追赶特性
19      *         白话就是虽然时间过了,但是任务会在当前被补充执行完
20      */
21     public static void main(String[] args) {
22         MyTask task = new MyTask();
23         System.out.println("现在执行时间：" + new Date());
24         Calendar calendar = Calendar.getInstance();
25         calendar.set(Calendar.SECOND, calendar.get(Calendar.SECOND)-20);
26         Date runDate = calendar.getTime();
27         System.out.println("计划执行时间为：" + runDate);
28         Timer timer = new Timer();
29         timer.scheduleAtFixedRate(task, runDate, 2000);
30     }
31 }
posted @ 2018-09-04 09:40  为你编程  阅读(1830)  评论(0)  编辑  收藏  举报