Timer 定时器原理：
Timer 类:
if (time < 0)
thrownew IllegalArgumentException("Illegal executiontime.");
// Constrain value of periodsufficiently to prevent numeric
// overflow while still beingeffectively infinitely large.
if (Math.abs(period) >(Long.MAX_VALUE >> 1))
period >>= 1;
synchronized(queue) {
if (!thread.newTasksMayBeScheduled)
thrownew IllegalStateException("Timer alreadycancelled.");
synchronized(task.lock) {
if (task.state != TimerTask.VIRGIN)
thrownew IllegalStateException(
"Task already scheduledor cancelled");
task.nextExecutionTime = time;
task.period = period;
task.state = TimerTask.SCHEDULED;
}
queue.add(task);
if (queue.getMin() == task)
queue.notify();
}
TimerTask:
package java.util;
public abstract class TimerTask implementsRunnable {
final Object lock = new Object(); //锁
int state = VIRGIN;
static final int VIRGIN = 0;
static final int SCHEDULED = 1;
static final int EXECUTED = 2;
static final int CANCELLED = 3;
long nextExecutionTime;
long period = 0;
protected TimerTask() {
}
public abstract void run();
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);
}
}
}
TaskQueue:任务队列
Public class TaskQueue{
private TimerTask[] queue = new TimerTask[128];
privateintsize = 0;
int size() {
returnsize;
}
void add(TimerTask task) {
// Grow backing store ifnecessary
if (size + 1 == queue.length)
queue = Arrays.copyOf(queue, 2*queue.length);
queue[++size] = task;
fixUp(size);
}
TimerTask getMin() {
returnqueue[1];
}
TimerTask get(int i) {
returnqueue[i];
}
void removeMin() {
queue[1] = queue[size];
queue[size--] = null;
fixDown(1);
}
void quickRemove(int i) {
assert i <= size;
queue[i] = queue[size];
queue[size--] = null; }
void rescheduleMin(long newTime) {
queue[1].nextExecutionTime = newTime;
fixDown(1);
}
boolean isEmpty() {
returnsize==0;
}
void clear() {
for (int i=1; i<=size; i++)
queue[i] = null;
size = 0;
}
privatevoid 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;
}
}
privatevoid 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： 定时任务线程
Public TimerThread{
booleannewTasksMayBeScheduled = true;
private TaskQueue queue;
TimerThread(TaskQueue queue) {
this.queue = queue;
}
publicvoid run() {
try {
mainLoop();
} finally {
synchronized(queue) {
newTasksMayBeScheduled = false;
queue.clear(); }
}
}
privatevoid 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) { // Non-repeating, remove
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) {
}
}
}
}
Timer是一个单线程 + 最小堆 + 不断轮询
Timer time=newTimer();
n 调用构造方法创建timer类
public Timer(){
this("Timer-"+ serialNumber());
}
private final static AtomicIntegernextSerialNumber = new AtomicInteger(0);
private static int serialNumber() {
return nextSerialNumber.getAndIncrement();
}
This方法: 这个name是Timer-0
public Timer(String name) {
thread.setName(name);
thread.start();
}
对name设置值
public final void setName(String name) {
checkAccess();
this.name = name.toCharArray();
}
checkAccess();
这个是权限控制
publicfinalvoid checkAccess() {
SecurityManager security =System.getSecurityManager();
if (security != null) {
security.checkAccess(this);
}
}
SecurityManager 对运行的java代码进行权限控制，防止恶意代码的运行
开启线程：
thread.start(); 这个运行的是timerThread 的run方法
这里先略过，
time.schedule(new TaskTest(), 1000); 定时类设置任务和每次时间间隔执行的时间
public void schedule(TimerTask task, long delay){
if (delay < 0)
throw new IllegalArgumentException("Negativedelay.");
sched(task, System.currentTimeMillis()+delay, 0);
}
//初始化task、 task 执行任务 time时间period 间隔
privatevoid sched(TimerTask task, long time, long period) {
if (time < 0)
thrownew IllegalArgumentException("Illegal executiontime.");
// Constrain value of periodsufficiently to prevent numeric
// overflow while still beingeffectively infinitely large.
if (Math.abs(period) >(Long.MAX_VALUE >> 1)) 间隔的绝对值 大于 LONG的最大值右移动一位 Long.MAX_VALUE =9223372036854775807
Long.MAX_VALUE >> 1 =4611686018427387903
period >>= 1; period右移一位并重新赋值给自己
这里插一下开始的时候创建了thread TimerThread thread = new TimerThread(queue);
Queue private TimerTask[] queue = newTimerTask[128];
synchronized(queue) {
if (!thread.newTasksMayBeScheduled) 判断 线程的newTasksMayBeScheduled 这个值是true还是false
thrownew IllegalStateException("Timer alreadycancelled.");如果是true 就报错
synchronized(task.lock) {
if (task.state != TimerTask.VIRGIN) 判断线程状态 task。State 初始是0 TimerTask.VIRGIN 初始也是0，如果初始状态不等就报错
thrownew IllegalStateException("Task already scheduledor cancelled");
task.nextExecutionTime = time; 任务的下一个执行时间是time
task.period = period; 间隔是period
task.state = TimerTask.SCHEDULED; TimerTask.SCHEDULED =1
}
queue.add(task); 把任务加入到队列
这里插入一下queue的方法add
void add(TimerTask task) {
// Grow backing store if necessary
if (size + 1 == queue.length) size 初始化是0 ，如果size+1是现在队列的长度就默认扩容2倍
queue = Arrays.copyOf(queue, 2*queue.length);
queue[++size] = task; 加入队列 queue是TimerTask数组，默认初始化128内存
fixUp(size);
这里插入fixup 比较队列中现在这个任务和上一个任务的执行时间
privatevoidfixUp(int k) {
while (k> 1) {
int j =k >> 1; 右移动是减少 2>>1 变成1
if (queue[j].nextExecutionTime<= queue[k].nextExecutionTime)
break;
TimerTask tmp = queue[j]; queue[j] = queue[k]; queue[k] =tmp;
k = j; 这里把k减少
}
}
}
if (queue.getMin() == task) 如果队列中的 和现在这个task一样 就唤醒其他等待线程
getMIn=queue【1】；
queue.notify();
}
}
、task的执行：
publicvoidrun() {
try {
mainLoop();
} finally {
// Someonekilled this Thread, behave as if Timer cancelled
synchronized(queue) {
newTasksMayBeScheduled = false;
queue.clear(); // Eliminate obsoletereferences
}
}
}
privatevoidmainLoop() {
while (true) { //轮循环
try {
TimerTask task;
booleantaskFired;
synchronized(queue) {
// Wait forqueue to become non-empty
while (queue.isEmpty()&& newTasksMayBeScheduled) 如果队列是空的就进入等待
queue.wait();
if (queue.isEmpty())
break; //Queue is empty and will forever remain; die
// Queuenonempty; look at first evt and do the right thing
longcurrentTime, executionTime;
task = queue.getMin();
synchronized(task.lock) {
if(task.state == TimerTask.CANCELLED) {
queue.removeMin();
continue; // No action required, pollqueue 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); //这里计算下一次的执行时间，轮询的时候比较下一次的执行时间，如果时间不对就不执行 这里有个问题，就是为什么动态循环都是只有下下一次才能改变这个时间间隔，而不是下一次，因为这次就决定了下次时间的决定。所以timer没办法改变下一次的执行时间，但是可以改变下下次的执行，那么这里我是不是可以重写这个函数，把执行时间可以从外部传进去。
}
}
}
if(!taskFired) // Task hasn't yet fired; wait
queue.wait(executionTime- currentTime);
}
if(taskFired) // Task fired;run it, holding no locks
task.run();
} catch(InterruptedExceptione) {
}
}
}