在Java中Timer是java.util包中的一个工具类,提供了定时器的功能。我们可以创建一个Timer对象,然后调用其schedule方法在某个特定的时间去执行一个特定的任务。并且你可以让其以特定频率一直执行某个任务,这个任务是用TimerTask来描述的,我们只需要将要进行的操作写在TimerTask类的run方法中即可。先附上两个小例子一遍让读者了解什么是定时器。接着再分析其中的一些源码实现。
第一个小例子:
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
|
package com.zkn.newlearn.thread; import java.util.Timer; import java.util.TimerTask; /** * 传统的定时器 * Created by zkn on 2016/11/1. */ public class TraditionalTimerTest01 { public static void main(String[] args){ //TimerTask是Runnable接口的一个实现类是,它是一个抽像类 //schedule是一个重载方法:第一个参数TimerTask的实现类。 // 第二个参数是第一次执行的时间。 // 第三个参数是间隔时间 new Timer().schedule( new TimerTask() { @Override public void run() { System.out.println( "这是一个定时器任务!" ); } }, 1000 , 2000 ); } } |
第二个小例子:让任务1每隔4秒执行,让任务2每隔2秒执行。依次反复。
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
|
package com.zkn.newlearn.thread; import java.util.Timer; import java.util.TimerTask; /** * Created by zkn on 2016/11/1. */ public class TraditionalTimerTest02 { public static void main(String[] args){ new Timer().schedule( new MyTimerTask01(), 4000 ); } private static class MyTimerTask01 extends TimerTask{ @Override public void run() { System.out.println( "我是TimerTask1,我被执行了!" ); new Timer().schedule( new MyTimerTask02(), 2000 ); } } private static class MyTimerTask02 extends TimerTask { @Override public void run() { System.out.println( "我是TimerTask2,我被执行了!" ); new Timer().schedule( new MyTimerTask01(), 4000 ); } } } |
大家一定会很好奇定时器是怎么执行的?接下来我们来看一下Timer中的主要代码。
1
2
3
4
5
6
|
private final TaskQueue queue = new TaskQueue(); /** * The timer thread. */ private final TimerThread thread = new TimerThread(queue); |
注意着两段代码是很重要的两段代码。TaskQueue和TimerThread都是Timer的内部类。TaskQueue是一个执行任务的优先队列。TimerThread是一个继承了Thread的线程类。他们两个在定时器中起着至关重要的作用,定时器基本上就是靠这两个类支撑的。 接下来我们来一下Timer的构造方法:
1
2
3
4
5
6
7
8
|
public Timer(String name) { thread.setName(name); thread.start(); } public Timer() { this ( "Timer-" + serialNumber()); } |
无参的这个构造函数会调用这个有参的构造函数,在这个有参的构造函数中你看到了什么?thread.start()看着是不是很眼熟啊?没错,在new Timer()的时候,就是启动了一个线程。而启动这个线程的对象就是上面的TimerThread!接下来我们来看一下TimerThread的run方法中干了些什么:
1
2
3
4
5
6
7
8
9
10
11
|
public void run() { try { mainLoop(); } finally { // Someone killed this Thread, behave as if Timer cancelled synchronized (queue) { newTasksMayBeScheduled = false ; queue.clear(); // Eliminate obsolete references } } } |
这个run方法中主要是干了两件事:一:调用mainLoop()这个死循环的方法,我们在下面会详细分析;二:finally代码块终止定时任务。终止定时任务的这个没什么说的,我们主要来看一下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
|
private void mainLoop() { while ( true ) { // 开始死循环 try { TimerTask task; boolean taskFired; synchronized (queue) { // 如果任务队列中为空并且定时任务没有被取消话,线程被挂起 等待执行任务的到来 while (queue.isEmpty() && newTasksMayBeScheduled) queue.wait(); if (queue.isEmpty()) break ; // 如果任务队列中没有任务了,则结束循环结束任务 // 如果队列中有执行任务的话,接着往下走 long currentTime, executionTime; task = queue.getMin(); synchronized (task.lock) { if (task.state == TimerTask.CANCELLED) { queue.removeMin(); continue ; // 如果执行任务被取消的话 则移除当前任务。这里会重新排队列里的任务执行顺序 } currentTime = System.currentTimeMillis(); executionTime = task.nextExecutionTime; if (taskFired = (executionTime<=currentTime)) { if (task.period == 0 ) { // 如果只执行一次的话,则在执行完之后,结束执行任务 queue.removeMin(); task.state = TimerTask.EXECUTED; } else { // 如果是固定频率执行任务的话,则计算下次执行的时间 queue.rescheduleMin( task.period< 0 ? currentTime - task.period : executionTime + task.period); } } } if (!taskFired) // 不到任务执行的时候 等待线程调用 queue.wait(executionTime - currentTime); } if (taskFired) // 任务执行时间到,调用任务的run方法,执行任务 task.run(); } catch (InterruptedException e) { } } } |
这个类比较长,具体的执行操作我在注释里都标注了。这个类基本上干了这样几件事:循环调用任务队列中的任务,执行队列中的任务。执行任务是什么时候放到执行队列中的呢?在schedule方法。我们来看看schedule的实现:
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
|
public void schedule(TimerTask task, long delay, long period) { if (delay < 0 ) // 如果第一次执行的时间小于0 抛出异常 throw new IllegalArgumentException( "Negative delay." ); if (period <= 0 ) //间隔时间小于等于 0 抛出异常 throw new IllegalArgumentException( "Non-positive period." ); sched(task, System.currentTimeMillis()+delay, -period); } private void sched(TimerTask task, long time, long period) { if (time < 0 ) throw new IllegalArgumentException( "Illegal execution time." ); // Constrain value of period sufficiently to prevent numeric // overflow while still being effectively infinitely large.这个间隔时间到死基本上也执行不到 if (Math.abs(period) > (Long.MAX_VALUE >> 1 )) period >>= 1 ; synchronized (queue) { if (!thread.newTasksMayBeScheduled) //在任务的执行方法中 如果定时任务已经被取消的话 则抛出异常 throw new IllegalStateException( "Timer already cancelled." ); synchronized (task.lock) { //object对象锁 if (task.state != TimerTask.VIRGIN) // 刚开是执行任务的时候 任务的状态应该是0的 throw new IllegalStateException( "Task already scheduled or cancelled" ); task.nextExecutionTime = time; //下次执行时间 在上面的mainLoop方法中有用到 task.period = period; //设置任务的间隔时间,在上面的mainLoop方法中有用到 task.state = TimerTask.SCHEDULED; // 调度方法被调用 设置定时任务的状态为 已调度未执行 } queue.add(task); //把执行任务加入到任务队列中 if (queue.getMin() == task) queue.notify(); // 如果任务队列中的第一个任务为当前任务的话,则把当前任务放入到等锁池中 等待执行 } } |
shedule这个方法做的事情比较简单。最主要的作用是把TimerTask放到任务队列中。
下面我们大致看一下TaskQueue的代码:
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
84
85
86
87
88
89
90
91
92
93
94
95
|
class TaskQueue { //定义一个TimerTask的堆数组 <span style="white-space:pre"> </span> private TimerTask[] queue = new TimerTask[ 128 ]; //任务队列中的任务数<span style="white-space:pre"> </span> private int size = 0 ; int size() { return size; } //添加任务到优先队列中 如果数组的长度不够的话会扩展数组 void add(TimerTask task) { // Grow backing store if necessary if (size + 1 == queue.length) queue = Arrays.copyOf(queue, 2 *queue.length); queue[++size] = task; fixUp(size); } //获取优先执行的任务 TimerTask getMin() { return queue[ 1 ]; } TimerTask get( int i) { return queue[i]; } //移除掉排在第一位的不能执行的任务 void removeMin() { queue[ 1 ] = queue[size]; queue[size--] = null ; // Drop extra reference to prevent memory leak 把对象置空 等待gc回收 fixDown( 1 ); } //删除任务队列队列中的任务 这里用来一个断言 来判断 i 不能大于 size void quickRemove( int i) { assert i <= size; queue[i] = queue[size]; queue[size--] = null ; // Drop extra ref to prevent memory leak } //重新设置优先执行任务的执行时间 并对任务队列进行重新排序 以确保最优先的任务 优先被执行 void rescheduleMin( long newTime) { queue[ 1 ].nextExecutionTime = newTime; fixDown( 1 ); } boolean isEmpty() { return size== 0 ; } //清空任务队列 定时任务结束 void clear() { // Null out task references to prevent memory leak for ( int i= 1 ; i<=size; i++) queue[i] = null ; size = 0 ; } //两个堆排序 选出最优先的执行任务 private void fixUp( int k) { while (k > 1 ) { int j = k >> 1 ; if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime) break ; TimerTask tmp = queue[j]; queue[j] = queue[k]; queue[k] = tmp; k = j; } } private void fixDown( int k) { int j; while ((j = k << 1 ) <= size && j > 0 ) { if (j < size && queue[j].nextExecutionTime > queue[j+ 1 ].nextExecutionTime) j++; // j indexes smallest kid if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime) break ; TimerTask tmp = queue[j]; queue[j] = queue[k]; queue[k] = tmp; k = j; } } void heapify() { for ( int i = size/ 2 ; i >= 1 ; i--) fixDown(i); } } |
OK,到这里定时任务的源码大致分析完毕。
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。
原文链接:http://www.jianshu.com/p/85b45df6d967#