Timer和TimerTask

  有时候需要每隔一段时间去执行某个任务，在Java中提供了Timer和TimerTask来完成这个任务，这个两个类位于java.util包中。Timer类是Java中一种线程设施，用于安排以后在后台线程中执行的任务，可以安排任务执行一次或定期重复执行。与每个Timer对象对应的是单个后台线程，用于顺序的执行所有计时器任务。

      对Timer对象最后的引用完成后，并且所有未处理的任务都已执行完毕后，计时器的任务执行线程会正常终止，并且成为垃圾回收的对象。但是这可能要很长时间后才能发生。默认情况下，任务执行线程并不作为守护线程来运行，所以它能够阻止应用程序终止。如果调用者想要快速终止计时器的任务执行线程，那么请调用计时器的cancel方法。

      TimerTask对象由Timer安排为一次执行或重复执行的任务，也就是说，Timer负责计时，具体的任务由TimerTask来完成。

      以下用两段程序来说明它们的用法。

Example1：LOGO闪屏

     在游戏中，当游戏开始之前，会显示一些Logo图片，在显示Logo图片的同时，进行资源文件的加载。这种情形可以利用Timer来进行图片的切换工作，先看看派生自TimerTask的具体的任务完成类EventTimerTask类源代码：
[java] view plaincopy

    <p>import java.util.Timer;  
    import java.util.TimerTask;</p><p>class EventTimerTask extends TimerTask{     
        private int imageNum;  
        private int imageCur = 0;     
        private Timer timer;     
          
        public void run(){     
            //判断当前显示的图片序号     
            if(++imageCur <= imageNum){     
                System.out.println("当前屏幕上显示的是第" + imageCur + "张图片");     
            }else{     
                timer.cancel();     
                System.out.println("游戏资源加载完毕，开始进入游戏");     
            }     
        }    </p><p>    public void setImageNum(int imageNum){     
            this.imageNum = imageNum;     
        }     
            
        public void setTimer(Timer timer){     
            this.timer = timer;     
        }    
    }</p>  
       

接下来是类ReadLogo代码：
[java] view plaincopy

    import java.util.Timer;     
    import java.util.TimerTask;     
        
    public class ReadLogo{     
        private Timer timer = new Timer();     
        private EventTimerTask timerTask = new EventTimerTask();     
        private int imageNum = 10;     
        private int delay = 1;     
        private int second = 2;     
          
        public void startTimerTask(){     
            timerTask.setTimer(timer);     
            timerTask.setImageNum(imageNum);   
            timer.schedule(timerTask, delay*1000, second*1000);     
            System.out.println("加载其它游戏资源......");     
        }     
          
        public static void main(String[] args){     
            ReadLogo rl = new ReadLogo();     
            rl.startTimerTask();     
        }     
    }  
       

程序运行结果：

加载其它游戏资源......
当前屏幕上显示的是第1张图片
当前屏幕上显示的是第2张图片
当前屏幕上显示的是第3张图片
当前屏幕上显示的是第4张图片
当前屏幕上显示的是第5张图片
当前屏幕上显示的是第6张图片
当前屏幕上显示的是第7张图片
当前屏幕上显示的是第8张图片
当前屏幕上显示的是第9张图片
当前屏幕上显示的是第10张图片
游戏资源加载完毕，开始进入游戏
 

Example2：煮鸡蛋计时程序
[java] view plaincopy

    <p>import java.util.Timer;  
    import java.util.TimerTask;</p><p>public class EggTask extends TimerTask {  
        private Timer timer;  
        public EggTask(Timer timer){  
            this.timer = timer;  
        }  
          
        public void run(){  
            playSound();  
            timer.cancel();  
        }  
          
        private void playSound(){  
            System.out.println("鸡蛋煮好了，播放声音！~~~");  
        }  
    }</p>  
       

[java] view plaincopy

    public class EggTimer {  
        private final Timer timer = new Timer();  
        private final int minutes;  
        public EggTimer(int minutes){  
            this.minutes = minutes;  
        }  
          
        public void start(){  
            EggTask et = new EggTask(timer);  
            //将任务和计时器关联在一起。第一个参数是要执行的任务  
            //第二个参数是执行任务前的延迟时间，单位是毫秒  
            timer.schedule(et, minutes*60*1000);  
        }  
          
        public static void main(String[] args){  
            final int minutes = 2;  
            System.out.println("煮鸡蛋计时器开始记时，"+minutes+"分钟后鸡蛋煮熟会播放声音！");  
              
            EggTimer eggTimer = new EggTimer(minutes);  
            eggTimer.start();  
        }  
    }  

程序运行结果

煮鸡蛋计时器开始记时，2分钟后鸡蛋煮熟会播放声音！
鸡蛋煮好了，播放声音！~~~
 

==============================================================================================================
Java2的开发包中提供了一种很使用的线程功能：提前安排将来某段时间执行某任务Timer ，TimerTask。你可以使用这些类创建后台进程，让其在等待一段规定的时间后执行，或者让其没隔一段时间执行。你也可以用Thread来完成，但利用Timer与TimerTask显然省事不少。

TimerTask实现了Runnable接口，待执行的任务置于run()中。Timer是一个安排TimerTask的类此此两者一般一起工作。所应用时首先硬创建一个TimerTask的对象，然后用一个Timer的类对象安排执行它


  Timer类包含的方法有：
  1.Timer()
  以常规方式运行task


  2.Timer(boolean)
  true时使用后台进程线程。只要剩下的程序记叙运行，后台进程线程就会执行。


  3.public void cancel()
  终止Timer的功能执行，但不会对正在执行的任务有影响。当执行cancel方法后将不能再用其分配任务。


  4.public void schedule(TimerTask task,Date time)
  task被安排在time指定的时间执行，如果时间为过去时则任务立刻执行。


  5.public void schedule(TimerTask task, Date firstTime, long period)
  task被安排在time指定的时间执行，执行后将每隔period(毫秒)反复执行。由于规定的时间间隔并不能保证与时钟精准的同不步，所以该方法最适合从短期看保持频率准确是更重要的的地方


  6.public void schedule(TimerTask task, long delay)
  task被安排在delay（毫秒）指定的时间后执行。


  7.public void schedule(TimerTask task,long delay, long period)
  task被安排在delay（毫秒）指定的时间后执行。执行后将每隔period(毫秒)反复执行。


  8.public void scheduleAtFixedRate(TimerTask task,Date firstTime, long period)
  task被安排在firstTime指定的时间执行。执行后将每隔period(毫秒)反复执行。每一次重复的时间时盒第一次执行而不是和前一次执行有关。因此执行的总速度是固定的。


  9.public void scheduleAtFixedRate(TimerTask task,long delay,long period)
  task被安排在delay（毫秒）指定的时间后执行。执行后将每隔period(毫秒)反复执行。每一次重复的时间时盒第一次执行而不是和前一次执行有关。因此执行的总速度是固定的。


  TimerTask的主要方法：
  1.public boolean cancel()
  终止任务的执行运行。如果Timer时要求循环执行的，则如果正在执行，则执行完了就再步会循环。如果还未执行或处于停歇期，则不会执行了


  2.public abstract void run()


  3.public long scheduledExecutionTime()
  返回被安排最后执行任务的时间。一般确定任务的当今的实行是否足够及时 ，证明进行被计划的活动为正当： 
 
[java] view plaincopy

    public void run() {  
           if (System.currentTimeMillis() - scheduledExecutionTime() >=  
               MAX_TARDINESS)  
                   return;  // Too late; skip this execution.  
           // Perform the task  
       }   


 

  4.protected TimerTask()
[java] view plaincopy

    import java.util.*;  
    import java.io.*;  
      
    public class doTask extends TimerTask {  
        String index;  
        Timer myTimer = new Timer();  
        public doTask(String index) {  
            this.index = index;  
        }  
      
        public void run() {  
            System.out.println(index);  
        }  
      
        public static void main(String args[]) {  
            doTask myTask1 = new doTask("First task");  
            myTask1.start(0,3);  
            doTask myTask2 = new doTask("Second task");  
            myTask2.start(0,1);  
      
            try{  
                Thread.sleep(6000);  
            }  
            catch(InterruptedException e){              
            }     
              
            myTask1.end();  
            myTask2.end();//程序结束时用cancel()结束Timer  
              
        }  
      
        public void start(int delay, int internal) {  
            myTimer.schedule(this, delay * 1000, internal * 1000); //利用timer.schedule方法  
        }  
        public void end(){  
            myTimer.cancel();  
        }  
    }  


 

输出：
First task
Second task
Second task
Second task
First task
Second task
Second task
Second task