if (time < 0)
throw new IllegalArgumentException("Illegal execution time.");
// 同步代码块 ，对queue的访问需要同步
synchronized (queue) {
if (!thread.newTasksMayBeScheduled)
throw new IllegalStateException("Timer already cancelled.");
// 同步代码块，需要获得task的lock，锁
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();
}
}
// 终止此计时器，丢弃所有当前已安排的任务。
public void cancel() {
synchronized (queue) {
thread.newTasksMayBeScheduled = false;
queue.clear();
queue.notify(); // In case queue was already empty.
}
}
// 从此计时器的任务队列中移除所有已取消的任务。
public int purge() {
int result = 0;
synchronized (queue) {
for (int i = queue.size(); i > 0; i--) {
if (queue.get(i).state == TimerTask.CANCELLED) {
queue.quickRemove(i);
result++;
}
}
if (result != 0)
queue.heapify();
}
return result;
}
}
import java.util.*;
import java.util.Date;
public class Timer {
// 定时任务队列
private TaskQueue queue = new TaskQueue();
// 计时器线程
private TimerThread thread = new TimerThread(queue);
private Object threadReaper = new Object() {
protected void finalize() throws Throwable {
synchronized (queue) {
thread.newTasksMayBeScheduled = false;
queue.notify(); // In case queue is empty.
}
}
};
// ID号作为线程的ID
private static int nextSerialNumber = 0;
private static synchronized int serialNumber() {
return nextSerialNumber++;
}
public Timer() {
this("Timer-" + serialNumber());
}
// 创建一个新计时器，可以指定其相关的线程作为守护程序运行。
public Timer(boolean isDaemon) {
this("Timer-" + serialNumber(), isDaemon);
}
public Timer(String name) {
thread.setName(name);
thread.start();
}
// 创建一个新计时器，其相关的线程具有指定的名称，并且可以指定作为守护程序运行。
public Timer(String name, boolean isDaemon) {
thread.setName(name);
thread.setDaemon(isDaemon);
thread.start();
}
// 安排在指定延迟后执行指定的任务。时间单位毫秒
public void schedule(TimerTask task, long delay) {
if (delay < 0)
throw new IllegalArgumentException("Negative delay.");
sched(task, System.currentTimeMillis() + delay, 0);
}
// 安排在指定的时间执行指定的任务。
public void schedule(TimerTask task, Date time) {
sched(task, time.getTime(), 0);
}
// 安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
public void schedule(TimerTask task, long delay, long period) {
if (delay < 0)
throw new IllegalArgumentException("Negative delay.");
if (period<= 0)
throw new IllegalArgumentException("Non-positive period.");
sched(task, System.currentTimeMillis() + delay, -period);
}
// 安排指定的任务在指定的时间开始进行重复的固定延迟执行。
public void schedule(TimerTask task, Date firstTime, long period) {
if (period <= 0)
throw new IllegalArgumentException("Non-positive period.");
sched(task, firstTime.getTime(), -period);
}
// 安排指定的任务在指定的延迟后开始进行重复的固定速率执行。
public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
if (delay < 0)
throw new IllegalArgumentException("Negative delay.");
if (period <= 0)
throw new IllegalArgumentException("Non-po