Timer的故事----Jdk源码解读
咱们今天也来说说定时器Timer
Timer是什么？
Timern.[电子]定时器；计时器；计时员
从翻译来看，我们可以知道Timer的本意是，定时定点。
而JDK中Timer类也的确是这个本意。那么接下来，我们通过JDK中的源码来学习下Timer这个类。
1privatefinalTaskQueuequeue=newTaskQueue();
2privatefinalTimerThreadthread=newTimerThread(queue);
Timer中有这样两个变量。这两个变量是Timer类中，最重要的三个变量中的两个。一个是Queue，它的作用是作为一个队列，来存放添加到Timer类中的任务，但是他不是一个简单的队列，后续我会通过代码来讲(防盗连接：本文首发自http://www.cnblogs.com/jilodream/)述他的原理，这里先提前说明下，这个Queue设计的非常巧妙。另外一个是TimerThread，他的作用是Timer的主线程，无论是循环，还是执行都与这个线程密不可分，后续我们也会说到他。
Timer三巨头
接下来是一个final引用ThreadReaper。
复制代码
1privatefinalObjectthreadReaper=newObject(){
2protectedvoidfinalize()throwsThrowable{
3synchronized(queue){
4thread.newTasksMayBeScheduled=false;
5queue.notify();//Incasequeueisempty.
6}
7}
8};
复制代码
Reaper翻译为n.收割者；收割机；收获者；死神,死
这里这个对象可以理解为线程收割者。这个引用在Timer中，没有再次使用，只是纯定义，目的就是在Timer回收之前，优先执行这个引用复写的finalize方法。方法的内容是置变量“是否能添加新任务”设定为false,同时唤醒timerthread线程，他们的作用，我后续会说。说真的，这种写法我觉得并不好，而且诸如effectivejava,等书也并不推荐这种写法。
1privatefinalstaticAtomicIntegernextSerialNumber=newAtomicInteger(0);
2privatestaticintserialNumber(){
3returnnextSerialNumber.getAndIncrement();
4}
接下来serialNumber()的方法是，生成一个依次增长的变量。比如第一次调用时，返回0，接着返回1,2,3....。这种方法我觉得要比弄一个i++来用，更安全也更优雅，有兴趣的同学查下API，看看他的使用方法。
接下来是4个构造函数：
复制代码
1publicTimer(){
2this("Timer-"+serialNumber());
3}
4publicTimer(booleanisDaemon){
5this("Timer-"+serialNumber(),isDaemon);
6}
7publicTimer(Stringname){
8thread.setName(name);
9thread.start();
10}
11
12publicTimer(Stringname,booleanisDaemon){
13thread.setName(name);
14thread.setDaemon(isDaemon);
15thread.start();
16}
复制代码
这4个构造函数没什么主要讲的，也就是如果被主动设定线程名字后，主线程timerThread是直接启动的，另外就是是否要设置isDeamon属性，他的作用是用来设置是否为守护线程的。对于服务器这种大型程序来说，作用不大，一般是脚本程序的话，有必要设定这个值。
接下来是6个很重要的公有方法：
(1)delay毫秒后，执行task任务
1publicvoidschedule(TimerTasktask,longdelay){
2if(delay<0)
3thrownewIllegalArgumentException("Negativedelay.");
4sched(task,System.currentTimeMillis()+delay,0);
5}
(2)在time时间点，执行task任务
1publicvoidschedule(TimerTasktask,Datetime){
2sched(task,time.getTime(),0);
3}
(3)delay毫秒时间点执行，并且以周期是period毫秒来执行
复制代码
1publicvoidschedule(TimerTasktask,longdelay,longperiod){
2if(delay<0)
3thrownewIllegalArgumentException("Negativedelay.");
4if(period<=0)
5thrownewIllegalArgumentException("Non-positiveperiod.");
6sched(task,System.currentTimeMillis()+delay,-period);
7}
复制代码
(4)firstTime时间点第一次执行该任务，并且每次以period为周期执行
1publicvoidschedule(TimerTasktask,DatefirstTime,longperiod){
2if(period<=0)
3thrownewIllegalArgumentException("Non-positiveperiod.");
4sched(task,firstTime.getTime(),-period);
5}
(5)delay毫秒后执行任务，然后周期是period
复制代码
1publicvoidscheduleAtFixedRate(TimerTasktask,longdelay,longperiod){
2if(delay<0)
3thrownewIllegalArgumentException("Negativedelay.");
4if(period<=0)
5thrownewIllegalArgumentException("Non-positiveperiod.");
6sched(task,System.currentTimeMillis()+delay,period);
7}
复制代码
(6)firstTime时间点第一次执行该任务，并且每次以period为周期
1publicvoidscheduleAtFixedRate(TimerTasktask,DatefirstTime,
2longperiod){
3if(period<=0)
4thrownewIllegalArgumentException("Non-positiveperiod.");
5sched(task,firstTime.getTime(),period);
6}
前两个方法是不反复执行的，没什么讲的，中间两个方法是反复执行，但是名字没有加atFixedRate（以固定频率）的，最后两个加了atFixedRate。3、4和5、的区别是在处理period时，前者传入了相反数（也就是负数）后者传入了正数。（看源代码的时候，我才突然在记忆的深刻想起，java中相反数直接加负号就可以了。然后想起了这种很萌的形式o-=-o;）
复制代码
1privatevoidsched(TimerTasktask,longtime,longperiod){
2if(time<0)
3thrownewIllegalArgumentException("Illegalexecutiontime.");
4
5//Constrainvalueofperiodsufficientlytopreventnumeric
6//overflowwhilestillbeingeffectivelyinfinitelylarge.
7if(Math.abs(period)>(Long.MAX_VALUE>>1))
8period>>=1;
9
10synchronized(queue){
11if(!thread.newTasksMayBeScheduled)
12thrownewIllegalStateException("Timeralreadycancelled.");
13
14synchronized(task.lock){
15if(task.state!=TimerTask.VIRGIN)
16thrownewIllegalStateException(
17"Taskalreadyscheduledorcancelled");
18task.nextExecutionTime=time;
19task.period=period;
20task.state=TimerTask.SCHEDULED;
21}
22
23queue.add(task);
24if(queue.getMin()==task)
25queue.notify();
26}
27}
复制代码
这个方法的主要作用是将任务添加到任务队列中。并且设置
在方法开始的地方，判断周期是否小于long的最大值，如(防盗连接：本文首发自http://www.cnblogs.com/jilodream/)果超过的话，那么就对周期除以2，防止后续使用周期的地方，出现运算溢出。
紧接着锁定任务队列，并且开始判断当前主线程是否还计划执行新任务。注意这个变量是在被回收，以及下文任务被取消掉的时候被改变的。接着锁定这个新任务，将下次执行的时间和周期以及状态赋值到这个上。状态标识为“计划中-TimerTask.SCHEDULED”，接下来将任务添加到任务队列中。同时获取任务队列中的最近时间点的任务，如果发现这个任务就是新添加的任务的话，那么就唤醒当前队列上等待wait的线程。
这里需要先说明一下，队列的添加，和获取最近时间点的方法，非常巧妙，会在后续的方法中详细讲述。
接着是取消方法：
复制代码
1publicvoidcancel(){
2synchronized(queue){
3thread.newTasksMayBeScheduled=false;
4queue.clear();
5queue.notify();//Incasequeuewasalreadyempty.
6}
7}
复制代码
这个方法的作用的是，取消当前的定时器，他的核心内容是前文中回收timer调用的析构的内容是一样的。这几个变量的使用在上一个方法：sched()已经被使用到。也就是设定主线程不允许增加新任务。同时清除队列的所有任务。接着唤醒队列上所有等待的线程。
复制代码
1publicintpurge(){
2intresult=0;
3
4synchronized(queue){
5for(inti=queue.size();i>0;i--){
6if(queue.get(i).state==TimerTask.CANCELLED){
7queue.quickRemove(i);
8result++;
9}
10}
11
12if(result!=0)
13queue.heapify();
14}
15
16returnresult;
17}
复制代码
purgevt.净化；清洗；通便
方法名字的意思是清理，清除。
方法的处理逻辑是：锁定任务队列，判断队列中的子任务状态，如果发现任务状态被取消了，那么就在队列中快速移除掉该任务，同时记录移除子任务的个数。如果发现有子任务被移除，最后会把队列再重新堆化。同时返回删除的子任务个数。这个方法(防盗连接：本文首发自http://www.cnblogs.com/jilodream/)是Timer中的最后一个方法。回顾前文中的所有方法，我们发现Timer中并没有定义删除子任务的方法。而唯一可以删除的形式，就是设定子任务状态，然后调用purge()方法进行一次洗牌。这种做法和JVMGC中标记回收有点异曲同工之处。倘若将回收的方法，公开出来，则Timer内部需要提供很健壮的任务管理机制，防止在高并发的情况下，队列维持的堆不会出现数据错误，或性能问题（想一下如果有大量的移除操作，那么每个移除操作都需要同步队列，然后重新堆化）。
讲完了Timer类之后，我们来讲讲TimerThread。
这个类是定时器的主执行线程，所有的的子任务执行都是由这个线程来操刀的，形象一点就是，他才是幕后的“大boss”
这个类继承自Thread
在类的内部定义了两个全局变量
1booleannewTasksMayBeScheduled=true;
2privateTaskQueuequeue;
定义的作用，不再赘述，后续方法也会用到。
接下来是TimerThread的构造方法：
1TimerThread(TaskQueuequeue){
2this.queue=queue;
3}
由于TimerThread继承自Thread，因此TimerThread中也肯定有实现run方法：
复制代码
1publicvoidrun(){
2try{
3mainLoop();
4}finally{
5//SomeonekilledthisThread,behaveasifTimercancelled
6synchronized(queue){
7newTasksMayBeScheduled=false;
8queue.clear();//Eliminateobsoletereferences
9}
10}
11}
复制代码
在run方法中，会调用另外一个mainLoop()的主循环方法。
并且在调用后(更准确的说应该是捕捉到异常后)，会置允许新增子任务变量为false.同时清空子任务队列。注意run()方法被调用的时机，是在Timer被创建时就启动的。
接下来是主循环方法，这个方法是Timer方法中非常核心的一个方法。同时由于方法比较长，我直接在方法中添加注释，来解释方法。
复制代码
1/
2Themaintimerloop.(Seeclasscomment.)
3/
4privatevoidmainLoop(){
5while(true){//不断循环获取下一个任务
6try{
7TimerTasktask;
8booleantaskFired;
9synchronized(queue){//锁定队列
10//Waitforqueuetobecomenon-empty
11while(queue.isEmpty()&&newTasksMayBeScheduled)//如果队列为空，并且还允许添加子任务的话
12queue.wait();//当前线程（timerThread）进入等待，等待队列中添加对象，或timer被取消时，唤醒
13if(queue.isEmpty())//唤醒之后，如果队列为空，那么就退出主循环了，一般这时候timer都是被取消了
14break;//Queueisemptyandwillforeverremain;die
15
16//Queuenonempty;lookatfirstevtanddotherightthing
17longcurrentTime,executionTime;//可以运行到这里，说明队列中包含子任务，需要开始考虑执行了
18task=queue.getMin();//获取队列中，执行时间最靠前的子任务
19synchronized(task.lock){
20if(task.state==TimerTask.CANCELLED){
21queue.removeMin();//如果发现最靠前的子任务已经被取消了，那么从队列中移除掉他，并且进入到下次循环中。
22continue;//Noactionrequired,pollqueueagain
23}
24currentTime=System.currentTimeMillis();//获取当前执行时间
25executionTime=task.nextExecutionTime;//获取子任务的下一次执行时间（其实就是本次要执行的时间点，因为还没有执行）
26if(taskFired=(executionTime<=currentTime)){//如果子任务的下次执行时间点，小于当前时间
27if(task.period==0){//Non-repeating,remove
28//如果当前任务没有循环周期的话
29queue.removeMin();//队列中移除最前子任务（其实就是当前任务）
30task.state=TimerTask.EXECUTED;//将任务状态设定为已执行
31}else{//Repeatingtask,reschedule
32//如果当前任务，是需要循环执行的
33queue.rescheduleMin(//队列重新设定最前任务，并且当前子任务的执行时间发生变化，变化规则如下：如果周期是负值（添加子任务采用的无fixed后缀的方法），那么下次执行时间是当前时间点+周期时间。换句话说就是等待时间为（所有）任务执行时间+等待周期。而如果周期为正值（添加子任务采用的有fixed后缀的方法），代表的是固定频率。则下次执行时间是，上次预计的执行时间+周期时间（注意这个时间点可能还是小于当前时间，仍然会被快速执行到）
34task.period<0?currentTime-task.period
35:executionTime+task.period);
36}
37}
38}
39//跳出子任务同步代码块
40if(!taskFired)//Taskhasn''tyetfired;wait
41//如果最前子任务还没到被执行的时间点，那么主线程就等待中间的时间差。注意在前边的方法中有写过，添加子任务等方法是会重新唤醒主线程的
42queue.wait(executionTime-currentTime);
43}
44if(taskFired)//Taskfired;runit,holdingnolocks
45task.run();//如果子任务的时间已经到了，那么就会执行这个子任务的run()方法。这里特别要注意两点：1直接运行run()方法的，说明是主线程全权负责执行，所以出现一个子任务挂了，整个定时器可能搁浅。2这里的标识为使用的值，还是旧值，也就是说如果出现主线程等待，那么他必须要再循环一次，才可以执行子任务。这是由于在等待期间，可能有更新的子任务添加进来，任务队列发生了变化，所以需要重新计算
46}catch(InterruptedExceptione){
47}
48}
49}
复制代码
接下来要介绍的类是TaskQueue
这个类的作用非常简单，就是维护一个很好的最小堆。什么是最小堆呢？你可以理解为就是父节点都小于子节点的这样一棵树。而根节点就是下次运行时间最小的任务。下面我们来看看代码，来看看这个Queue内部的设计。
1privateTimerTask[]queue=newTimerTask[128];
这个是维护堆的一个数据结构，长度为128的一个数组。（话说，为什么定义这么大的，比hashMap之类的大多了）
复制代码
1/
2Thenumberoftasksinthepriorityqueue.(Thetasksarestoredin
3queue[1]uptoqueue[size]).
4/
5privateintsize=0;
6
7/
8Returnsthenumberoftaskscurrentlyonthequeue.
9/
10intsize(){
11returnsize;
12}
复制代码
接下来是长度size，因为queue变量只是一个堆，具体有多少个可用元素，还是需要其他变量来表示的。
接下来是add方法，我们在Timer类中的sched()方法曾经见过这个方法被调用。
方法的内部逻辑是：
1>如果queue已经被塞满了(之所以加1，是因为数组(防盗连接：本文首发自http://www.cnblogs.com/jilodream/)的第一个元素是从未被使用的，这样是为了方便使用索引计算出堆中的位置)，那么queue进行一次扩容。
2>然后把新任务放到堆的最后一个元素的位置。（注意size的作用是堆中元素的个数，而不是堆的容积）
3>然后进行一次堆的上推，也就是把新增任务的位置，按照堆的设计，依次上推到属于他的位置。
复制代码
1voidadd(TimerTasktask){
2//Growbackingstoreifnecessary
3if(size+1==queue.length)
4queue=Arrays.copyOf(queue,2queue.length);
5
6queue[++size]=task;
7fixUp(size);
8}
复制代码
接下来是返回最小堆的根元素，timerTask会调用这个方法，准备执行优先级最高的任务。
1TimerTaskgetMin(){
2returnqueue[1];
3}
取出任意的堆中元素，清理定时器废弃任务的时候(purge()),会调用这个方法。
1TimerTaskget(inti){
2returnqueue[i];
3}
移除最小元素，这个方法会在以下两种情况被调用：
1、在执行周期为0(也就是不会再次执行)的子任务时，在取出该子任务后会调用该方法;
2、在主循环取出最近子任务时，发现该任务当前的装备已经被置为取消了，也会调用该方法，然后再次进行循环取出下一个子任务。
1voidremoveMin(){
2queue[1]=queue[size];
3queue[size--]=null;//Dropextrareferencetopreventmemoryleak
4fixDown(1);
5}
方法实现主要逻辑是，移除掉min任务，然后把下边的子任务依次往最小堆的根部推。但是采用的方法却非常巧妙：将最后一个元素赋值到根元素的位置上，然后将最后一个元素的位置设置为null，接着将根元素依次向下推送到合适的位置，以保证最小堆的结构仍然正常。
接下来是快速移除方法，将i位置的元素，设置为堆元素的最后一个值，然后将最后的位置设置为null。需要注意的地方如下：
1>这里有涉及到assert关键字，不明白的话，看我的另外一篇博客，点击这里。(防盗连接：本文首发自http://www.cnblogs.com/jilodream/)
2>同时不知道大家发现没有，在方法的内部没有进行同步保护。可能存在线程不安全的地方，调用这个方法的另外一个方法，是在前文中的purge()方法。在调用之前，已经锁住queue变量，所以线程不安全的担心是多余的。
3>快速移除后，最小堆的结构已经发生变化，在purge()调用后，又重新对queue继续堆化。以保证queue的使用不会再出现问题。最后才解除queue锁定。所以无论怎样，该方法都不会对定时器的使用造成空引用或触发错误。当然前提是包中的其他jdk源码不出现错误的使用。
同时我们也应该反思自己日常工作中的代码，很多时候，可以从整理逻辑上保持代码的安全和简洁，而不是将控制的粒度放到非常小，导致代码的性能和逻辑的可读性非常差。
1voidquickRemove(inti){
2asserti<=size;
3
4queue[i]=queue[size];
5queue[size--]=null;//Dropextrareftopreventmemoryleak
6}
这个方法的功能是重行规划queue中根元素的位置，用于执行需要重复运行的子任务时。
1voidrescheduleMin(longnewTime){
2queue[1].nextExecwww.tt951.comutionTime=newTime;
3fixDown(1);
4}
判断queue中，是否还包含有子任务，size的含义前文中提到过。
1booleanisEmpty(){
2returnsize==0;
3}
清除当前的queue，并且置size为0;
这个方法在两个地方会被调用
1>主循环时捕捉到了异常，注意这个特性，也就是说子任务的run方法中，要自己做好异常的保护，否则一旦出现异常，那么Timer即可会退出。所以这时候是不需要线程保护的。
2>当任务被取消的时候，cancel()会调用该方法。cancel()想要clear掉整个堆,需要首先(防盗连接：本文首发自http://www.cnblogs.com/jilodream/)抢到锁。而cancel后,重新唤起queue上等待的线程，但是注意主循环上的等待线程，此时都不会直接获取堆中的元素。所以不会出现空引用异常：
有两处wait()，第一处无限等待，被唤醒后会判断queue是否为空，然后才继续执行。第二处等待若干秒后，时间没有到即被唤醒的话，当次循环并不会执行queue，需要至少在等待一个循环。这个在主循环的最后部分有讲到。
复制代码
1voidclear(){
2//Nullouttaskreferencestopreventmemoryleak
3for(inti=1;i<=size;i++)
4queue[i]=null;
5
6size=0;
7}
复制代码
下边是维持堆化时，非常重要的两个方法：
fixup是将元素从底部往根的位置向上推送
复制代码
1privatevoidfixUp(intk){
2while(k>1){
3intj=k>>1;
4if(queue[j].nextExecutionTime<=queue[k].nextExecutionTime)
5break;
6TimerTasktmp=queue[j];queue[j]=queue[k];queue[k]=tmp;
7k=j;
8}
9}
复制代码
fixdown是将根位置的元素，向底部推送
复制代码
1privatevoidfixDown(intk){
2intj;
3while((j=k<<1)<=size&&j>0){
4if(j
5queue[j].nextExecutionTime>queue[j+1].nextExecutionTime)
6j++;//jindexessmallestkid
7if(queue[k].nextExecutionTime<=queue[j].nextExecutionTime)
8break;
9TimerTasktmp=queue[j];queue[j]=queue[k];queue[k]=tmp;
10k=j;
11}
12}
复制代码
这两个方法没什么好讲的，只是需要强调一下，在需要大量整形的乘2或者除以2的运算，都可以通过<<1、>>1的形式来表达。
堆化的方法，i从size的一半的位置，向前取出每个元素，然后依次向下推送元素。因为1/2位置的元素是最小堆叶子节点的父节点（即倒数第二层），依次向前遍历时，每一层的元素都会进行一个fixdown的操作，所以整体来说，耗费的时间非常短暂。
1voidheapify(){
2for(inti=size/2;i>=1;i--)
3fixDown(i);
4}
最后一个类是TimerTask
这个类是一个继承自接口Runnable的抽象类，需要实现类自己去补充run方法。
接下来直接看代码
首先是内部保证同步逻辑的一个锁变量。
1finalObjectlock=newObject();
接着是状态变量，初始状态为virgin。只有这个状态的任务才可以添加到queue中，sched(),子任务添加后，会改变子任务的状态，所以子任务不会被反复多次添加到queue中。
1intstate=VIRGIN;
接下来是4个状态变量
1staticfinalintVIRGIN=0;//初始化
2staticfinalintSCHEDULED=1;//任务被添加到queue中即会设置该状态
3staticfinalintEXECUTED=2;//被执行过，只有不反复循环的子任务会被设置该状态
4staticfinalintCANCELLED=3;//被取消
下次被执行的时间(维持最小堆的判断标准)
1longnextExecutionTime;
周期，初始是0毫秒，即不被反复执行。
1longperiod=0;
构造方法(抽象类的)
1protectedTimerTask(){
2}
抽象run方法
1publicabstractvoidrun();
取消任务时调用的方法，这个方法jdk源码没有调用，是供外部调用的
复制代码
1publicbooleancancel(){
2synchronized(lock){
3booleanresult=(state==SCHEDULED);
4state=CANCELLED;
5returnresult;
6}
7}
复制代码
下一次计划执行时间：当前计划执行时间加周期时间。注意这个方法的返回值，可能是一个过去时间。
这个方法jdk源码也没有调用，是供外部调用的。
1publiclongscheduledExecutionTime(){
2synchronized(lock){
3return(period<0?nextExecutionTime+period
4:nextExecutionTime-period);
5}
6}
最后的最后，来谈谈Timer类的定位：
（1）前Timer时代。
Timer是jdk1.3的时候，添加进源码的。这个时候大概是2000年左右。具体java被推出，才仅仅过去5年，所以1.3的主要改进，表现在新增的大量类库上。而在此之前，想拥有一个如Timer般的定时功能，是非常麻烦的，基本都要手动去实现。
（2）后Timer时代
查看了Timer的源代码之后，我们发现Timer在使用中存在这么问题：
1、定时任务是顺序执行的，也就是说后续的任务，一定要等到前边的任务执行完毕后，才会执行，否则将会一直等待。（其实这一点说不上来好还是坏，因为有时候我们可能会希望尽管是定时任务，但是执行时是有顺序完成和开始的，是要保证先后顺序的)
2、对系统时间非常敏感，通过代码我们知道，在每次子任务被取出后（执行run前），都会计算一遍执行时间，同时在判定子任务的执行时间是否已经到来时，都是直接获取到系统时间。倘若系统时间发生了修改，而使用的计划时间仍然是使用上次修改前的时间段时，就会出现一些意想不到的结果。如计划是5秒后执行，主线程wait5秒钟后，被唤醒，在这5秒钟内，系统时间向后推迟了1天，那么主任务，仍然会执行该子任务（其他的也都会依次迅速执行，因为时间已经过了）。而倘若向前调整一天，那么主线程判断的时间仍然是，调整时间前的时间点，所以需要再等待一天。因此会出(防盗连接：本文首发自http://www.cnblogs.com/jilodream/)现很多人以为Timer在调整时间后，被挂起，但是查看线程状态，发现还存在的奇怪场景。
3、子任务之间存在依赖。其实子任务之间的依赖关系并不强，无非就是前边的子任务执行完后，后边的子任务才可以开始执行。但是倘若在执行某个子任务时，捕捉到了异常，那么线程会立刻结束执行，后续的子任务都不会执行了，这个问题有时会对我们造成很大的困扰。
为了解决以上种种在jdk1.5中提供了ScheduledExecutorService接口以供开发者使用。
这个接口的实现，主要是通过线程池的形式，解决了上述遇到的问题（线程池也是jdk1.5时才推出的），很多人因此认为Timer已经过时了，我觉得完全没有必要这样认为，通过自己对比Timer的原理和ScheduledExecutorService的改进之后。我们发现很多地方Timer仍然是有自己存在的必要的，只是占用场景不如ScheduledExecutorService多罢了。关于ScheduledExecutorService的学习，此处不再罗列，有兴趣的同学可以自己学习。
|
|
