java.util 套件之中有两个类别与工作排程非常有关系,他们分别是Timer与TimerTask。其中,Timer 是一个定时器,可以设定成特定时间或特定时间周期产生讯号。不过,只有Timer 是没有用的,必须配合TimerTask 才有作用。Timer一旦与某个TimerTask 产生关联,就会在产生讯号的同时,连带执行TimerTask所定义的工作。
TimerTask 的制作非常容易,任何一个类别只要继承TimerTask 类别,并实作其run()方法即可。Run()方法就是我们自行定义的工作,一旦Timer 在特定时间或特定时间周期产生讯号,run()方法就会被执行。我们会透过Timer 的schedule()方法来设定特定时间或特定时间周期,并将它与某个TimerTask 联系(进行TimerTask 的排程)。最后,您可以使用Timer 的cancel()方法来停止Timer,叫用cancel()之后,Timer 就会和TimerTask 脱离关系。TimerTask 本身也有cancel()方法。
假设我们希望在3 秒之后执行某些工作,范例程序如下:
//MyTask1.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class MyTask1 extends TimerTask { public void run() { //印出run()被叫用的时间 System.out.println("Task1 Fire Time:"); System.out.println(System.currentTimeMillis()); } } //TimerTest1.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class TimerTest1 extends MIDlet { public TimerTest1() { } public void startApp() { Timer timer = new Timer(); //规定3000 毫秒之后(3 秒)启动MyTask1 timer.schedule(new MyTask1(), 3000); //印出排程后的时间 System.out.println("Task Schedule Time:"); System.out.println(System.currentTimeMillis()); } public void pauseApp() { } public void destroyApp(boolean unconditional) { } }
执行结果:
Task Schedule Time:
1036932682671
Task1 Fire Time:
1036932685671
执行时,屏幕上会先印出
Task Schedule Time:
1036932682671
大约三秒钟之后才会印出。
Task1 Fire Time:
1036932685671
我们可以发现两者的时间差距为3000 豪秒。
Timer 的schedule()方法除了可以给定一个long 型态,也可以给定一个Date类别的实体。
几舍我们希望从现在起5 秒之后执行某些工作,范例程序如下:
//MyTask2.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class MyTask2 extends TimerTask { public void run() { System.out.println("Task2 Fire Time:"); System.out.println(System.currentTimeMillis()); } } //TimerTest2.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class TimerTest2 extends MIDlet { public TimerTest2() { } public void startApp() { Timer timer = new Timer(); Date after5sec = new Date(System.currentTimeMillis() + 5000); timer.schedule(new MyTask2(), after5sec); System.out.println("Task Schedule Time:"); System.out.println(System.currentTimeMillis()); } public void pauseApp() { } public void destroyApp(boolean unconditional) { } }
执行结果:
Task Schedule Time:
1036933242234
Task2 Fire Time:
1036933247250
执行时,屏幕上会先印出
Task Schedule Time:
1036933242234
大约五秒钟之后才会印出。
Task2 Fire Time:
1036933247250
我们可以发现两者的时间差距大约为5000 豪秒。之所以无法精确定差5000 毫秒,是因为在排程(呼叫timer.schedule(new MyTask2(),after5sec))之前,系统必须先取得目前时间,再产生Date 对象,这些动作都会造成些微的时间差。
上述两个范例都是设定在某个特定时间产生讯号,接下来我们将示范如何在某个特定的时间周期产生讯号。
假设我们希望在离现在5 秒钟之后,每格4 秒中产生讯号,范例程序如下:
//MyTask3.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class MyTask3 extends TimerTask { long lasttime; public void run() { long now = System.currentTimeMillis(); System.out.print("Task3 Fire Time: "); System.out.print(now); System.out.print(" ; Intervel :"); //计算出与上一次的时间差 System.out.println(now - lasttime); //重设上次发生时间为现在 lasttime = now; } } //TimerTest3.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class TimerTest3 extends MIDlet { Timer timer; public TimerTest3() { } public void startApp() { Form f = new Form("Test"); Display.getDisplay(this).setCurrent(f); timer = new Timer(); //Date after5sec = new Date(System.currentTimeMillis()+5000) ; MyTask3 mt = new MyTask3(); mt.lasttime = System.currentTimeMillis(); //timer.schedule(mt,after5sec,4000); timer.schedule(mt, 5000, 4000); System.out.println("Task Schedule Time:"); System.out.println(System.currentTimeMillis()); } public void pauseApp() { } public void destroyApp(boolean unconditional) { timer.cancel(); } }
执行结果:
Task Schedule Time:
1036934383453
Task3 Fire Time: 1036934388453 ; Intervel :5000
Task3 Fire Time: 1036934392453 ; Intervel :4000
Task3 Fire Time: 1036934396453 ; Intervel :4000
Task3 Fire Time: 1036934400453 ; Intervel :4000
Task3 Fire Time: 1036934404453 ; Intervel :4000
….
从范例中可以看出,第一个讯号出现在5 秒之后,往后的讯号都是每隔4 秒产生一次。周期性产生讯号所使用的sechdule()方法,其第二个参数可以是long或Date。在此范例中,使用了:
Form f = new Form("Test") ;
Display.getDisplay(this).setCurrent(f) ;
设定MIDlet 的显示画面,这纯粹是为了避开J2ME WTK 仿真器本身的bug,没有任何特别意义。
在MyTask3.java 之中,我们使用
long now = System.currentTimeMillis();
来抓取run()一开始执行时的时间。如果任何时候想到知道这一次的run()在何时启动,我们可以随时叫用TimerTask 的scheduledExecutionTime()方法。所以上述取得开始时间的方式可以用
long now = scheduledExecutionTime() ;
来取代,所以MyTask3.java 可以改成下面方式实作:
//MyTask3.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class MyTask3 extends TimerTask { long lasttime; public void run() { System.out.print("Task3 Fire Time: "); long now = scheduledExecutionTime(); System.out.print(now); System.out.print(" ; Intervel :"); System.out.println(now - lasttime); lasttime = now; } }
由于scheduledExecutionTime()方法只传回这次run()的起始时间,所以在任何地方呼叫都不会影响到时间精确度。更重要的一点, 如果scheduledExecutionTime()和System.currentTimeMillis()都可以达到我们的目的时,使用scheduledExecutionTime()比较不会浪费系统资源。另外要注意的是,当您不希望Timer 再产生讯号,您可以使用Timer 的cancel()方法来停止Timer,叫用cancel()之后,Timer 就会和TimerTask 脱离关系,而且不再产生任何讯号,此时TimerTask 才能重新被排程。
Timer 属于系统资源,每次MIDlet 离开之前,都应该使用Timer 的cancel()方法来停止Timer。TimerTask 本身也有cancel()方法,如果TimerTask 被排定特定的时间周期执行,那么叫用TimerTask 的cancel()方法之后,也可以保证往后其工作都不会再被执行。
最后,我们要讨论的是讯号精确度的问题。前面的范例中,TimerTask 里头都只有做简单的计算。由于简单的计算花的时间不多,所以都可以在下次重新产生讯号前完成。可是,如果run()里头的工作无法在下次产生讯号前完成呢?举例来说,我们希望每4 秒钟产生一次讯号,但是run()方法有时确需要5.5秒钟完成工作,有时2.2 秒就完成,范例如下:
//MyTask4.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class MyTask4 extends TimerTask { long lasttime; public void run() { long now = System.currentTimeMillis(); System.out.print("Task4 Fire Time: "); System.out.print(now); System.out.print(" ; Intervel :"); System.out.println(now - lasttime); lasttime = now; doSomething(); } public void doSomething() { //用随机数来模拟工作所需时间,有时超过4000 豪秒,有时少于4000 豪秒 try { Random rdm = new Random(); int i = rdm.nextInt() % 2; if (i == 0) { Thread.sleep(2500); System.out.println("doSomething : 2500 millisecond"); } else { Thread.sleep(5500); System.out.println("doSomething : 5500 millisecond"); } } catch (Exception e) {} } } //TimerTest4.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class TimerTest4 extends MIDlet { Timer timer; public TimerTest4() { } public void startApp() { Form f = new Form("Test"); Display.getDisplay(this).setCurrent(f); timer = new Timer(); //Date after5sec = new Date(System.currentTimeMillis()+5000) ; MyTask4 mt = new MyTask4(); mt.lasttime = System.currentTimeMillis(); //timer.schedule(mt,after5sec,4000); timer.schedule(mt, 5000, 4000); System.out.println("Task Schedule Time:"); System.out.println(System.currentTimeMillis()); } public void pauseApp() { } public void destroyApp(boolean unconditional) { timer.cancel(); } }
执行结果:
Task Schedule Time:
1036936893265
Task4 Fire Time: 1036936898265 ; Intervel :5000
doSomething : 5500 millisecond
Task4 Fire Time: 1036936903765 ; Intervel :5500
doSomething : 2500 millisecond
Task4 Fire Time: 1036936907765 ; Intervel :4000
doSomething : 2500 millisecond
Task4 Fire Time: 1036936911765 ; Intervel :4000
doSomething : 5500 millisecond
Task4 Fire Time: 1036936917265 ; Intervel :5500
doSomething : 5500 millisecond
Task4 Fire Time: 1036936922765 ; Intervel :5500
doSomething : 2500 millisecond
Task4 Fire Time: 1036936926765 ; Intervel :4000
doSomething : 5500 millisecond
从这个范例可以看出schedule()方法的运作属于一种称为fixed-delay execution 的模式。意思就是说,如果run()在时间周期之内完成,那么下一次的讯号就会在下一次预定的时间产生。但是,如果run()无法在时间周期之内完成,那么下一次的讯号就延迟,而且上一个run 执行之后就会立刻产生讯号。所以会有上述的结果。另外一个可以在固定周期产生讯号的方法为scheduleAtFixedRate(),但是其特性和schedule()不太相同。。范例如下(TimerTask 的部分我们仍采用MyTask4)
//TimerTest5.java import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import java.util.*; public class TimerTest5 extends MIDlet { Timer timer; public TimerTest5() { } public void startApp() { Form f = new Form("Test"); Display.getDisplay(this).setCurrent(f); timer = new Timer(); //Date after5sec = new Date(System.currentTimeMillis()+5000) ; MyTask4 mt = new MyTask4(); mt.lasttime = System.currentTimeMillis(); //timer.scheduleAtFixedRate(mt,after5sec,4000); timer.scheduleAtFixedRate(mt, 5000, 4000); System.out.println("Task Schedule Time:"); System.out.println(System.currentTimeMillis()); } public void pauseApp() { } public void destroyApp(boolean unconditional) { timer.cancel(); } }执行结果:
Task Schedule Time:
1036937109687
Task4 Fire Time: 1036937114703 ; Intervel :5016
doSomething : 5500 millisecond
Task4 Fire Time: 1036937120203 ; Intervel :5500
doSomething : 5500 millisecond
Task4 Fire Time: 1036937125703 ; Intervel :5500
doSomething : 2500 millisecond
Task4 Fire Time: 1036937128203 ; Intervel :2500
doSomething : 2500 millisecond
Task4 Fire Time: 1036937130703 ; Intervel :2500
doSomething : 2500 millisecond
Task4 Fire Time: 1036937134703 ; Intervel :4000
doSomething : 5500 millisecond
Task4 Fire Time: 1036937140203 ; Intervel :5500
doSomething : 2500 millisecond
Task4 Fire Time: 1036937142703 ; Intervel :2500
doSomething : 2500 millisecond
Task4 Fire Time: 1036937146703 ; Intervel :4000
doSomething : 5500 millisecond
从这个范例可以看出scheduleAtFixedRate()方法的运作属于一种称为fixed-rate execution 的模式。意思就是说,如果run()在时间周期之内完成,那么下一次的讯号就会在下一次预定的时间产生。但是,如果run()无法在时间周期之内完成,那么等到run 完成之后,下一次的讯号产生就尽量赶上原本应该产生讯号的时间。以上面的例子来说,第二次的讯号应该在第一次产生讯号之后4000 毫秒之后产生,可是却因为上一次的执行使得必需延迟1500 毫秒。
同样的,第三次讯号的产生应该在第一次产生讯号之后8000 毫秒之后产生,可是由于第二次的run()延迟1500 毫秒之后才完成,所以总计就比预计时间延迟了3000 毫秒。第三次所需工作时间只要2500 毫秒,因此完成第三次run()之后,系统必须要尽快赶上原本预计的时间,所以立刻产生讯号,使得第四次与第三次之间的时间差只有2500 毫秒,此时就赶上了1500 毫秒。第四次所需工作时间只要2500 毫秒,因此完成第四次run()之后,系统必须要尽快赶上原本预计的时间,所以立刻产生讯号,使得第五次与第四次之间的时间差只有2500 毫秒,此时又赶上了1500 毫秒。到目前为止,已经把落后都追回来了,这就是尽量赶上的意思。所以即使第五次的工作只花了2500 毫秒就完成,但是由于没有落后的进度需要追赶,所以和第六次的时间相差就是预计的4000 毫秒