Java定时器Timer的源码分析

 更新时间:2022年11月02日 11:09:42   作者:UnicornLien  
通过源码分析,我们可以更深入的了解其底层原理。本文将通过Timer的源码,带大家深入了解Java Timer的使用,感兴趣的小伙伴可以了解一下

通过源码分析,我们可以更深入的了解其底层原理。

对于JDK自带的定时器,主要涉及TimerTask类、Timer类、TimerQueue类、TimerThread类,其中TimerQueue和TimerThread类与Timer类位于同一个类文件,由Timer内部调用。

先画上一张图,描述一下Timer的大致模型,Timer的模型很容易理解,即任务加入到任务队列中,由任务处理线程循环从任务队列取出任务执行:

一、TimerTask

TimerTask是一个任务抽象类,实现了Runnable接口,是可被线程执行的。

1. 任务状态

在TimerTask中定义了关于任务状态的常量字段:

//	未调度状态
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中,有如下成员变量:

//	用于加锁控制多线程修改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方法的实现代码:

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方法实现:

public long scheduledExecutionTime() {
    synchronized(lock) {
        return (period < 0 ? nextExecutionTime + period
                           : nextExecutionTime - period);
    }
}

该方法返回此任务的下次执行时间点。

二、Timer

分析Timer源代码,Timer在内部持有了两个成员变量:

private final TaskQueue queue = new TaskQueue();

private final TimerThread thread = new TimerThread(queue);

TaskQueue是任务队列,TimerThread是任务处理线程。

1. sched方法

无论是使用schedule还是scheduleAtFixedRate方法来调度任务,Timer内部最后都是调用sched方法进行处理。

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方法核心代码:

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内部的线程也会对任务队列进行操作,因此加锁。

public void cancel() {
    synchronized(queue) {
        //	修改线程的循环执行标志,令线程能够终止
        thread.newTasksMayBeScheduled = false;
        //	清空任务队列
        queue.clear();
        //	唤醒线程
        queue.notify();
    }
}

3. purge方法

当通过TimerTask.cancel将任务取消后,Timer的任务队列还引用着此任务,Timer只有到了要执行时才会移除,其他时候并不会自动将此任务移除,需要调用purge方法进行清理。

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按时间从近到远进行排序。

void add(TimerTask task) {
    // 检测数组长度,若不够则进行扩容
    if (size + 1 == queue.length)
        queue = Arrays.copyOf(queue, 2*queue.length);

	//	任务入队
    queue[++size] = task;

	//	排序
    fixUp(size);
}

fixUp方法实现:

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;
    }
}

TaskQueue中除了fixUp方法外还有一个fixDown方法,这两个其实就是堆排序算法,在算法专题中再进行详细介绍,只要记住他们的任务就是按时间从近到远进行排序,最近的任务排在队首即可。

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);
}

四、TimerThread

TimerThread的核心代码位于mainLoop方法:

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 = (executionTime<=currentTime)) {

                        //	如果任务period=0,即一次性任务
                        if (task.period == 0) {

                            //	从队列移除一次性任务
                            queue.removeMin();


                            //	任务状态变更为已执行
                            task.state = TimerTask.EXECUTED;

                        } else {

                            //	可重复执行任务,重新进行调度,period<0是固定时延,period>0是固定速率
                            queue.rescheduleMin(
                              task.period<0 ? currentTime   - task.period	//	计算下次执行时间
                                            : executionTime + task.period);
                        }
                    }
                }
                
                // taskFired为false即任务尚未到执行时间点,进行等待,等待时间是 执行时间点 - 当前时间点
                if (!taskFired)
                    queue.wait(executionTime - currentTime);
            }

            //	taskFired为true表示已触发,执行任务
            if (taskFired)  
                task.run();
        } catch(InterruptedException e) {
        }
    }
}

以上就是Java定时器Timer的源码分析的详细内容,更多关于Java Timer的资料请关注脚本之家其它相关文章!

相关文章

  • java对象序列化操作实例分析

    java对象序列化操作实例分析

    这篇文章主要介绍了java对象序列化操作,结合实例形式分析了java对象序列化操作相关实现步骤与操作注意事项,需要的朋友可以参考下
    2019-11-11
  • springboot+maven多环境动态配置及编译失败的解决方案(步骤详解)

    springboot+maven多环境动态配置及编译失败的解决方案(步骤详解)

    这篇文章主要介绍了springboot+maven多环境动态配置及编译失败的解决方案,本文通过实例图文相结合给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧
    2023-11-11
  • java实现文件重命名功能

    java实现文件重命名功能

    这篇文章主要介绍了java实现文件重命名功能,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2020-03-03
  • Spring中最常用的注解之一@Autowired详解

    Spring中最常用的注解之一@Autowired详解

    本文讲解了Spring中最常用的注解之一@Autowired, 平时我们可能都是使用属性注入的,但是后续建议大家慢慢改变习惯,使用构造器注入。同时也讲解了这个注解背后的实现原理,需要的朋友可以参考下
    2023-01-01
  • 数据库基本操作语法归纳总结

    数据库基本操作语法归纳总结

    本篇文章主要介绍了数据库的一些常用方法及一些基本操作,需要的朋友可以参考下
    2017-04-04
  • Java实现简单井字棋小游戏代码实例

    Java实现简单井字棋小游戏代码实例

    这篇文章主要介绍了Java实现简单井字棋小游戏代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-03-03
  • SpringBoot集成quartz实现定时任务

    SpringBoot集成quartz实现定时任务

    这篇文章主要介绍了如何使用SpringBoot整合Quartz,并将定时任务写入库中(持久化存储),还可以任意对定时任务进行如删除、暂停、恢复等操作,需要的可以了解下
    2023-09-09
  • Javaweb EL自定义函数开发及代码实例

    Javaweb EL自定义函数开发及代码实例

    这篇文章主要介绍了Javaweb EL自定义函数开发及代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-06-06
  • mybatis-plus的批量新增/批量更新以及问题

    mybatis-plus的批量新增/批量更新以及问题

    这篇文章主要介绍了Mybatis-Plus实现批量新增与批量更新以及出现的问题,文章中有详细的代码示例,感兴趣的同学可以参考一下
    2023-04-04
  • java中的BlockingQueue(阻塞队列)解析

    java中的BlockingQueue(阻塞队列)解析

    这篇文章主要介绍了java中的BlockingQueue阻塞队列解析,阻塞队列是一个支持两个附加操作的队列,这两个附加的操作是,在队列为空时,获取元素的线程会等待队列变为非空,需要的朋友可以参考下
    2023-12-12

最新评论