1. 前言
在生活中，我们肯定遇到过访问某个网站的时候或者加载视频的时候，出现请求超时的现象吧，如果客户端向服务器发送请求，但是没有得到响应该怎么办呢？难道要让我们死等吗？这肯定是不现实的，那么这时候就需要用到我们的定时器。客户端向服务器发送请求，如果超过一段时间没有得到响应，那么定时器就会决定是重新发送请求还是停止请求。在多线程案例中，定时器是一个比较复杂的案例，同时也是比较重要的一个多线程案例。今天我将为大家分享关于定时器知识的分享。
2. 如何使用Java标准库提供的定时器
在 Java 的 util 包下提供了定时器的实现，我们可以直接使用 Java 标准库提供的定时器。
import java.util.Timer; import java.util.TimerTask; public class Demo1 { public static void main(String[] args) { Timer timer = new Timer(); timer.schedule(new TimerTask() { @Override public void run() { System.out.println(3000); } },3000); timer.schedule(new TimerTask() { @Override public void run() { System.out.println(2000); } },2000); timer.schedule(new TimerTask() { @Override public void run() { System.out.println(1000); } },1000); System.out.println("定时器开始"); } }
- Timer 类表示定时器类
- 调用 Timer 类的 schedule 方法，将 TimerTask 类添加到定时器内
- TimerTask 类包括了该任务的具体实现内容，以及执行这个任务的时间
delay 表示从调用 schedule 方法开始的多长时间执行这个任务。不管哪个任务先添加的，总是按照时间的从小到大顺序执行。并且仔细观察我们可以发现，当执行完定时器当中的内容的时候，整个线程并没有结束，这是因为 Timer 内部的线程阻止了线程的结束。
3. 如何自己实现一个定时器
3.1 构建 MyTimerTask 任务类
虽然 Java 标准库为我们提供了定时器，但是我们作为初学者，还是需要知道他究竟是如何实现的，我们能自己实现一个计时器对理解定时器作用是非常大的。
class Mytimer { private long time; private Runnable runnable; public Mytimer(Runnable runnable, long delay) { this.runnable = runnable; this.time = System.currentTimeMillis() + delay; } public long getTime() { return this.time; } public Runnable getRunnable() { return this.runnable; } }
先创建一个 MyTimerTask 类用来描述任务的具体内容，包括执行的操作和执行的时间。
3.2 使用优先级队列来存储多个任务
当创建一个 MyTimerTask 类用来描述具体的内容之后，又该用什么来存储这多个 MyTimerTask 任务呢？因为它是按照时间的先后顺序执行的，时间近的任务优先级高，那么这样的话，我们就可以使用优先级队列这个数据结构来存储 MyTimerTask 类，并且创建的小根堆，时间最接近的放在堆顶。
PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
3.3 实现 schedule 方法来添加任务
当调用 schedule 方法的时候，就调用 PriorityQueue 的 offer 方法将任务添加到优先级队列中。
public void schedule(MyTimerTask myTimerTask) { queue.offer(myTimerTask); }
3.4 实现 Timer 类当中的扫描线程和具体细节
Timer 线程中需要一个扫描线程来看堆顶任务是否该执行了。当优先级队列为空的时候，需要该线程进入等待状态，直到调用 schedule 方法向队列中添加任务的时候才唤醒该线程。所以我们前面的 schedule 方法就需要稍作调整。
private static Object locker = new Object(); public void schedule(MyTimerTask myTimerTask) { synchronized (locker) { queue.offer(myTimerTask); locker.notify(); } } public MyTimer() { Thread t = new Thread(() -> { while (true) { try { synchronized (locker) { //通常线程被唤醒之后的判断不使用if， //而是使用while循环，因为唤醒线程的方法不止有notify //interrupt方法也可以唤醒处于等待状态的线程 //当处于等待状态的线程是因为interrupt方法唤醒的时候 //就说明没有执行schedule方法，此时queue中还是为空的 while (queue.isEmpty()) { locker.wait(); } } } catch (Exception e) { e.printStackTrace(); } } }); }
这里在调用 schedule 方法的好处不止有唤醒当堆为空时的等待状态，还有一些好处，我们在后面遇到的时候为大家讲解。
当堆不为空的时候，就要判断堆顶的任务是否到了需要执行的时间，如果到了需要执行的时间，就执行，没到则不需要做。
public MyTimer() { Thread t = new Thread(() -> { while (true) { try { synchronized (locker) { while (queue.isEmpty()) { locker.wait(); } MyTimerTask task = queue.peek(); if (curTime >= task.getTime()) { task.getRunnable().run(); queue.poll(); }else { ; } } } catch (Exception e) { e.printStackTrace(); } } }); t.start(); }
当我们运行这个计时器的时候，看看结果如何
import java.util.PriorityQueue; class MyTimerTask { private long time; private Runnable runnable; public MyTimerTask(Runnable runnable, long delay) { this.runnable = runnable; this.time = System.currentTimeMillis() + delay; } public long getTime() { return this.time; } public Runnable getRunnable() { return this.runnable; } } class MyTimer { PriorityQueue<MyTimerTask> queue = new PriorityQueue<>(); private static Object locker = new Object(); public void schedule(Runnable runnable, long delay) { synchronized (locker) { queue.offer(new MyTimerTask(runnable,delay)); locker.notify(); } } public MyTimer() { Thread t = new Thread(() -> { while (true) { try { synchronized (locker) { while (queue.isEmpty()) { locker.wait(); } MyTimerTask task = queue.peek(); long curTime = System.currentTimeMillis(); if (curTime >= task.getTime()) { task.getRunnable().run(); queue.poll(); }else { ; } } } catch (Exception e) { e.printStackTrace(); } } }); t.start(); } } public class Demo3 { public static void main(String[] args) { MyTimer myTimer = new MyTimer(); myTimer.schedule(new Runnable() { @Override public void run() { System.out.println(3000); } },3000); myTimer.schedule(new Runnable() { @Override public void run() { System.out.println(2000); } },2000); myTimer.schedule(new Runnable() { @Override public void run() { System.out.println(1000); } },1000); System.out.println("计时器开始"); } }
这里为什么会报错呢？
3.5 定时器的修改及优化
这里我们遗漏了一个细节，前面学习优先级队列的时候，我们知道优先级队列当中的元素必须是可比较的元素，跟 TreeMap 和 TreeSet 是一样的，但是 MyTimerTask 是一个类，类与类之间是不能够进行大小的比较的，所以我们需要重写 MyTimerTask 中的 compareTo 方法来指明比较方式。
class MyTimerTask implements Comparable<MyTimerTask>{ private long time; private Runnable runnable; public MyTimerTask(Runnable runnable, long delay) { this.runnable = runnable; this.time = System.currentTimeMillis() + delay; } public long getTime() { return this.time; } public Runnable getRunnable() { return this.runnable; } @Override public int compareTo(MyTimerTask o) { return (int) (this.time - o.time); } }
当进行这样的修改之后，堆中的元素就是可比较的了。写到这里其实功能就已经实现了，但是呢？还需要做出优化：当堆顶元素未到达执行时间的时候，难道真的什么都不用做吗？如果什么都不做的话，那么代码就会回到上面的while循环部分，继续判断堆顶元素是否到达了执行时间，因为计算机的执行速度很快，那么在这个到达执行堆顶元素任务的时间之内又进行了上万次判断，那么这种情况就叫做忙等。要想解决这个忙等问题，当判断未到达堆顶元素的执行时间的时候，我们让该线程等待一定的时间，不让这个线程继续循环判断。
public MyTimer() { Thread t = new Thread(() -> { while (true) { try { synchronized (locker) { while (queue.isEmpty()) { locker.wait(); } MyTimerTask task = queue.peek(); long curTime = System.currentTimeMillis(); if (curTime >= task.getTime()) { task.getRunnable().run(); queue.poll(); }else { locker.wait(task.getTime() - curTime); } } } catch (Exception e) { e.printStackTrace(); } } }); t.start(); }
到这里就可以说说前面 schedule 方法的 notify 方法的又一个好处：如果在 Timer 计时器在等待执行堆顶元素的过程中，又加入了一个任务，并且这个任务的执行时间先于之前堆顶元素任务的执行时间，那么当添加完成之后就会唤醒 Timer 计时器的等待状态，然后将这个刚加入的任务放入堆顶，并且下一个执行该任务。
4. 计时器完整代码
import java.util.PriorityQueue; class MyTimerTask implements Comparable<MyTimerTask>{ private long time; private Runnable runnable; public MyTimerTask(Runnable runnable, long delay) { this.runnable = runnable; this.time = System.currentTimeMillis() + delay; } public long getTime() { return this.time; } public Runnable getRunnable() { return this.runnable; } @Override public int compareTo(MyTimerTask o) { return (int) (this.time - o.time); } } class MyTimer { PriorityQueue<MyTimerTask> queue = new PriorityQueue<>(); private static Object locker = new Object(); public void schedule(Runnable runnable, long delay) { synchronized (locker) { queue.offer(new MyTimerTask(runnable,delay)); locker.notify(); } } public MyTimer() { Thread t = new Thread(() -> { while (true) { try { synchronized (locker) { while (queue.isEmpty()) { locker.wait(); } MyTimerTask task = queue.peek(); long curTime = System.currentTimeMillis(); if (curTime >= task.getTime()) { task.getRunnable().run(); queue.poll(); }else { locker.wait(task.getTime() - curTime); } } } catch (Exception e) { e.printStackTrace(); } } }); t.start(); } } public class Demo3 { public static void main(String[] args) { MyTimer myTimer = new MyTimer(); myTimer.schedule(new Runnable() { @Override public void run() { System.out.println(3000); } },3000); myTimer.schedule(new Runnable() { @Override public void run() { System.out.println(2000); } },2000); myTimer.schedule(new Runnable() { @Override public void run() { System.out.println(1000); } },1000); System.out.println("计时器开始"); } }
