如果你使用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内部的实现原理。
01
|
import java.util.Timer;
|
02
|
03
|
import java.util.TimerTask;
|
04
|
05
|
import org.junit.Test;
|
06
|
07
|
|
08
|
09
|
class TestTimerTask extends TimerTask
{
|
10
|
11
|
@Override
|
12
|
13
|
public void run()
{
|
14
|
15
|
System.out.println("TestTimerTask
is running......");
|
16
|
17
|
}
|
18
|
19
|
}
|
20
|
21
|
public class TimerTaskTest
{
|
22
|
23
|
@Test
|
24
|
25
|
public void testTimerTask()
{
|
26
|
27
|
Timer
timer = new Timer();
|
28
|
29
|
timer.schedule(new TestTimerTask(), 0, 10);
|
30
|
31
|
}
|
32
|
33
|
}
|
上面的代码是一个典型的Timer&TimerTask的应用，下面先来看一下new Timer()干了什么事，其源码如下：
public Timer(String name) {
thread.setName(name); //thread为TimerThread实例。
thread.start();
}
从上面的源代码可以知道，创建Timer对象的同时也启动了TimerThread线程。下面来看看TimerThread干了什么事：
01
|
public void run()
{
|
02
|
03
|
try {
|
04
|
05
|
mainLoop(); //线程真正执行的代码在这个私有方法中
|
06
|
07
|
} finally {
|
08
|
09
|
//
Someone killed this Thread, behave as if Timer cancelled
|
10
|
11
|
synchronized(queue)
{
|
12
|
13
|
newTasksMayBeScheduled
= false;
|
14
|
15
|
queue.clear(); //
Eliminate obsolete references
|
16
|
17
|
}
|
18
|
19
|
}
|
20
|
21
|
}
|
接着来看看私有方法mainLoop()干了什么事：
01
|
private void mainLoop()
{
|
02
|
03
|
while (true)
{
|
04
|
05
|
try {
|
06
|
07
|
TimerTask
task;
|
08
|
09
|
booleantaskFired; //是否已经到达Task的执行时间，如果已经到达，设置为true，否则置为false
|
10
|
11
|
synchronized(queue)
{
|
12
|
13
|
//
Wait for queue to become non-empty
|
14
|
15
|
while (queue.isEmpty()
&& newTasksMayBeScheduled)
|
16
|
17
|
queue.wait(); //由此可以看出，Timer通过wait
& notify 方法安排线程之间的同步
|
18
|
19
|
if (queue.isEmpty())
|
20
|
21
|
break; //
Queue is empty and will forever remain; die
|
22
|
23
|
|
24
|
25
|
//
Queue nonempty; look at first evt and do the right thing
|
26
|
27
|
long currentTime,
executionTime;
|
28
|
29
|
task
= queue.getMin();
|
30
|
31
|
synchronized(task.lock)
{
|
32
|
33
|
if (task.state
== TimerTask.CANCELLED) {
|
34
|
35
|
queue.removeMin();
|
36
|
37
|
continue; //
No action required, poll queue again
|
38
|
39
|
}
|
40
|
41
|
currentTime
= System.currentTimeMillis();
|
42
|
43
|
executionTime
= task.nextExecutionTime;
|
44
|
45
|
if(taskFired
= (executionTime<=currentTime)) { //Task的执行时间已到，设置taskFired为true
|
46
|
47
|
if (task.period
== 0)
{ //
Non-repeating, remove
|
48
|
49
|
queue.removeMin(); //移除队列中的当前任务
|
50
|
51
|
task.state
= TimerTask.EXECUTED;
|
52
|
53
|
} else { //
Repeating task, reschedule
|
54
|
55
|
queue.rescheduleMin( //重新设置任务的下一次执行时间
|
56
|
57
|
task.period<0 ?
currentTime - task.period
|
58
|
59
|
:
executionTime + task.period);
|
60
|
61
|
}
|
62
|
63
|
}
|
64
|
65
|
}
|
66
|
67
|
if (!taskFired) //
Task hasn't yet fired; wait
|
68
|
69
|
queue.wait(executionTime
- currentTime); //还没有执行时间，通过wait等待特定时间
|
70
|
71
|
}
|
72
|
73
|
if (taskFired) //
Task fired; run it, holding no locks
|
74
|
75
|
task.run(); //已经到达执行时间，执行任务
|
76
|
77
|
} catch(InterruptedException
e) {
|
78
|
79
|
}
|
80
|
81
|
}
|
82
|
83
|
}
|
也就是说，一旦创建了Timer类的实例，就一直存在一个循环在遍历queue中的任务，如果有任务的话，就通过thread去执行该任务，否则线程通过wait()方法阻塞自己，由于没有任务在队列中，就没有必要继续thread中的循环。
上面提到，如果Timer的任务队列中不包含任务时，Timer中的TimerThread线程并不会执行，接着来看看为Timer添加任务后会出现怎样的情况。为Timer添加任务就是timer.schedule()干的事，schedule()方法直接调用Timer的私有方法 sched()，sched()是真正安排Task的地方，其源代码如下：
01
|
private void sched(TimerTask
task, long time, long period)
{
|
02
|
03
|
if (time
< 0)
|
04
|
05
|
throw new IllegalArgumentException("Illegal
execution time.");
|
06
|
07
|
|
08
|
09
|
synchronized(queue)
{
|
10
|
11
|
if (!thread.newTasksMayBeScheduled)
|
12
|
13
|
throw new IllegalStateException("Timer
already cancelled.");
|
14
|
15
|
|
16
|
17
|
synchronized(task.lock)
{
|
18
|
19
|
if(task.state
!= TimerTask.VIRGIN) //我喜欢virgin状态，其他状态表明该Task已经被schedule过了
|
20
|
21
|
throw new IllegalStateException(
|
22
|
23
|
"Task
already scheduled or cancelled");
|
24
|
25
|
|
26
|
27
|
//设置Task下一次应该执行的时间,
由System.currentTimeMillis()+/-delay得到
|
28
|
29
|
task.nextExecutionTime
= time;
|
30
|
31
|
task.period
= period;
|
32
|
33
|
task.state
= TimerTask.SCHEDULED;
|
34
|
35
|
}
|
36
|
37
|
|
38
|
39
|
queue.add(task); //queue为TaskQueue类的实例，添加任务到队列中
|
40
|
41
|
if(queue.getMin()
== task) //获取队列中nextExecutionTime最小的任务，如果与当前任务相同
|
42
|
43
|
queue.notify(); //还记得前面看到的queue.wait()方法么
|
44
|
45
|
}
|
46
|
47
|
}
|
不要奇怪，为什么要判断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的实现原理，修改这种实现方式也就非常简单了。