首页 > 其他 > 详细

【定时任务】Timer

时间:2017-11-12 19:00:52      阅读:304      评论:0      收藏:0      [点我收藏+]

Java原生api Timer类就可以实现简单的定时任务。下面将简单介绍一下Timer。

一、使用 Timer 实现定时任务

具体代码如下。

可以看到我们主要是分三步进行的

1、new Timer() 创建定时器

2、new TimerTask() 创建任务。这里是通过继承TimerTask类实现的。

3、使用定时器调度。这里我们使用的是Timer类中的schedule(TimerTask task, long delay, long period) 方法,里面有三个参数,

   第一个参数表示任务,第二个参数表示延迟的时间,第三个参数表示任务执行的间隔(也就是每隔多少秒执行一次任务)。

public class TimerTest {
    
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTest().new MyTask(), 1000, 5000);
    }
    
    /**
     * 任务
     * @author LKB
     *
     */
    class MyTask extends TimerTask{

        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println("current time is " + new Date());
        }        
    }
}

二、Timer 实现定时任务的原理

Timer 的实现需要四个类:Timer TimerThread TaskQueue TimerTask。

2.1 TimerTask

其中 TimerTask 表示任务,它是个抽象类TimeTask 抽象类  继承Runnable。可以看到每个Task都是一个runnable对象。

TimeTask中全局变量有

   lock    锁
    state    VIRGIN: 任务未被调度
            SCHEDULED: 任务被调度但是还未执行
            EXECUTED: 任务已经被执行但是未被取消
            CANCELLED:任务被取消
            nextExecutionTime:任务下一次被执行的时间
            period:重复任务之间的间隔

内部方法有

  //取消调度
    public boolean cancel() {
        synchronized(lock) {
            boolean result = (state == SCHEDULED);
            state = CANCELLED;
            return result;
        }
    }
    //计算下次执行时间
    public long scheduledExecutionTime() {
        synchronized(lock) {
            return (period < 0 ? nextExecutionTime + period
                               : nextExecutionTime - period);
        }
    }

2.2 TaskQueue

TaskQueue 是一个优先队列,它是通过一个数组实现的。

全局变量有:

  private TimerTask[] queue = new TimerTask[128];  一个数组,数组元素类型为TimerTask。这个数组用来实现优先队列。
    
    private int size = 0; //优先队列中的任务个数  需要注意的是任务在优先队列中的存储是queue[1]-queue[size]

内部的方法有挺多的,最基本的我认为是下面几个:

  /**
     * Adds a new task to the priority queue.
     */
    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);
    }

    /**
     * Return the "head task" of the priority queue.  (The head task is an
     * task with the lowest nextExecutionTime.)
     */
    TimerTask getMin() {
        return queue[1];
    }
    
    /**
     * Remove the head task from the priority queue.
     */
    void removeMin() {
        queue[1] = queue[size];
        queue[size--] = null;  // Drop extra reference to prevent memory leak
        fixDown(1);
    }

add 是往队列中添加任务,removeMin 是移除队头元素。因为 TaskQueue 是通过优先队列实现的,所以的删除或者添加一个元素的复杂度为O(lgN)。

2.3 TimerThread

TimerThread 继承Thread 类,Timer 定时器正是通过这个线程实现任务调度的。

全局变量有

boolean newTasksMayBeScheduled = true;  //如果该标志位false 则表示对 Timer 对象没有任何有效的引用,没有任何的任务需要做了,线程可以优雅地终止了
private TaskQueue queue; //任务队列

重写的 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
            }
        }
    }

    /**
     * The main timer loop.  (See class comment.)
     */
    private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                synchronized(queue) {
                    // Wait for queue to become non-empty
                    while (queue.isEmpty() && newTasksMayBeScheduled)
                        queue.wait();
                    if (queue.isEmpty())
                        break; // Queue is empty and will forever remain; die

                    // Queue nonempty; look at first evt and do the right thing
                    long currentTime, executionTime;
                    task = queue.getMin();
                    synchronized(task.lock) {
                        if (task.state == TimerTask.CANCELLED) {
                            queue.removeMin();
                            continue;  // No action required, poll queue again
                        }
                        currentTime = System.currentTimeMillis();
                        executionTime = task.nextExecutionTime;
                        if (taskFired = (executionTime<=currentTime)) {
                            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);
                            }
                        }
                    }
                    if (!taskFired) // Task hasn‘t yet fired; wait
                        queue.wait(executionTime - currentTime);
                }
                if (taskFired)  // Task fired; run it, holding no locks
                    task.run();
            } catch(InterruptedException e) {
            }
        }
    }

可以看到TimerThread 运行的方式很简单,在一个while(true)循环中,首先判断任务队列中是否有任务,没有任务则一直等待;

如果有任务,取出该任务(运行时间离当前时间最近的任务),判断任务时间,任务时间到了,则调用task.run()运行任务。

2.4 Timer

Timer 是一个调度器,该调度器内部只有一个调度线程,并且只有一个任务队列。

全局变量有:

   private final TaskQueue queue = new TaskQueue(); //任务队列
   private final TimerThread thread = new TimerThread(queue); //调度线程
   private final Object threadReaper = new Object() {
       protected void finalize() throws Throwable {
           synchronized(queue) {
               thread.newTasksMayBeScheduled = false;
               queue.notify(); // In case queue is empty.
           }
       }
   }; //该对象可以使得当没有任何有效引用指向Timer对象时,定时器被优雅回收
   
    /**
     * This ID is used to generate thread names.
     */
    private final static AtomicInteger nextSerialNumber = new AtomicInteger(0);
    private static int serialNumber() {
        return nextSerialNumber.getAndIncrement();
    }

最基本的构造器如下。可以看到,当我们new一个 Timer 对象出来时,Timer 中对应的调度线程就被启动了。

 public Timer(String name) {
        thread.setName(name);
        thread.start();
    }

最基本的调度方法如下。可以看出它其实就是对任务队列的一个操作。

首先将当前任务配置好(计算好下次执行时间,间隔与状态),然后加入任务队列,如果刚好是队列的队头,再将队列唤醒,让队列直接处理。

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

综上,我们可以任务定时器的工作原理如下:

技术分享

Timer 内部拥有一个 TimerThread 和 一个TaskQueue,当我们new Timer() 时,我们就拥有了这两个对象,并启动了TimerThread。

当我们这样调动  timer.schedule(new TimerTest().new MyTask(), 1000, 5000); schedule方法时我们就将对应的任务加到TaskQueue中。

TimeThread 负责调度TaskQueue,TaskQueue 是一个优先队列,里面的元素全是TimerTask 对象。

 

【定时任务】Timer

原文:http://www.cnblogs.com/cuglkb/p/7801649.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!