栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java Timer及TimerTask源码分析

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java Timer及TimerTask源码分析

首先贴出Timer类重要的两个成员属性

第一个queue属性,这个属性是一个队列,其底层是一个数组,有兴趣的同学可以按住ctrl点进去看一看,这个队列放置的内容都是timeTask类型的对象,也就是我们定义的具体任务。比如我要每分钟都唱一次歌,那么唱歌就是一个任务,那么对于我来说,就应该将唱歌这个任务放到Timer的queue里面。如果看到这里,没明白,不着急,接着往下看。
第二个thread属性,这个是Timer的一个重要成员属性,其是一个线程,我们知道启动一个线程必然要用thread.start,所以后文必然有一个启动线程的代码,先不用着急。

情景假设

假设我们手机定一个每天早上会响的闹钟,首先,这里面有这么几点因素要注意。
1.早上
2.响
3.每天
以上三点因素中的第二点,指的是要做的事情,剩下的第一点和第三点都是时间段,以及循环次数。那么,我们肯定需要准备一个手机,然后让他每天的早上干一件事情(响)。换到代码中就是这样的

//搞一个手机
Timer timer=new Timer();
timer.schedule(响,早上8点,每天);

如上面代码所示,首先搞了一个手机,也就是new了一个Timer,然后给这个手机定制了一项任务,就是每天早上8点响。这里面出现了两个API,一个是new Timer这个构造方法,还有一个就是schedule这个定制任务的方法。我们一个一个看
首先是new Timer

按住ctrl点进去,就能看到如图的样子,貌似没什么营养,那我们继续按住ctrl点this

有的小伙伴可能已经激动了,又有的小伙伴可能不是很激动,没事,我给大家描述描述。也就是说我们通过new Timer最后的最后会触发两个代码一个是给thread这个紫色的东西设置一个名字,第二个调用thread.start的方法,啥方法名能起成start呢?别忘了,这个紫色的东西,是Timer的一个成员属性,且他的类型就是一个TimerThread,有兴趣的小伙伴可以点击去看到,这个TimerThread实现了Runnable接口,也就是说,这个thread.start就是启动了一个线程!
那么启动线程,就应该关注线程的run方法(没反应过来的小伙伴们,多练练java的线程编程)。而这个TimerThread的run方法,我给大家COPY出来啦。

  public void run() {
        try {
            mainLoop();
        } finally {
            // Someone killed this Thread, behave as if Timer cancelled
            synchronized(queue) {
                newTasksMayBeScheduled = false;
                queue.clear();  // Eliminate obsolete references
            }
        }
    }

如上所示,新鲜的jdk官方注释,哈哈哈。这不重要,重要的是看这个run方法里面的代码结构,一个try-finally块,我们知道finally块一般都是做善后工作的,也就是说那个同步代码块包住的地方都是善后工作,而这个run方法主要干的事情都在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)  
                    task.run();
            } catch(InterruptedException e) {
            }
        }
    }

如上所示,这就是我们new了一个Timer对象,导致我们启动了一个线程,这个线程干了上面那么多代码的事情。这堆代码首先是一个死循环,然后声明了几个变量task、taskFired,然后加了一个同步代码块,所以这些都草率的看一看就行,重点来了看这个代码。

   while (queue.isEmpty() && newTasksMayBeScheduled)
                        queue.wait();

这个代码应该是上面的第7行和第8行,不会真的有人跟我一起数吧,哈哈哈。这行代码是一个循环,然后进入循环是让当前线程等待,那么如何才能进入这个while循环呢?第一个条件就是queue.isEmpty,也就是queue这个东西如果是空的,就会进入进来。有人可能会说,不对不对,这不是两个条件嘛,后面还有个条件呢!这个newTaskMayBeScheduled的值是true,阅读源码就可以知道,在jdk1.8的489行,有兴趣的同学可以进去看一看。所以我们重点关注前面的条件就是queue这个东西是不是空,很显然他必然是空,因为从一开始,我们只是new了一个Timer,触发了一个线程的run方法,然后巴拉巴拉走到了这里,queue我们还没搞他呢。所以此时,这个线程会阻塞在这里。我们先不着急往下看了,再回到一开始的代码里面,看看
timer.schedule(响,早上8点,每天);
这行代码干了什么事情。
按住ctrl点进去,可以发现

这个方法需要三个参数,为了方便大家记忆,我给的代码
timer.schedule(响,早上8点,每天);
是个伪代码,分别对应三个参数,干什么事、第一次啥时候干、多久干一次
首先看if(period<=0),如果多久干一次的这个时间是小于0的,也就是说每负一秒干一次,着显然是有问题的,所以jdk帮我们抛出了一个异常。所以刚开始的两行代码只是检查参数,然后这个代码又将参数传入到另一个方法中,注意最后的那个参数-period,他把我们给的多久干一次变成了负数,一定要注意这里。后文会提到这个点的。
接下来看sched这个方法

首先从387行到393行只是进行参数校验,有的同学说,老师,387和388我能看明白,392到393这是干嘛呢,这个是吧,老师也不太清楚,只是说,如果你传进来的这个period也就是多久干一次如果太大的话,就把他缩小一半,大概这个意思。但这不是重点,重点是从395到410的位置,首先396和3978进行参数校验,400到402参数校验,这些都先不管,看403到405,这些是设置task的一些属性,其中nextExecutionTime是下一次执行的时间,period是多久执行一次,state是当前任务执行的状态(执行了,没执行,取消了……)。设置完这些之后,就把这个任务添加到了queue里面,然后进行了一步判断,queue.getMin这个方法是指从queue这个队列里面拿出执行时间最少的执行,采用的算法是小根堆,这个不用深入了解,反正就是判断一下当前堆里面这个执行时间最小的任务是不是我当前往队列里面加的这个任务啊,如果是,就唤醒所有因为queue而等待的线程。
有没有小伙伴还记得,之前我们有一行代码是queue.wait了,然后接下来的代码,我们就没继续讲解,转而去看添加任务的代码了,现在我们被唤醒了,我们回到之前的run方法中,继续看。

 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)  
                    task.run();
            } catch(InterruptedException e) {
            }
        }
    }

还是回到这个方法里面讲解,我们从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)  
                    task.run();
            } catch(InterruptedException e) {
            }
        }
    }

这是wait之后的代码,首先先判断,被唤醒之后,看看队列是不是空的,目前来说,我们唤醒的原因是因为队列里面有元素了,所以这个if对于我们来说,没有限制。
然后声明了两个变量currentTime, executionTime,并从queue中取出任务task,然后是一个同步代码块,同步代码块里面首先判断这个task的状态是不是已取消,如果是已取消,那么从queue中移除该任务,毕竟这个任务都取消了,继续在queue里面没什么意思,然后continue,进行下一步循环。
紧接着,代码获取了当前时间,赋值给currentTime,然后把task的下一次执行时间赋值给了executionTime,这里要解释一下。当我们刚创建task任务的时候,此时task任务是没有执行的,那么我们想让他早上8点执行,,那么早上8点就是他下一次执行的时间,这个道理大家能理解嘛。并不是大家以为的下一次执行时间是任务已经执行完一遍了,第二次执行的时间。所以这里带入我们的情景假设,这个executionTime,就是要这次要执行的时间。这样说,大家应该能理解了吧。
赋值完毕后,进行判断,如果这次要执行的时间小于当前时间,说明啥,说明你执行任务执行晚了,那就得立即执行啊,比如闹钟早上8点要响,这个时候已经9点了,闹钟一看,不行啊!都9点了,我得响啊,然后就咔咔一顿响。所以如果说已经小于当前时间了,就说明这个任务要执行,但大家发现这个if里面还包含了一个if-else

if (task.period == 0) { // Non-repeating, remove
   	queue.removeMin();
    task.state = TimerTask.EXECUTED;
} else { // Repeating task, reschedule
    queue.rescheduleMin(
    task.period<0 ? currentTime - task.period: executionTime + task.period);
}

这部分代码是判断你当前这个任务是不是要循环,因为现在已经确定了要执行任务了,那么进一步判断这个任务是不是要循环,如果要循环得话,那就循环,否则就从queue里面移除。而他判断得方式就是根据period是否等于0,而我们之前说个period就是多久干一次,若这个为0就说明,只干一次,那么只干一次就说明该任务不需要循环,那我就把他移除queue队列,然后把这个任务得状态设置为已执行(一会才能执行),如果当前任务需要循环,那我就需要把当前任务重新放入queue里面,因为放入queue里面,queue会根据要执行得时间进行排序,来挑选出最着急的那个任务。我们当前的这个任务已经确定要执行了,并且当前这个任务还要进行循环,那么就需要重新计算一下,它下一次执行的时间并且重新在queue里面排序。但是这个rescheduleMin我们已经明白了,就是把任务放里面,然后重新排序一下,可是这里面的三目运算符是什么意思呢?
还记得上面让大家记住的period是负数嘛,我们先看如果是负数的情况下,那么传入的参数就是currentTime-task.period,当前时间减去一个负数,就是加上正数,也就是说,当前时间+多久执行一次,就是下次执行的时间,没毛病吧,那么后面的这个executionTime+task.period是什么意思啊。
这里先说两种模型,我1点钟开始做A任务,每5分钟重复一次,那么第一次做是1:00,第二次就是1:05,第三次就是1:10……这样看好像没什么毛病,但是我们做任务是不是也需要时间,比如说做一次任务花费2分钟,那么上面的模型就是1点钟开始做,第一次是1:00,到1:02的时候我做完了,然后进行5分钟重复一次,那么下一次任务就是1:07开始做,以此类推,也就是说多久做一次这个多久 ,即可以根据刚开始做的时候开始计算,也可以根据做完之后再开始计算。而我们用的模型就是做完之后开始计算,而后面的execution+task.period这个就是刚开始做的时候开始计算。这里可能需要各位朋友多思考一下,因为这里我觉得文字有点难以描述。
那么给大家说一下什么情况下可以触发刚开始做的时候开始计算呢,我们之前添加任务的时候,用的API是schedule这个API,如果想要刚开始的时候就开始计算的话,需要这个API,scheduleAtFixedRate,有兴趣的同学可以搜一下看看源码,注意它里面调用的方法传的最后一个参数。
那么好,说了这么一堆,可是任务还是没有执行啊。
接着往下看

                 }
                    if (!taskFired) 
                        queue.wait(executionTime - currentTime);
                }
                if (taskFired)  
                    task.run();
            } catch(InterruptedException e) {
            }
        }

这个taskFired是个boolean值,他代表的含义就是能不能做,如果不能做,那么让当前队列等待,等到能做的时候,就做。
如果能做,则掉task.run方法,这个task是我们的任务,难道这也需要个run方法?答案是对的。因为这个queue根据前面的讲解,他是一个TaskQueue类型,里面就是一个一维数组,数组中的每一个值得类型都是TimerTask,所以说queue里面放的对象都是TimerTask这个类型得,而这个TimerTask类型部分代码如下

所以这个类是一个线程类,需要实现run方法,那么run方法写啥呢?
就写咱们具体干什么事情就行
.

样例代码
public class TimeTest {
    public static void main(String[] args) {
        Timer timer=new Timer();//任务启动
        for(int i=0;i<2;i++){
            TimerTask timerTask=new ClockTimeTask("clock"+i);
            timer.schedule(timerTask,new Date(),1000*60*60*24);//任务添加
        }
    }
}
class ClockTimeTask extends TimerTask{

    private String name;

    public ClockTimeTask(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("叮铃铃");
    }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/956443.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号