Java-定时器(Timer)-分析

定时器的使用

//timer的使用
private void testTimer(){
        //<1>Timer仅延迟执行
        //第一次延时1秒后开始执行任务currentTime=System.currentTimeMillis()+1000，任务执行完后就结束了
        Timer timerDelayOnly = new Timer();
        timerDelayOnly.schedule(new TimerTask() {
            @Override
            public void run() {
				//要执行的任务
            }
        },1000);

        //<2>
        //第一次延时1秒后开始执行任务nextTaskTime=System.currentTimeMillis()+1000，即第一次任务开始执行时间
        //第一次任务完成后下次任务nextTaskTime=System.currentTimeMillis()+3000，即第二次任务开始执行时间
        //第二次任务完成后下次任务nextTaskTime=System.currentTimeMillis()+3000，即第三次任务开始执行时间
        //...
        //此类定时器，在上个任务执行完后，才会重新计时
        Timer timerDelayAndRate = new Timer();
        timerDelayAndRate.schedule(new TimerTask() {
            @Override
            public void run() {
                //要执行的任务
            }
        },1000,30*1000);

        //<3>
        //第一次延时1秒后开始执行任务nextTaskTime=System.currentTimeMillis()+1000，即第一次任务的执行时间
        //第一次任务完成后下次任务nextTaskTime=nextTaskTime+3000，即第二次任务开始执行时间
        //第二次任务完成后下次任务nextTaskTime=nextTaskTime+3000，即第三次任务开始执行时间
        //...
        //此类定时器，在固定时间线为起点，重新计时
        Timer timerDelayAtFixedRate = new Timer();
        timerDelayAtFixedRate.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                //要执行的任务
            }
        },1000,30*1000);

        //<4>
        //每天除第一次12是0分0秒，被调起，其他次的任务需要考虑历史人物的执行时间的总和
        //第一次任务开始执行时间nextTaskTime=timeDate，即第一次任务的执行时间
        //第一次任务完成后下次任务nextTaskTime=System.currentTimeMillis()+1000 * 60 * 60 * 24，即第二次任务的执行时间
        //第二次任务完成后下次任务nextTaskTime=System.currentTimeMillis()+1000 * 60 * 60 * 24，即第三次任务的执行时间
        //...
        //此类定时器，在上个任务执行完后，才会重新计时
        Timer timerDate= new Timer();
        Calendar calendarDate = Calendar.getInstance();
        calendarDate.set(Calendar.HOUR_OF_DAY, 12); // 控制时
        calendarDate.set(Calendar.MINUTE, 0);// 控制分
        calendarDate.set(Calendar.SECOND, 0);// 控制秒
        Date timeDate = calendarDate.getTime();// 得出执行任务的时间,此处为今天的12：00：00
        timerDate.schedule(new TimerTask() {
            @Override
            public void run() {
                //要执行的任务
            }
        },timeDate,1000 * 60 * 60 * 24);

        //<5>
        //每天12时0分0秒，任务被执行，不考虑任务的执行时间
        //每天除第一次12是0分0秒，被调起，其他次的任务需要考虑历史人物的执行时间的总和
        //第一次任务开始执行时间nextTaskTime=timeDate，即第一次任务的执行时间
        //第一次任务完成后下次任务nextTaskTime=extTaskTime+1000 * 60 * 60 * 24，即第二次任务的执行时间
        //第二次任务完成后下次任务nextTaskTime=extTaskTime+1000 * 60 * 60 * 24，即第三次任务的执行时间
        //...
        //此类定时器，在上个任务执行完后，下一个任务的时间为上一个任务的起始时间+period
        Timer timerAtFixedRate = new Timer();
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY, 12); // 控制时
        calendar.set(Calendar.MINUTE, 0);// 控制分
        calendar.set(Calendar.SECOND, 0);// 控制秒
        Date time = calendar.getTime();// 得出执行任务的时间,此处为今天的12：00：00
        timerAtFixedRate.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                //要执行的任务
            }
        },time,1000 * 60 * 60 * 24);
    }

定时器调用过程

Timer

//Timer 初始化对象时，
private final TaskQueue queue = new TaskQueue();
private final TimerThread thread = new TimerThread(queue);
 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();
        }
    }
    

TimerThread 的run方法

class TimerThread extends Thread {
    /**
     *新任务可能被执行
     */
    boolean newTasksMayBeScheduled = true;
    private TaskQueue queue;

    TimerThread(TaskQueue queue) {
        this.queue = queue;
    }

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

    /**
     * 真正执行定时任务的方法，在run方法中被调起
     */
    private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                synchronized(queue) {
                    // Wait for queue to become non-empty
                    //Timer初始化完成thread.start()后，会一直阻塞在这个位置等待
                    //一直等到Timer.sched(...){queue.add(TimerTask;queue.notify();)}，阻塞等待才会结束
                    while (queue.isEmpty() && newTasksMayBeScheduled)
                        queue.wait();
                     //TimerTask.cancel(){queue.clear;newTasksMayBeScheduled=false}，会退出循环
                    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
                            //周期性重置task.nextExecutionTime。
                            //task.period<0，上一个任务执行完后，以当前时间currentTime为基准，往后延时period
                            //task.period>0，与task.nextExecutionTime为基准，往后延时period
                                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) {
            }
        }
    }
}