在java中timer是java.util包中的一个工具类，提供了定时器的功能。我们可以创建一个timer对象，然后调用其schedule方法在某个特定的时间去执行一个特定的任务。并且你可以让其以特定频率一直执行某个任务，这个任务是用timertask来描述的，我们只需要将要进行的操作写在timertask类的run方法中即可。先附上两个小例子一遍让读者了解什么是定时器。接着再分析其中的一些源码实现。
第一个小例子：
我要评论
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秒执行。依次反复。
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中的主要代码。
private final taskqueue queue = new taskqueue(); /** * the timer thread. */ private final timerthread thread = new timerthread(queue);
注意着两段代码是很重要的两段代码。taskqueue和timerthread都是timer的内部类。taskqueue是一个执行任务的优先队列。timerthread是一个继承了thread的线程类。他们两个在定时器中起着至关重要的作用，定时器基本上就是靠这两个类支撑的。 接下来我们来一下timer的构造方法：
public timer(string name) {
thread.setname(name);
thread.start();
}
public timer() {
this("timer-" + serialnumber());
}
无参的这个构造函数会调用这个有参的构造函数，在这个有参的构造函数中你看到了什么？thread.start()看着是不是很眼熟啊？没错，在new timer()的时候，就是启动了一个线程。而启动这个线程的对象就是上面的timerthread！接下来我们来看一下timerthread的run方法中干了些什么：
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()这个方法。
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的实现：
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的代码：
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，到这里定时任务的源码大致分析完毕。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持移动技术网。
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
荐 Python部分第三方库简要介绍及近期Python入门学习笔记
荐 PCA降维原理及其代码实现（附加 sklearn PCA用法参数详解）
网友评论