通过源码剖析，咱们能够更深刻的理解其底层原理。
对于JDK自带的定时器，次要波及TimerTask类、Timer类、TimerQueue类、TimerThread类，其中TimerQueue和TimerThread类与Timer类位于同一个类文件，由Timer外部调用。
先画上一张图，形容一下Timer的大抵模型，Timer的模型很容易了解，即工作退出到工作队列中，由工作解决线程循环从工作队列取出工作执行：
一、TimerTask
TimerTask是一个工作抽象类，实现了Runnable接口，是可被线程执行的。
1. 工作状态
在TimerTask中定义了对于工作状态的常量字段：
// 未调度状态
static final int VIRGIN = 0;
// 工作已调度，但未执行
static final int SCHEDULED = 1;
// 若是一次性工作示意已执行；可反复执行工作，该状态有效
static final int EXECUTED = 2;
// 工作被勾销
static final int CANCELLED = 3;当一个TimerTask对象创立后，其初始状态为VIRGIN；
当调用Timer的schedule办法调度了此TimerTask对象后，其状态变更为SCHEDULED；
如果TimerTask是一次性工作，此工作执行后，状态将变为EXECUTED，可反复执行工作执行后状态不变；
当中途调用了TimerTask.cancel办法，该工作的状态将变为CANCELLED。
2. 工作属性阐明
TimerTask中，有如下成员变量：
// 用于加锁管制多线程批改TimerTask外部状态
final Object lock = new Object();
// 工作状态，初始状态为待未调度状态
int state = VIRGIN;
// 工作的下一次执行工夫点
long nextExecutionTime;
// 工作执行的工夫距离。负数示意固定速率；正数示意固定时延；0示意只执行一次
long period = 0;3. 工作办法阐明
TimerTask中有三个办法：
- run：实现了Runnable接口，创立TimerTask须要重写此办法，编写工作执行代码
- cancel：勾销工作
- scheduledExecutionTime：计算执行工夫点
3.1. Cancel办法
cancel办法的实现代码：
public boolean cancel() {
synchronized(lock) {
boolean result = (state == SCHEDULED);
state = CANCELLED;
return result;
}
}在cancel办法内，应用synchronized加锁，这是因为Timer外部的线程会对TimerTask状态进行批改，而调用cancel办法个别会是另外一个线程。
为了防止线程同步问题，cancel在批改状态前进行了加锁操作。
调用cancel办法将会把工作状态变更为CANCELLED状态，即工作勾销状态，并返回一个布尔值，该布尔值示意此工作之前是否已是SCHEDULED 已调度状态。
3.2. scheduledExecutionTime办法
scheduledExecutionTime办法实现：
public long scheduledExecutionTime() {
synchronized(lock) {
return (period < 0 ? nextExecutionTime + period
: nextExecutionTime - period);
}
}该办法返回此工作的下次执行工夫点。
二、Timer
剖析Timer源代码，Timer在外部持有了两个成员变量：
private final TaskQueue queue = new TaskQueue();
private final TimerThread thread = new TimerThread(queue);TaskQueue是工作队列，TimerThread是工作解决线程。
1. sched办法
无论是应用schedule还是scheduleAtFixedRate办法来调度工作，Timer外部最初都是调用sched办法进行解决。
public void schedule(TimerTask task, Date time) {
sched(task, time.getTime(), 0); // 一次性工作，period为0
}
public void schedule(TimerTask task, long delay) {
...
sched(task, System.currentTimeMillis()+delay, 0); // 一次性工作，period为0
}
public void schedule(TimerTask task, long delay, long period) {
...
sched(task, System.currentTimeMillis()+delay, -period); // 固定延时模式，-period
}
public void schedule(TimerTask task, Date firstTime, long period) {
...
sched(task, firstTime.getTime(), -period); // 固定延时模式，-period
}
public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
...
sched(task, System.currentTimeMillis()+delay, period); // 固定速率模式，period为正
}
public void scheduleAtFixedRate(TimerTask task, Date firstTime, long period) {
...
sched(task, firstTime.getTime(), period); // 固定速率模式，period为正
}
sched办法外围代码：
private void sched(TimerTask task, long time, long period) {
...
// 加锁，防止内部其余线程同时调用cancel，同时拜访queue产生线程同步问题
synchronized(queue) {
// 如果线程已终止，抛出异样
if (!thread.newTasksMayBeScheduled)
throw new IllegalStateException("Timer already cancelled.");
// 加锁，防止多线程拜访同一个工作产生线程同步问题
synchronized(task.lock) {
// task的状态必须为VIRGIN，否则认为曾经退出调度或者曾经勾销了，防止反复的调度
if (task.state != TimerTask.VIRGIN)
throw new IllegalStateException(
"Task already scheduled or cancelled");
// 设置下次执行工夫点
task.nextExecutionTime = time;
// 设置工夫距离
task.period = period;
// 工作状态变更为已调度
task.state = TimerTask.SCHEDULED;
}
// 将工作增加到队列中
queue.add(task);
// 如果此工作是最近的工作，唤醒线程
if (queue.getMin() == task)
queue.notify();
}
}2. cancel办法
cancel办法个别是由内部其余线程调用，而Timer外部的线程也会对工作队列进行操作，因而加锁。
public void cancel() {
synchronized(queue) {
// 批改线程的循环执行标记，令线程可能终止
thread.newTasksMayBeScheduled = false;
// 清空工作队列
queue.clear();
// 唤醒线程
queue.notify();
}
}3. purge办法
当通过TimerTask.cancel将工作勾销后，Timer的工作队列还援用着此工作，Timer只有到了要执行时才会移除，其余时候并不会主动将此工作移除，须要调用purge办法进行清理。
public int purge() {
int result = 0;
synchronized(queue) {
// 遍历队列，将CANCELLED状态的工作从工作队列中移除
for (int i = queue.size(); i > 0; i--) {
if (queue.get(i).state == TimerTask.CANCELLED) {
queue.quickRemove(i);
result++;
}
}
// 如果移除工作数不为0，触发从新排序
if (result != 0)
queue.heapify();
}
// 返回移除工作数
return result;
}三、TaskQueue
TaskQueue是Timer类文件中封装的一个队列数据结构，外部默认是一个长度128的TimerTask数组，当工作退出时，检测到数组将满将会主动扩容1倍，并对数组元素依据下次执行工夫nextExecutionTime按工夫从近到远进行排序。
void add(TimerTask task) {
// 检测数组长度，若不够则进行扩容
if (size + 1 == queue.length)
queue = Arrays.copyOf(queue, 2*queue.length);
// 工作入队
queue[++size] = task;
// 排序
fixUp(size);
}fixUp办法实现：
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;
}
}
TaskQueue中除了fixUp办法外还有一个fixDown办法，这两个其实就是堆排序算法，在算法专题中再进行具体介绍，只有记住他们的工作就是按工夫从近到远进行排序，最近的工作排在队首即可。
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);
}四、TimerThread
TimerThread的外围代码位于mainLoop办法：
private void mainLoop() {
// 死循环，从队列取工作执行
while (true) {
try {
TimerTask task;
boolean taskFired;
// 对工作队列加锁
synchronized(queue) {
// 如果队列中没有工作，则进入期待，newTasksMayBeScheduled是线程运行标记位，为false时将退出循环
while (queue.isEmpty() && newTasksMayBeScheduled)
queue.wait();
// 如果工作队列是空的还执行到这一步，阐明newTasksMayBeScheduled为false，退出循环
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)) {
// 如果工作period=0，即一次性工作
if (task.period == 0) {
// 从队列移除一次性工作
queue.removeMin();
// 工作状态变更为已执行
task.state = TimerTask.EXECUTED;
} else {
// 可反复执行工作，从新进行调度，period<0是固定时延，period>0是固定速率
queue.rescheduleMin(
task.period<0 ? currentTime - task.period // 计算下次执行工夫
: executionTime + task.period);
}
}
}
// taskFired为false即工作尚未到执行工夫点，进行期待，等待时间是 执行工夫点 - 以后工夫点
if (!taskFired)
queue.wait(executionTime - currentTime);
}
// taskFired为true示意已触发，执行工作
if (taskFired)
task.run();
} catch(InterruptedException e) {
}
}
}
发表回复