定时器的使用
//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) {
}
}
}
}