Timer定时器

Timer定时任务相关：

　　情景1：定时任务执行时间为当前运行程序启动10秒之后

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 /**
 5  *    定时任务类,继承TimerTask类
 6  */
 7 public class MyTask extends TimerTask {
 8 
 9     @Override
10     public void run() {
11         System.out.println("任务执行,时间为：" + new Date());
12     }
13 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 public class Test {
 6     /**
 7      *    通过测试结果可以看出任务执行了,但是执行完之后当前进程并没有销毁
 8      *        因为创建Timer的时候,启动了一个新的线程,并且这个线程并不是守护线程,一直在运行
 9      */
10     public static void main(String[] args) {
11         System.out.println("当前时间为：" + new Date());
12         Calendar calendar = Calendar.getInstance();
13         calendar.add(Calendar.SECOND, 10);
14         MyTask task = new MyTask();
15         Timer timer = new Timer();
16         timer.schedule(task, calendar.getTime());
17     }
18 }

运行结果如下：

　　

 

 　　情景2：创建的Timer为守护线程,解决上面进程不销毁的情况

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 /**
 5  *    定时任务类,继承TimerTask类
 6  */
 7 public class MyTask extends TimerTask {
 8 
 9     @Override
10     public void run() {
11         System.out.println("任务执行,时间为：" + new Date());
12     }
13 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 public class Test {
 6     /**
 7      *    通过测试结果可以看出程序运行后迅速结束当前的进程,
 8      *        而此时TimerTask中的任务还没被执行(因为进程已经结束了)
 9      */
10     public static void main(String[] args) {
11         System.out.println("当前时间为：" + new Date());
12         Calendar calendar = Calendar.getInstance();
13         calendar.add(Calendar.SECOND, 10);
14         Date runDate = calendar.getTime();
15         MyTask task = new MyTask();
16         Timer timer = new Timer(true);//设置创建的Timer为守护线程
17         timer.schedule(task, runDate);
18     }
19 }

运行结果如下：

　　

 

 　　情景3：执行任务的时间早于当前时间

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 /**
 5  *    定时任务类,继承TimerTask类
 6  */
 7 public class MyTask extends TimerTask {
 8 
 9     @Override
10     public void run() {
11         System.out.println("任务执行,时间为：" + new Date());
12     }
13 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 public class Test {
 6     /**
 7      *    通过测试结果可以看出如果执行任务的时间早于当前时间,则任务立刻被执行
 8      */
 9     public static void main(String[] args) {
10         System.out.println("当前时间为：" + new Date());
11         Calendar calendar = Calendar.getInstance();
12         //将执行任务的时间提前10秒
13         calendar.set(Calendar.SECOND, calendar.get(Calendar.SECOND)-10);
14         Date runDate = calendar.getTime();
15         System.out.println("计划时间为：" + runDate);
16         MyTask task = new MyTask();
17         Timer timer = new Timer();
18         timer.schedule(task, runDate);
19     }
20 }

运行结果如下：

　　

 

 　　情景4：Timer运行有多个TimerTask任务及延时

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 /**
 5  *    定时任务类,继承TimerTask类
 6  */
 7 public class MyTask extends TimerTask {
 8 
 9     @Override
10     public void run() {
11         System.out.println("任务执行,时间为：" + new Date());
12     }
13 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 public class Test {
 6 
 7     /**
 8      *    Timer运行有多个TimerTask任务及延时
 9      */
10     public static void main(String[] args) {
11         System.out.println("当前时间为：" + new Date());
12         
13         Calendar calendar1 = Calendar.getInstance();
14         calendar1.add(Calendar.SECOND, 10);
15         Date runDate1 = calendar1.getTime();
16         System.out.println("计划时间：" + runDate1);
17         
18         Calendar calendar2 = Calendar.getInstance();
19         calendar2.add(Calendar.SECOND, 15);
20         Date runDate2 = calendar2.getTime();
21         System.out.println("计划时间：" + runDate2);
22         
23         MyTask task1 = new MyTask();
24         MyTask task2 = new MyTask();
25 
26         Timer time = new Timer();
27         time.schedule(task1, runDate1);
28         time.schedule(task2, runDate2);
29     }
30 }

运行结果如下：

　　　

　　情景5：TimerTask是以队列的方式一个一个被顺序的执行,所有执行的时间有可能和预期的时间不一致,因为前面的任务有可能消耗的时间较长,则后面的任务运行的时间也被拖延

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 public class MyTaskA extends TimerTask {
 5 
 6     @Override
 7     public void run() {
 8         try {
 9             System.out.println("A begin timer：" + new Date());
10             Thread.sleep(20000);
11             System.out.println("A end timer：" + new Date());
12         } catch (InterruptedException e) {
13             e.printStackTrace();
14         }
15     }
16 }
 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 public class MyTaskB extends TimerTask {
 5 
 6     @Override
 7     public void run() {
 8         System.out.println("B begin timer：" + new Date());
 9         System.out.println("B end timer：" + new Date());
10     }
11 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 public class Test {
 6 
 7     /**
 8      *    TimerTask是以队列的方式一个一个被顺序的执行,所有执行的时间有可能和预期的时间不一致,因为前面的任务有可能消耗的时间较长,则后面的任务运行的时间也被拖延
 9      */
10     public static void main(String[] args) {
11         System.out.println("当前时间为：" + new Date());
12         
13         Calendar calendar1 = Calendar.getInstance();
14         Date runDate1 = calendar1.getTime();
15         System.out.println("A计划时间：" + runDate1);
16         
17         Calendar calendar2 = Calendar.getInstance();
18         calendar2.add(Calendar.SECOND, 10);
19         Date runDate2 = calendar2.getTime();
20         System.out.println("B计划时间：" + runDate2);
21         
22         MyTaskA task1 = new MyTaskA();
23         MyTaskB task2 = new MyTaskB();
24 
25         Timer time = new Timer();
26         time.schedule(task1, runDate1);
27         time.schedule(task2, runDate2);
28     }
29 }

运行结果如下：

　　

 

 　　情景6：schedule(TimerTask, Date runDate, long period) 在指定的日期之后按照指定的时间间隔无限循环的执行某一个任务

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 public class MyTask extends TimerTask {
 5 
 6     @Override
 7     public void run() {
 8         System.out.println("任务执行,时间为：" + new Date());
 9     }
10 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 /**
 6  *    schedule(TimerTask, Date runDate, long period)
 7  *    在指定的日期之后按照指定的时间间隔无限循环的执行某一个任务
 8  */
 9 public class Test {
10     /**
11      * 测试计划时间大于当前时间,程序运行之后,到达指定时间后开始执行任务,并且每4秒执行一次
12      */
13     public static void main(String[] args) {
14         System.out.println("当前时间为：" + new Date());
15         Calendar calendar = Calendar.getInstance();
16         calendar.add(Calendar.SECOND, 10);
17         Date runDate = calendar.getTime();
18         System.out.println("计划时间为：" + runDate);
19         MyTask task = new MyTask();
20         Timer timer = new Timer();
21         timer.schedule(task, runDate, 4000);
22     }
23 }

 

 　　情景7：schedule(TimerTask, Date runDate, long period) 在指定的日期之后按照指定的时间间隔无限循环的执行某一个任务

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 public class MyTask extends TimerTask {
 5 
 6     @Override
 7     public void run() {
 8         System.out.println("任务执行,时间为：" + new Date());
 9     }
10 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 /**
 6  *    schedule(TimerTask, Date runDate, long period)
 7  *    在指定的日期之后按照指定的时间间隔无限循环的执行某一个任务
 8  */
 9 public class Test {
10     /**
11      * 测试计划时间小于当前时间,程序运行后立刻执行任务
12      */
13     public static void main(String[] args) {
14         System.out.println("当前时间为：" + new Date());
15         Calendar calendar = Calendar.getInstance();
16         calendar.set(Calendar.SECOND, calendar.get(Calendar.SECOND)-10);
17         Date runDate = calendar.getTime();
18         System.out.println("计划时间为：" + runDate);
19         MyTask task = new MyTask();
20         Timer timer = new Timer();
21         timer.schedule(task, runDate, 4000);
22     }
23 }

　　情景8：schedule(TimerTask, Date runDate, long period) 在指定的日期之后按照指定的时间间隔无限循环的执行某一个任务

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 public class MyTaskA extends TimerTask {
 5 
 6     @Override
 7     public void run() {
 8         try {
 9             System.out.println("A begin timer：" + new Date());
10             Thread.sleep(5000);
11             System.out.println("A end timer：" + new Date());
12         } catch (InterruptedException e) {
13             e.printStackTrace();
14         }
15     }
16 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 /**
 6  *    schedule(TimerTask, Date runDate, long period)
 7  *    在指定的日期之后按照指定的时间间隔无限循环的执行某一个任务
 8  */
 9 public class Test {
10     
11     /**
12      * 测试任务执行时间被延时,从结果可以看出,任务被延时,并且还是得一个一个执行
13      */
14     public static void main(String[] args) {
15         System.out.println("当前时间为：" + new Date());
16         Calendar calendar = Calendar.getInstance();
17         calendar.add(Calendar.SECOND, 10);
18         Date runDate = calendar.getTime();
19         System.out.println("计划时间为：" + runDate);
20         MyTaskA task = new MyTaskA();
21         Timer timer = new Timer();
22         timer.schedule(task, runDate, 3000);
23     }
24 }

　　情景9：TimerTask类中的cancel()方法：将自身从任务队列中清除

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 public class MyTaskA extends TimerTask {
 5 
 6     @Override
 7     public void run() {
 8         System.out.println("A run timer：" + new Date());
 9         this.cancel();//移除当前任务
10         System.out.println("A任务自己移除了自己");
11     }
12 }
 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 public class MyTaskB extends TimerTask {
 5 
 6     @Override
 7     public void run() {
 8         System.out.println("B run timer：" + new Date());
 9     }
10 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 /**
 6  *    schedule(TimerTask, Date runDate, long period)
 7  *    在指定的日期之后按照指定的时间间隔无限循环的执行某一个任务
 8  */
 9 public class Test {
10     
11     /**
12      * TimerTask类中的cancel()方法：将自身从任务队列中清除
13      */
14     public static void main(String[] args) {
15         System.out.println("当前时间为：" + new Date());
16         Calendar calendar = Calendar.getInstance();
17         calendar.add(Calendar.SECOND, 10);
18         Date runDate = calendar.getTime();
19         System.out.println("计划时间为：" + runDate);
20         MyTaskA task1 = new MyTaskA();
21         MyTaskB task2 = new MyTaskB();
22         Timer timer = new Timer();
23         timer.schedule(task1, runDate, 4000);
24         timer.schedule(task2, runDate, 4000);
25     }
26 }

　　情景10：Timer类中的cancel()方法：将任务队列中的全部任务清空

 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 public class MyTaskA extends TimerTask {
 5 
 6     @Override
 7     public void run() {
 8         System.out.println("A run timer：" + new Date());
 9     }
10 }
 1 import java.util.Date;
 2 import java.util.TimerTask;
 3 
 4 public class MyTaskB extends TimerTask {
 5 
 6     @Override
 7     public void run() {
 8         System.out.println("B run timer：" + new Date());
 9     }
10 }
 1 import java.util.Calendar;
 2 import java.util.Date;
 3 import java.util.Timer;
 4 
 5 /**
 6  *    schedule(TimerTask, Date runDate, long period)
 7  *    在指定的日期之后按照指定的时间间隔无限循环的执行某一个任务
 8  */
 9 public class Test {
10     
11     /**
12      * Timer类中的cancel()方法：将任务队列中的全部任务清空
13      *         当使用Timer类中的cancel()方法时,不一定会停止任务,
14      *         因为cancel()方法有时并没有抢到queue锁,则任务会被正常执行
15      */
16     public static void main(String[] args) {
17         try {
18             System.out.println("当前时间为：" + new Date());
19             Calendar calendar = Calendar.getInstance();
20             Date runDate = calendar.getTime();
21             System.out.println("计划时间为：" + runDate);
22             MyTaskA task1 = new MyTaskA();
23             MyTaskB task2 = new MyTaskB();
24             Timer timer = new Timer();
25             timer.schedule(task1, runDate, 2000);
26             timer.schedule(task2, runDate, 2000);
27             Thread.sleep(10000);
28             timer.cancel();//移除当前所有任务
29         } catch (InterruptedException e) {
30             e.printStackTrace();
31         }
32     }
33 }

 测试1：

 1 import java.util.Date;
 2 import java.util.Timer;
 3 import java.util.TimerTask;
 4 
 5 /**
 6  *    schedule(TimerTask,long delay): 
 7  *        以当前时间为参考,延迟指定时间后执行任务
 8  */
 9 public class Test {
10     
11     public static class MyTask extends TimerTask{
12         @Override
13         public void run() {
14             System.out.println("执行任务,时间为：" + new Date());
15         }
16     }
17     
18     public static void main(String[] args) {
19         MyTask task = new MyTask();
20         Timer timer = new Timer();
21         System.out.println("当前时间为：" + new Date());
22         timer.schedule(task, 4000);
23     }
24 }

测试2：

 1 import java.util.Date;
 2 import java.util.Timer;
 3 import java.util.TimerTask;
 4 
 5 /**
 6  *    schedule(TimerTask,long delay,long period): 
 7  *        以当前时间为参考,延迟指定时间后执行任务,并每隔指定时间循环执行
 8  */
 9 public class Test2 {
10     
11     public static class MyTask extends TimerTask{
12         @Override
13         public void run() {
14             System.out.println("执行任务,时间为：" + new Date());
15         }
16     }
17     
18     public static void main(String[] args) {
19         MyTask task = new MyTask();
20         Timer timer = new Timer();
21         System.out.println("当前时间为：" + new Date());
22         timer.schedule(task, 3000, 5000);
23     }
24 }
posted @ 2018-09-04 09:39  为你编程  阅读(351)  评论(0)  编辑  收藏  举报