Timer和TimerTask的使用（一

来源：互联网发布：中国汽车年度销量数据编辑：程序博客网时间：2024/06/04 21:00

Timer和TimerTask的使用（一）

(2006-08-15 17:30:14)

转载▼

分类： J2me语言

Timer和TimerTask是util包中两个与工作排程的类，Timer是计时器，可以设定成特定时间或特定的时间周期产生信号，不过这里只有Timer是没有用的，必须配合TimerTask才有作用。Timer一旦与某个TimerTask产生关联，就会在产生信号的同时，连带一起执行TimerTask所定义的工作。

　TimerTask的实现只需要继承TimerTask类就并实现其run()方法就可以了。run()方法是由我们自己来编写的，把你想做的工作放在里面，一旦Timer在特定时间内或周期产生信号，run()方法就会执行，我们通会Timer的schdeule()方法来设定特定时间或特定的周期。schdeule()有两种形式，一个是两个参数的，一个是三个参数的。二种参数的第一个参数是TimerTask的对象，第二个是时间也可是以Date对象。具有三个参数的schedule方法可以使一个task在某一个时间后，根据一定的间隔时间运行多次，具有周期性。最后，可以使用Timer的cancel()方法来停止Timer，调用cancel()之后，两者就会脱离关系。TimerTask本身也有cancel()方法。

我们看一个例子，在三秒之后执行某些工作：

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;

public class MyTask1 extends TimerTask
{
    public void run()
    {
     System.out.println("Task1 Fire Time:") ;
        System.out.println(System.currentTimeMillis());
    }
}

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() ;
         timer.schedule(new MyTask1(),3000);
         System.out.println("Task Schedule Time:") ;
         System.out.println(System.currentTimeMillis());
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
}
这里，我们使用两种不同颜色来写书二个类，一个类继承TimerTask类，一个类继承MIDlet，这样编程有利于我们观察和以后的修改，不会出现一大长串代码的情况。

执行时会出现：

Task Schedule Time:

//时间

Task1 Fire Time:

//时间

我们可以发现两者之间相差3000毫秒。

这里schedule()方法除了给定一个long型外，还可以用上面所说的Date类的实体，假设我们在五秒后执行某些动作：

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());
    }
}

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)
{
}
}
我们可以发现两者之者大约相差为5000毫秒，但没有很精确，因为在调用(timer.schedule(new MyTask2(),after5

果你使用Java语言进行开发，对于定时执行任务这样的需求，自然而然会想到使用Timer和TimerTask完成任务，我最近就使用 Timer和TimerTask完成了一个定时执行的任务，实现得没有问题，但当在TimerTaks的run()方法中使用 Thread.sleep()方式时，可能会出现奇怪的现象，好像Timer失效了，网上查了一下，倒是有人遇到了相同的问题，但是并没有找到一篇解释为什么会出现这种情况，期待有某位达人能够分析清楚这个问题。

遇到了这样的问题，始终让我不爽，于是看了一下Timer的源码，先将了解到的内容整理如下，接下来再看看Thread.sleep()的源码，看能否找到问题所在。

在Java中，与定时任务执行相关的类很少，只有Timer、TimerTask、TimerThread、TaskQueue几个，其中每个类的职责大致如下：

Timer：一个Task的调度类，和TimerTask一样，暴露给最终用户使用的类，通过schedule方法安排Task的执行计划。该类通过TaskQueue和TimerThread类完成Task的调度。

TimerTask：实现Runnable接口，表明每一个任务均为一个独立的线程。通过run()方法提供用户定制自己任务。该类有一个比较重要的成员变量nextExecutionTime ，表示下一次执行该任务的时间。以后会看到，Timer机制就是靠这个值安排Task执行的。

TimerThread：继承于Thread，是真正执行Task的类。

TaskQueue：一个存储Task的数据结构，内部由一个最小堆实现，堆的每个成员为一个TimeTask，每个Task依靠其 nextExecutionTime值进行排序，也就是说，nextExecutionTime最小的任务在队列的最前端，从而能够现实最早执行。

要想使用Timer，用户只需要了解Timer和TimerTask，下面现已一个最基本的Timer和TimerTask使用案例入手，来看一下Timer内部的实现原理。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
importjava.util.Timer;
 
importjava.util.TimerTask;
 
importorg.junit.Test;
 
  
 
classTestTimerTask extendsTimerTask {
 
  @Override
 
  publicvoidrun() {
 
    System.out.println("TestTimerTask is running......");
 
  }
 
}
 
publicclassTimerTaskTest {
 
  @Test
 
  publicvoidtestTimerTask() {
 
    Timer timer = newTimer();
 
    timer.schedule(newTestTimerTask(), 0, 10);
 
  }
 
}

上面的代码是一个典型的Timer&TimerTask的应用，下面先来看一下new Timer()干了什么事，其源码如下：

public Timer(String name) {

thread.setName(name); //thread为TimerThread实例。

thread.start();

}

从上面的源代码可以知道，创建Timer对象的同时也启动了TimerThread线程。下面来看看TimerThread干了什么事：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
publicvoidrun() {
 
        try{
 
            mainLoop();                 //线程真正执行的代码在这个私有方法中
 
        } finally{
 
            // Someone killed this Thread, behave as if Timer cancelled
 
            synchronized(queue) {
 
                newTasksMayBeScheduled = false;
 
                queue.clear();  // Eliminate obsolete references
 
            }
 
        }
 
}

接着来看看私有方法mainLoop()干了什么事：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
privatevoidmainLoop() {
 
        while(true) {
 
            try{
 
                TimerTask task;
 
                booleantaskFired;       //是否已经到达Task的执行时间，如果已经到达，设置为true，否则置为false
 
                synchronized(queue) {
 
                    // Wait for queue to become non-empty
 
                    while(queue.isEmpty() && newTasksMayBeScheduled)
 
                        queue.wait();                //由此可以看出，Timer通过wait & notify 方法安排线程之间的同步
 
                    if(queue.isEmpty())
 
                        break; // Queue is empty and will forever remain; die
 
  
 
                    // Queue nonempty; look at first evt and do the right thing
 
                    longcurrentTime, executionTime;
 
                    task = queue.getMin();
 
                    synchronized(task.lock) {
 
                        if(task.state == TimerTask.CANCELLED) {
 
                            queue.removeMin();
 
                            continue;  // No action required, poll queue again
 
                        }
 
                        currentTime = System.currentTimeMillis();
 
                        executionTime = task.nextExecutionTime;
 
                        if(taskFired = (executionTime<=currentTime)) {        //Task的执行时间已到，设置taskFired为true
 
                            if(task.period == 0) { // Non-repeating, remove
 
                                queue.removeMin();        //移除队列中的当前任务
 
                                task.state = TimerTask.EXECUTED;
 
                            } else{ // Repeating task, reschedule
 
                                queue.rescheduleMin(         //重新设置任务的下一次执行时间
 
                                  task.period<0? currentTime   - task.period
 
                                                : executionTime + task.period);
 
                            }
 
                        }
 
                    }
 
                    if(!taskFired) // Task hasn't yet fired; wait
 
                        queue.wait(executionTime - currentTime);    //还没有执行时间，通过wait等待特定时间
 
                }
 
                if(taskFired)  // Task fired; run it, holding no locks
 
                    task.run();    //已经到达执行时间，执行任务
 
            } catch(InterruptedException e) {
 
            }
 
        }
 
}

也就是说，一旦创建了Timer类的实例，就一直存在一个循环在遍历queue中的任务，如果有任务的话，就通过thread去执行该任务，否则线程通过wait()方法阻塞自己，由于没有任务在队列中，就没有必要继续thread中的循环。

上面提到，如果Timer的任务队列中不包含任务时，Timer中的TimerThread线程并不会执行，接着来看看为Timer添加任务后会出现怎样的情况。为Timer添加任务就是timer.schedule()干的事，schedule()方法直接调用Timer的私有方法 sched()，sched()是真正安排Task的地方，其源代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
privatevoidsched(TimerTask task, longtime, longperiod) {
 
        if(time < 0)
 
            thrownewIllegalArgumentException("Illegal execution time.");
 
  
 
        synchronized(queue) {
 
            if(!thread.newTasksMayBeScheduled)
 
                thrownewIllegalStateException("Timer already cancelled.");
 
  
 
            synchronized(task.lock) {
 
                if(task.state != TimerTask.VIRGIN)             //我喜欢virgin状态，其他状态表明该Task已经被schedule过了
 
                    thrownewIllegalStateException(
 
                        "Task already scheduled or cancelled");
 
                 
 
                 //设置Task下一次应该执行的时间, 由System.currentTimeMillis()+/-delay得到
 
                task.nextExecutionTime = time;              
 
                task.period = period;
 
                task.state = TimerTask.SCHEDULED;
 
            }
 
  
 
            queue.add(task);            //queue为TaskQueue类的实例，添加任务到队列中
 
            if(queue.getMin() == task)        //获取队列中nextExecutionTime最小的任务，如果与当前任务相同
 
                queue.notify();                         //还记得前面看到的queue.wait()方法么
 
        }
 
}

不要奇怪，为什么要判断queue.getMin() == task时，才通过queue.notify()恢复执行。因为这种方式已经满足所有的唤醒要求了。

如果安排当前Task之前queue为空，显然上述判断为true，于是mainLoop()方法能够继续执行。

如果安排当前Task之前queue不为空，那么mainLoop()方法不会一直被阻塞，不需要notify方法调用。

调用该方法还有一个好处是，如果当前安排的Task的下一次执行时间比queue中其余Task的下一次执行时间都要小，通过notify方法可以提前打开queue.wait(executionTime - currentTime)方法对mainLoop()照成的阻塞，从而使得当前任务能够被优先执行，有点抢占的味道。

上述分析可以看出，Java中Timer机制的实现仅仅使用了JDK中的方法，通过wait & notify机制实现，其源代码也非常简单，但可以想到的是这种实现机制会对开发者造成一种困扰，sched()方法中可以看出，对于一个重复执行的任务，Timer的实现机制是先安排Task下一次执行的时间，然后再启动Task的执行，如果Task的执行时间大于下一次执行的间隔时间，可能出现不可预期的错误。当然，了解了Timer的实现原理，修改这种实现方式也就非常简单了。

java定时器的使用（Timer）

1、在应用开发中，经常需要一些周期性的操作，比如每5分钟执行某一操作等。

对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。

private java.util.Timer timer;

timer = new Timer(true);

timer.schedule(

new java.util.TimerTask() { public void run()

{ //server.checkNewMail(); 要操作的方法} }, 0, 5*60*1000);

第一个参数是要操作的方法，第二个参数是要设定延迟的时间，第三个参

数是周期的设定，每隔多长时间执行该操作。

使用这几行代码之后，Timer本身会每隔5分钟调用一遍

server.checkNewMail()方法，不需要自己启动线程。Timer本身也是多线程同

步的，多个线程可以共用一个Timer，不需要外部的同步代码。

2、

(1)Timer.schedule(TimerTask task,Date time)安排在制定的时间执行指定的

任务。

(2)Timer.schedule(TimerTask task,Date firstTime ,long period)安排指定

的任务在指定的时间开始进行重复的固定延迟执行．

(3)Timer.schedule(TimerTask task,long delay)安排在指定延迟后执行指定的

任务．

(4)Timer.schedule(TimerTask task,long delay,long period)安排指定的任务

从指定的延迟后开始进行重复的固定延迟执行．

(5)Timer.scheduleAtFixedRate(TimerTask task,Date firstTime,long period)

安排指定的任务在指定的时间开始进行重复的固定速率执行．

(6)Timer.scheduleAtFixedRate(TimerTask task,long delay,long period)安

排指定的任务在指定的延迟后开始进行重复的固定速率执行．

用Java Timer API进行时间调度开发的相关注意点

java.util这个包中可以找到Timer和TimerTask这两个类。Timer直接从Object

继承，它相当于一个计时器，能够用它来指定某个时间来执行一项任务，或者

每隔一定时间间隔反复执行同一个任务。创建一个Timer后，就会生成一个线程

在背后运行，来控制任务的执行。而TimerTask就是用来实现某项任务的类，

它实现了Runnable接口，因此相当于一个线程。

如何实现自己的任务调度？

1、继承TimerTask，注意TimerTask是实现Runnable接口的，因此只要重载run()

方法即可。

2、创建Timer对象，调用schedule()方法。