目录
一、什么是定时器?
二、标准库中的定时器
三、实现定时器
一、什么是定时器?
定时器就像一个"闹钟"，当它到达设定的时间后，就会执行预定的代码。
例如，我们在TCP的超时重传机制中讲过，如果服务器在规定的时间内没有收到客户端返回的ACK确认应答，那么它将再次发送请求。
二、标准库中的定时器
1.标准库中提供了一个Timer类，Timer类的核心方法为schedule；
2.schedule包含两个参数，第一个参数为即将要执行的任务代码，第二个参数为指定多长时间之后执行(单位为毫秒)
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("Timer");
}
},3000);
}三、实现自定义定时器
为了实现一个自定义的计时器，我们需要满足以下两个条件：
- 被调度的任务可以按照指定时间执行；
- 一个定时器可以调度多个任务，并按照最初约定的时间执行它们。
1.被调度的任务可以按照指定时间执行。
针对第一个条件，我们可以创建一个线程来周期性地扫描任务列表，检查每个任务是否到达指定的执行时间。如果任务到达了预定的执行时间，就执行相应的代码；如果没有达到预定的执行时间，就不执行任务。
2.一个定时器可以调度多个任务，并按照最初约定的时间执行它们。
针对第二个条件，我们可以使用一个优先级队列（PriorityBlockingQueue），这里为了线程安全我们使用PriorityBlockingQueue，而不是PriorityQueue来保存所有的任务。这个队列可以根据任务的执行时间进行排序，使得时间最早的任务位于队列的前端，即最先要执行的任务。这样，在第一个条件中描述的扫描线程只需要检查队列的首元素即可，而不需要遍历整个任务列表。
这里还需要处理一个小问题，就是我们如何描述一个任务?我们可以使用Runnable描述任务，并添加一个表示执行时间的字段。
class MyTask{
//要指定的任务
private Runnable runnable;
///任务执行时间(毫秒时间戳)
private long time;
public MyTask(Runnable runnable, long time) {
this.runnable = runnable;
this.time = time;
}
/**
* 获取当前任务时间
*
* @return
*/
public long getTime() {
return time;
}
/**
* 执行任务
*/
public void run(){
runnable.run();
}
}我们按照上面的两个条件的描述，写出下列代码:
class MyTimer {
//扫描线程
private Thread t = null;
//优先级队列
private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
public MyTimer() {
t = new Thread(() -> {
while (true) {
try {
//取出队首元素,判断当前任务是否到达时间
MyTask myTask = queue.take();
long curTime = System.currentTimeMillis();
if (curTime > myTask.getTime()) {
//未到达时间,放回队列中
queue.put(myTask);
} else {
//到达时间,执行任务
myTask.run();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
/**
* @param runnable
* @param time
*/
public void schedule(Runnable runnable, long time) {
MyTask task = new MyTask(runnable, System.currentTimeMillis() + time);
queue.offer(task);
}
}上面的代码看起来很有道理，我们运行代码
然后就会得到报错，在优先级队列中第五点的使用示例我们详细说明过原因，这里不再赘述，简而言之，当你使用自定义类作为PriorityQueue的元素时，除了提供一个比较器（Comparator）来定义元素之间的排序规则外，你还可以通过实现Comparable接口并重写compareTo方法来定义元素的自然顺序，我们需要明确说明，当前任务对象的优先级是什么样的。
class MyTask implements Comparable<MyTask> {
//要指定的任务
private Runnable runnable;
///任务执行时间(毫秒时间戳)
private long time;
public MyTask(Runnable runnable, long time) {
this.runnable = runnable;
this.time = time;
}
/**
* 获取当前任务时间
*
* @return
*/
public long getTime() {
return time;
}
/**
* 执行任务
*/
public void run() {
runnable.run();
}
@Override
public int compareTo(MyTask o) {
return (int) (this.time - o.getTime());
}
}但是上面的代码还存在一个问题，如果当前任务未到执行时间时，代码会不断重复执行队列的取出和塞回操作。
如果当前任务未到执行时间时，代码会不断重复执行队列的取出和塞回操作，这种现象被称为"忙等"。为了更有效地利用CPU资源，我们需要使用阻塞式等待而不是忙等。
在这种情况下，我们知道等待的时间比较明确，第一时间想到了使用sleep方法来等待，但是可能会出现问题。例如，如果我们添加了一个比之前添加的任务更早的任务，那么可能会错过新任务的执行时间。
因此，我们可以使用wait方法来实现阻塞式等待更为合适，因为它可以更方便地唤醒线程并重新检查时间。
wait方法还提供了一个带有"超时时间"的版本，这意味着我们可以指定一个最长等待时间，以避免无限期地等待。这样，即使没有新的任务加入，线程也可以在一定时间后自动唤醒并继续执行其他任务。
class MyTimer {
//扫描线程
private Thread t = null;
//优先级队列
private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
public MyTimer() {
t = new Thread(() -> {
while (true) {
try {
//取出队首元素,判断当前任务是否到达时间
MyTask myTask = queue.take();
long curTime = System.currentTimeMillis();
if (curTime > myTask.getTime()) {
//未到达时间,放回队列中
queue.put(myTask);
synchronized (this) {
this.wait(myTask.getTime() - curTime);
}
} else {
//到达时间,执行任务
myTask.run();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
/**
* @param runnable
* @param time
*/
public void schedule(Runnable runnable, long time) {
MyTask task = new MyTask(runnable, System.currentTimeMillis() + time);
queue.offer(task);
synchronized (this) {
this.notify();
}
}
}上面的代码看起来已经很完备了，但是其实还有一个很严重的问题，这个问题和线程安全/随机调度有关。
我们考虑一个极端情况，假设代码执行到 `queue.put(myTask);` 这一行时，当前线程被CPU调度走。当线程回来之后，接下来就需要进行等待操作，此时等待时间已经计算好了。
例如，当前时间为19:30，任务执行时间为20:00，即将要等待30分钟。但是此时的wait还没有开始执行，而在这个时候，另一个线程调用了schedule方法，添加了一个新任务，新任务的执行时间为19:45。然后就会调用notify方法通知等待唤醒，但是令人遗憾的是，扫描线程的等待还没有开始执行，所以这里的notify通知是无效的，不会产生任何唤醒操作。
此时此刻，新的任务已经插入队列，并且位于队首，但是当前的等待时间仍然是30分钟，导致19:45的任务就被错过了。
在上面的说明中，我们可以发现问题出现的原因是：在take和wait的操作之间存在一个时间窗口，在这个时间窗口内，如果有新的任务被添加，那么扫描线程可能会错过这个新任务。
为了解决这个问题，我们需要确保take和wait的操作是原子的，即在执行这两个操作时，不允许有其他线程插入新的任务，在这里我们可以通过扩大锁的范围，来避免这个问题。
public MyTimer() {
t = new Thread(() -> {
while (true) {
try {
synchronized (this) {
//取出队首元素,判断当前任务是否到达时间
MyTask myTask = queue.take();
long curTime = System.currentTimeMillis();
if (curTime > myTask.getTime()) {
//未到达时间,放回队列中
queue.put(myTask);
this.wait(myTask.getTime() - curTime);
} else {
//到达时间,执行任务
myTask.run();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}好了，到这里实现自定义定时器代码已经结束了。
![数据结构（邓俊辉）学习笔记】串 06——KMP算法：构造next[]表](https://i-blog.csdnimg.cn/direct/760670d7639542358daf30b43405d110.png)
