java实现多线程之定时器任务
在Java中Timer是java.util包中的一个工具类，提供了定时器的功能。我们可以创建一个Timer对象，然后调用其schedule方法在某个特定的时间去执行一个特定的任务。并且你可以让其以特定频率一直执行某个任务，这个任务是用TimerTask来描述的，我们只需要将要进行的操作写在TimerTask类的run方法中即可。先附上两个小例子一遍让读者了解什么是定时器。接着再分析其中的一些源码实现。
第一个小例子：
packagecom.zkn.newlearn.thread;
importjava.util.Timer;
importjava.util.TimerTask;
/**
*传统的定时器
*Createdbyzknon2016/11/1.
*/
publicclassTraditionalTimerTest01{
publicstaticvoidmain(String[]args){
//TimerTask是Runnable接口的一个实现类是，它是一个抽像类
//schedule是一个重载方法：第一个参数TimerTask的实现类。
//第二个参数是第一次执行的时间。
//第三个参数是间隔时间
newTimer().schedule(newTimerTask(){
@Override
publicvoidrun(){
System.out.println("这是一个定时器任务!");
}
},1000,2000);
}
}
第二个小例子：让任务1每隔4秒执行，让任务2每隔2秒执行。依次反复。
packagecom.zkn.newlearn.thread;
importjava.util.Timer;
importjava.util.TimerTask;
/**
*Createdbyzknon2016/11/1.
*/
publicclassTraditionalTimerTest02{
publicstaticvoidmain(String[]args){
newTimer().schedule(newMyTimerTask01(),4000);
}
privatestaticclassMyTimerTask01extendsTimerTask{
@Override
publicvoidrun(){
System.out.println("我是TimerTask1，我被执行了!");
newTimer().schedule(newMyTimerTask02(),2000);
}
}
privatestaticclassMyTimerTask02extendsTimerTask{
@Override
publicvoidrun(){
System.out.println("我是TimerTask2，我被执行了!");
newTimer().schedule(newMyTimerTask01(),4000);
}
}
}
大家一定会很好奇定时器是怎么执行的？接下来我们来看一下Timer中的主要代码。
privatefinalTaskQueuequeue=newTaskQueue(); /** *Thetimerthread. */ privatefinalTimerThreadthread=newTimerThread(queue);
注意着两段代码是很重要的两段代码。TaskQueue和TimerThread都是Timer的内部类。TaskQueue是一个执行任务的优先队列。TimerThread是一个继承了Thread的线程类。他们两个在定时器中起着至关重要的作用，定时器基本上就是靠这两个类支撑的。接下来我们来一下Timer的构造方法：
publicTimer(Stringname){
thread.setName(name);
thread.start();
}
publicTimer(){
this("Timer-"+serialNumber());
}
无参的这个构造函数会调用这个有参的构造函数，在这个有参的构造函数中你看到了什么？thread.start()看着是不是很眼熟啊？没错，在newTimer()的时候，就是启动了一个线程。而启动这个线程的对象就是上面的TimerThread！接下来我们来看一下TimerThread的run方法中干了些什么：
publicvoidrun(){
try{
mainLoop();
}finally{
//SomeonekilledthisThread,behaveasifTimercancelled
synchronized(queue){
newTasksMayBeScheduled=false;
queue.clear();//Eliminateobsoletereferences
}
}
}
这个run方法中主要是干了两件事：一：调用mainLoop()这个死循环的方法，我们在下面会详细分析；二：finally代码块终止定时任务。终止定时任务的这个没什么说的，我们主要来看一下mainLoop()这个方法。
privatevoidmainLoop(){
while(true){//开始死循环
try{
TimerTasktask;
booleantaskFired;
synchronized(queue){
//如果任务队列中为空并且定时任务没有被取消话，线程被挂起等待执行任务的到来
while(queue.isEmpty()&&newTasksMayBeScheduled)
queue.wait();
if(queue.isEmpty())
break;//如果任务队列中没有任务了，则结束循环结束任务
//如果队列中有执行任务的话，接着往下走
longcurrentTime,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(InterruptedExceptione){
}
}
}
这个类比较长，具体的执行操作我在注释里都标注了。这个类基本上干了这样几件事：循环调用任务队列中的任务，执行队列中的任务。执行任务是什么时候放到执行队列中的呢?在schedule方法。我们来看看schedule的实现：
publicvoidschedule(TimerTasktask,longdelay,longperiod){
if(delay<0)//如果第一次执行的时间小于0抛出异常
thrownewIllegalArgumentException("Negativedelay.");
if(period<=0)//间隔时间小于等于0抛出异常
thrownewIllegalArgumentException("Non-positiveperiod.");
sched(task,System.currentTimeMillis()+delay,-period);
}
privatevoidsched(TimerTasktask,longtime,longperiod){
if(time<0)
thrownewIllegalArgumentException("Illegalexecutiontime.");
//Constrainvalueofperiodsufficientlytopreventnumeric
//overflowwhilestillbeingeffectivelyinfinitelylarge.这个间隔时间到死基本上也执行不到
if(Math.abs(period)>(Long.MAX_VALUE>>1))
period>>=1;
synchronized(queue){
if(!thread.newTasksMayBeScheduled)//在任务的执行方法中如果定时任务已经被取消的话则抛出异常
thrownewIllegalStateException("Timeralreadycancelled.");
synchronized(task.lock){//object对象锁
if(task.state!=TimerTask.VIRGIN)//刚开是执行任务的时候任务的状态应该是0的
thrownewIllegalStateException(
"Taskalreadyscheduledorcancelled");
task.nextExecutionTime=time;//下次执行时间在上面的mainLoop方法中有用到
task.period=period;//设置任务的间隔时间，在上面的mainLoop方法中有用到
task.state=TimerTask.SCHEDULED;//调度方法被调用设置定时任务的状态为已调度未执行
}
queue.add(task);//把执行任务加入到任务队列中
if(queue.getMin()==task)
queue.notify();//如果任务队列中的第一个任务为当前任务的话，则把当前任务放入到等锁池中等待执行
}
}
shedule这个方法做的事情比较简单。最主要的作用是把TimerTask放到任务队列中。
下面我们大致看一下TaskQueue的代码：
classTaskQueue{
//定义一个TimerTask的堆数组<spanstyle="white-space:pre"></span>
privateTimerTask[]queue=newTimerTask[128];
//任务队列中的任务数<spanstyle="white-space:pre"></span>
privateintsize=0;
intsize(){
returnsize;
}
//添加任务到优先队列中如果数组的长度不够的话会扩展数组
voidadd(TimerTasktask){
//Growbackingstoreifnecessary
if(size+1==queue.length)
queue=Arrays.copyOf(queue,2*queue.length);
queue[++size]=task;
fixUp(size);
}
//获取优先执行的任务
TimerTaskgetMin(){
returnqueue[1];
}
TimerTaskget(inti){
returnqueue[i];
}
//移除掉排在第一位的不能执行的任务
voidremoveMin(){
queue[1]=queue[size];
queue[size--]=null;//Dropextrareferencetopreventmemoryleak把对象置空等待gc回收
fixDown(1);
}
//删除任务队列队列中的任务这里用来一个断言来判断i不能大于size
voidquickRemove(inti){
asserti<=size;
queue[i]=queue[size];
queue[size--]=null;//Dropextrareftopreventmemoryleak
}
//重新设置优先执行任务的执行时间并对任务队列进行重新排序以确保最优先的任务优先被执行
voidrescheduleMin(longnewTime){
queue[1].nextExecutionTime=newTime;
fixDown(1);
}
booleanisEmpty(){
returnsize==0;
}
//清空任务队列定时任务结束
voidclear(){
//Nullouttaskreferencestopreventmemoryleak
for(inti=1;i<=size;i++)
queue[i]=null;
size=0;
}
//两个堆排序选出最优先的执行任务
privatevoidfixUp(intk){
while(k>1){
intj=k>>1;
if(queue[j].nextExecutionTime<=queue[k].nextExecutionTime)
break;
TimerTasktmp=queue[j];queue[j]=queue[k];queue[k]=tmp;
k=j;
}
}
privatevoidfixDown(intk){
intj;
while((j=k<<1)<=size&&j>0){
if(j<size&&
queue[j].nextExecutionTime>queue[j+1].nextExecutionTime)
j++;//jindexessmallestkid
if(queue[k].nextExecutionTime<=queue[j].nextExecutionTime)
break;
TimerTasktmp=queue[j];queue[j]=queue[k];queue[k]=tmp;
k=j;
}
}
voidheapify(){
for(inti=size/2;i>=1;i--)
fixDown(i);
}
}
OK，到这里定时任务的源码大致分析完毕。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。