通过源码分析，我们可以更深入的了解其底层原理。
对于JDK自带的定时器，主要涉及TimerTask类、Timer类、TimerQueue类、TimerThread类，其中TimerQueue和TimerThread类与Timer类位于同一个类文件，由Timer内部调用。
先画上一张图，描述一下Timer的大致模型，Timer的模型很容易理解，即任务加入到任务队列中，由任务处理线程循环从任务队列取出任务执行：
一、TimerTask
TimerTask是一个任务抽象类，实现了Runnable接口，是可被线程执行的。
1. 任务状态
在TimerTask中定义了关于任务状态的常量字段：
1 2 3 4 5 6 7 8 | // 未调度状态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中，有如下成员变量：
1 2 3 4 5 6 7 8 9 10 11 | // 用于加锁控制多线程修改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方法的实现代码：
1 2 3 4 5 6 7 | 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方法实现：
1 2 3 | public long scheduledExecutionTime() { synchronized(lock) { return (period |
该方法返回此任务的下次执行时间点。
二、Timer
分析Timer源代码，Timer在内部持有了两个成员变量：
1 2 3 | private final TaskQueue queue = new TaskQueue();private final TimerThread thread = new TimerThread(queue); |
TaskQueue是任务队列，TimerThread是任务处理线程。
1. sched方法
无论是使用schedule还是scheduleAtFixedRate方法来调度任务，Timer内部最后都是调用sched方法进行处理。
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 | 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方法核心代码：
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 | 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内部的线程也会对任务队列进行操作，因此加锁。
1 2 3 4 5 6 7 8 9 10 | public void cancel() { synchronized(queue) { // 修改线程的循环执行标志，令线程能够终止 thread.newTasksMayBeScheduled = false; // 清空任务队列 queue.clear(); // 唤醒线程 queue.notify(); }} |
3. purge方法
当通过TimerTask.cancel将任务取消后，Timer的任务队列还引用着此任务，Timer只有到了要执行时才会移除，其他时候并不会自动将此任务移除，需要调用purge方法进行清理。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | 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按时间从近到远进行排序。
1 2 3 4 5 6 7 8 9 10 11 | void add(TimerTask task) { // 检测数组长度，若不够则进行扩容 if (size + 1 == queue.length) queue = Arrays.copyOf(queue, 2*queue.length); // 任务入队 queue[++size] = task; // 排序 fixUp(size);} |
fixUp方法实现：
1 2 3 4 | private void fixUp(int k) { while (k > 1) { int j = k >> 1; if (queue[j].nextExecutionTime |
TaskQueue中除了fixUp方法外还有一个fixDown方法，这两个其实就是堆排序算法，在算法专题中再进行详细介绍，只要记住他们的任务就是按时间从近到远进行排序，最近的任务排在队首即可。
1 2 3 4 5 6 7 8 | private void fixDown(int k) { int j; while ((j = k 0) { if (j queue[j+1].nextExecutionTime) j++; // j indexes smallest kid if (queue[k].nextExecutionTime = 1; i--) fixDown(i);} |
四、TimerThread
TimerThread的核心代码位于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) { // 如果队列中没有任务，则进入等待，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 = (executionTime0是固定速率 queue.rescheduleMin( task.period |
以上就是Java定时器Timer的源码分析的详细内容，更多关于Java Timer的资料请关注IT俱乐部其它相关文章！
