定时器相信大家都不陌生，平时使用定时器就像使用闹钟一样，我们可以在固定的时间做某件事，也可以在固定的时间段重复做某件事，今天就来分析一下java中自带的定时任务器Timer。
一、Timer基本使用
在Java中为我们提供了Timer来实现定时任务，当然现在还有很多定时任务框架，比如说Spring、QuartZ、Linux Cron等等，而且性能也更加优越。但是我们想要深入的学习就必须先从最简单的开始。
在Timer定时任务中，最主要涉及到了两个类：Timer和TimerTask。他们俩的关系也特别容易理解，TimerTask把我们得业务逻辑写好之后，然后使用Timer定时执行就OK了。我们来看一个最基本的案例：
public class MyTimerTask extends TimerTask {
private String taskName;
public MyTimerTask(String taskName) {
this.taskName = taskName;
}
public String getTaskName() {
return taskName;
}
public void setTaskName(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
System.out.println("当前执行的任务是：" + taskName);
}
}
这就是我们的TimerTask，我们单独写成类时候需要去继承TimerTask。然后呢我们写好了之后就可以使用Timer来执行了。
public class TimerTest {
public static void main(String[] args) {
Timer timer = new Timer();
MyTimerTask myTask = new MyTimerTask("TimerTask 1");
//在2秒钟之后执行第一次，之后每隔一秒执行一次
timer.schedule(myTask, 2000L, 1000L);
}
}
指定的流程很简单：
（1）第一步：创建一个Timer。
（2）第二步：创建一个TimerTask。
（3）第三步：使用Timer执行TimerTask。
其中第三步无疑是我们目前最关心的，也就是timer.schedule(myTask, 2000L, 1000L)。他的意思是myTask在两秒钟之后开始第一次执行，然后每隔一秒执行一次。这只是最基本的用法。就体现了Timer定时执行的流程。当然java中Timer还为我们提供了很多其他的方法。对此就有必要深入其源码看看了。
二、Timer源码分析
对于一个类的源码分析，我一贯的思路就是先从参数开始，然后构造方法，最后就是常用方法。下面我们就按照这个思路开始今天的源码分析，在这里基于jdk1.8。先给出一张整体类图：
1、参数
Timer的源码中为我们提供了两个最主要的参数TaskQueue和TimerThread。
/**
* The timer task queue. This data structure is shared with the timer
* thread. The timer produces tasks, via its various schedule calls,
* and the timer thread consumes, executing timer tasks as appropriate,
* and removing them from the queue when they're obsolete.
*/
private final TaskQueue queue = new TaskQueue();
/**
* The timer thread.
*/
private final TimerThread thread = new TimerThread(queue);
上面的代码大概意思是这样的：
（1）TaskQueue：这是一个最小堆，它存放该Timer的所有TimerTask。
（2）TimerThread：执行TaskQueue中的任务，执行完从任务队列中移除。
所以上面这两个参数其实是配合着使用的，那这个TaskQueue是如何存放的呢？在这里我们不妨跟进去看看。
class TaskQueue {
/**
* Priority queue represented as a balanced binary heap: the two children
* of queue[n] are queue[2*n] and queue[2*n+1]. The priority queue is
* ordered on the nextExecutionTime field: The TimerTask with the lowest
* nextExecutionTime is in queue[1] (assuming the queue is nonempty). For
* each node n in the heap, and each descendant of n, d,
* n.nextExecutionTime <= d.nextExecutionTime.
*/
private TimerTask[] queue = new TimerTask[128];
//增删改查的方法
}
在这里我们只给出了一部分源码，不过这一部分是整个思想原理最核心的，上面英文的大概意思是;TaskQueue是一个平衡二叉堆，具有最小 nextExecutionTime 的 TimerTask 在队列中为 queue[1] ，也就是堆中的根节点。第 n 个位置 queue[n] 的子节点分别在 queue[2n] 和 queue[2n+1] 。不了解二叉堆的话，可以看看数据结构。
也就是说TimerTask 在堆中的位置其实是通过nextExecutionTime 来决定的。nextExecutionTime 越小，那么在堆中的位置越靠近根，越有可能先被执行。而nextExecutionTime意思就是下一次执行开始的时间。
还有一个TimerTask数组，默认大小是128个。
2、构造方法
构造方法就比较简单了，这里一共有四个：
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();
}
（1）第一个：默认构造方法。
（2）第二个：在构造器中指定是否是守护线程。
（3）第三个：带有名字的构造方法。
（3）第四个：不仅带名字，还指定是否是守护线程。
不过我们需要注意一点的是，Timer在构造完成之后会启动一个后台线程用于执行TaskQueue里面的TimerTask 。
3、定时任务方法
在一开始我们提到，我们不仅可以在指定的时间执行某些任务，还可以在一段时间之后执行。我们对这些方法进行总结一下：
（1）schedule(task,time) 在时间等于或超过time的时候执行且只执行一次task，这个time表示的是例如2019年11月11日上午11点11分11秒。指的是时刻。
（2）schedule(task,time,period)
在时间等于或超过time的时候首次执行task，之后每隔period毫秒重复执行一次task 。这个time和上一个一样。
（3）schedule(task, delay)
在delay时间之后，执行且只执行一次task。这个delay表示的是延迟时间，比如说三秒后执行。
（4）schedule(task,delay,period)
在delay时间之后，开始首次执行task，之后每隔period毫秒重复执行一次task ，这个delay和上面的一样。
我们不如来看看源码：
//第一个：
public void schedule(TimerTask task, Date time) {
sched(task, time.getTime(), 0);
}
//第二个：
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 schedule(TimerTask task, long delay) {
if (delay < 0) throw new IllegalArgumentException("Negative delay.");
sched(task, System.currentTimeMillis()+delay, 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);
}
这四个方法都执行了同一个方法sched，所以我们要弄清楚原理，就必须要再跟进去看看：
private void sched(TimerTask task, long time, long period) {
if (time < 0)
throw new IllegalArgumentException("Illegal execution time.");
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();
}
}
上面的代码我们来分析一下，最上面的if就是排除一下异常情况，最核心的就是synchronized里面的代码。首先将任务添加到队列中，然后根据nextExecutionTime调整队列。
添加任务add(task)：
void add(TimerTask task) {
if (size + 1 == queue.length)
//添加任务很简单，就是数组的拷贝
queue = Arrays.copyOf(queue, 2*queue.length);
queue[++size] = task;
fixUp(size);//维护最小堆
}
维护最小堆：
private void 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;
}
}
上面就是Timer中如何执行的定时任务核心，但是还有一个方法，也是执行定时任务的。叫scheduleAtFixedRate
下面我们来分析一下，然后比较和上面的不同。
4、scheduleAtFixedRate方法
这个方法有两个：
（1）scheduleAtFixedRate(task, time, period)
在时间等于或超过time的时候首次执行task，之后每隔period毫秒重复执行一次task 。这个time表示的是例如2019年11月11日上午11点11分11秒。指的是时刻。
（2）scheduleAtFixedRate(task, delay, period)
在delay时间之后，开始首次执行task，之后每隔period毫秒重复执行一次task ，这个delay表示的是延迟时间，比如说三秒后执行。
既然上面都已经有了4个定时器，为什么这里还要再增加几个呢？我们来分析一下他们的区别：
分两种情况： ① 首次计划执行的时间 schedule：如果第一次执行时间被delay了，随后的执行时间按照上一次实际执行完的时间点进行计算 。 scheduleAtFixedRate：如果第一次执行时间被delay了，随后的执行时间按上一次开始的时间进行计算，并且为了赶上进度会多次执行任务，因此TimerTask中的执行体需要考虑同步。
②任务执行所需时间 schedule方法：下一次执行时间会不断延后，因此参照的是上一次执行完成的时间点。 scheduleAtFixedRate方法：下一次执行时间不会延后，因此存在并发性。 我们可以看一下图：
5、其他方法
我们已经明白了如何创建Timer和执行定时任务，如果在执行的时候我们突然改变主意，想要取消怎么办呢？这里Timer当然为我们提供了。
（1）cancel：取消此计时器任务。
（2）scheduledExecutionTime()：返回此任务最近实际执行的安排执行时间。
6、任务调度
任务调度也就是说我们的线程如何去执行这些任务。其实在TimerThread调用了run来执行，我们看一下源码。
public void run() {
try {
mainLoop();
} finally {
synchronized(queue) {
newTasksMayBeScheduled = false;
queue.clear();
}
}
}
也就是说其实真正执行任务调度的是mainLoop()，synchronized代码块只是为了确保在执行完之后能够移除这个task。
而这个mainLoop方法的思想很简单，就是拿出任务队列中的第一个任务，如果执行时间还没有到，则继续等待，否则立即执行。源码在这里就不再给出了。
三、Timer缺陷
上面从源码的角度分析了一下Timer，因为用法很简单，主要是源码分析。说了这么多，Timer还是有一定的缺陷的，
1、Timer管理延时任务的缺陷
Timer在执行定时任务时只会创建一个线程，所以如果存在多个任务，且任务时间过长，超过了两个任务的间隔时间，会发生一些缺陷。我们看一个例子：
这个例子中的功能是这样的，第一个任务在1秒钟之后开始执行，第二个任务在2秒钟之后开始执行。
第一步：定义两个TimerTask
public class Task1 extends TimerTask {
@Override
public void run() {
try {
SimpleDateFormat sdf =
new SimpleDateFormat("hh:MM:ss");
String data = sdf.format(new Date());
System.out.println("task 1:"+data);
//休眠了3秒
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
还有一个：
public class Task2 extends TimerTask {
@Override
public void run() {
SimpleDateFormat sdf =
new SimpleDateFormat("hh:MM:ss");
String data = sdf.format(new Date());
System.out.println("task 2:"+data);
}
}
第二步：我们测试一下：
public class TimerTest {
public static void main(String[] args) {
Timer timer = new Timer();
Task1 myTask1 = new Task1();
Task2 myTask2 = new Task2();
SimpleDateFormat sdf =
new SimpleDateFormat("hh:MM:ss");
String data = sdf.format(new Date());
System.out.println("Main :"+data);
timer.schedule(myTask1, 1000L);
timer.schedule(myTask2, 2000L);
}
}
//Main :05:09:30
//task 1:05:09:31
//task 2:05:09:34
我们在上面的Task1中会发现，任务2不是应该在32秒的时候执行嘛，怎么会在4秒钟之后才执行。究其原因是任务1执行了3秒，但是线程只有一个，所以只能先把任务1执行完才去执行任务2。这就是其缺陷之一。
2、Timer当任务抛出异常时的缺陷
这个缺陷的意思是，其中有一个任务抛出了RuntimeException，那么所有的任务都会停止执行。这个演示起来很简单。
第一步：声明几个定时任务
public class Task1 extends TimerTask {
@Override
public void run() {
throw new RuntimeException();
}
}
public class Task2 extends TimerTask {
@Override
public void run() {
System.out.println("任务2执行");
}
}
第二步：测试
public class TimerTest {
public static void main(String[] args) {
Timer timer = new Timer();
Task1 myTask1 = new Task1();
Task2 myTask2 = new Task2();
timer.schedule(myTask1, 1000L);
timer.schedule(myTask2, 2000L);
}
}
我们来看一下结果：
正是Timer有很多的缺陷，所以出现了Timer的替代品ScheduledExecutorService，用来解决上面出现的问题。而且也出现了很多优秀的框架。具体的我会在后续文章中介绍。
OK，今天的文章到这，欢迎批评指正。
