定时器是什么
定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定
好的代码.
定时器是一种实际开发中非常常用的组件.
比如在浏览器访问某个网站时网卡了，浏览器就会转圈圈(阻塞等待)，这个等待不是无限的等待，到达一定时间以后，就显示超时访问
再比如在前端开发中网站上的动画效果，也是通过定时器实现的，比如每隔30ms，把页面往下滚动几个像素
标准库中的定时器
- 标准库中提供了一个 Timer 类. Timer 类的核心方法为 schedule .
- schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后
- 执行 (单位为毫秒).
System.out.println("代码开始执行"); Timer timer=new Timer(); //此处的TimerTask与Runnable功能相同，都是执行任务的代码 timer.schedule(new TimerTask() { @Override public void run() { System.out.println("触发定时器！"); } },3000); // 代码开始执行 触发定时器！
实现定时器
定时器的构成:
- （1）队列中的每个元素是一个 Task 对象，Task中带有一个时间属性和一个Runnable任务属性
- （2）一个带优先级的阻塞队列
为啥要带优先级呢?
因为阻塞队列中的任务都有各自的执行时刻 (delay). 最先执行的任务一定是 delay 最小的. 使用带
优先级的队列就可以高效的把这个 delay 最小的任务找出来,使用带有阻塞功能的优先队列用以维护线程安全
- （3）一个schedule方法，该方法用于往队列中插入元素
- （4）一个扫描线程不断去扫描队首元素，看看队首元素是不是已经到点了，如果到点就执行这个任务，如果没有到点，就把这个队首元素塞回队列中，继续扫描
1）Task类用于描述一个任务，里面包含一个Runnable对象和一个time（毫秒时间戳）
这个对象需要放到优先队列中，因此需要实现Comparable接口
//这个类表示一个任务 class MyTask implements Comparable<MyTask> { //要执行的任务 private Runnable runnable; //什么时间来执行任务 private long time; public MyTask(Runnable runnable,long delay) { this.runnable=runnable; this.time=System.currentTimeMillis()+delay; } public Runnable getRunnable() { return runnable; } public long getTime() { return time; } @Override public int compareTo(MyTask o) { return (int)(this.time-o.time); } //此处注意谁减谁如果不确定，可以换一下试试 }
2）MyTimer 实例中, 通过 PriorityBlockingQueue （优先级阻塞队列）来组织若干个 MyTask 对象. 通过 schedule 来往队列中插入一个个 Task 对象.
在实例化Timer类时，启动扫描线程
class MyTimer { private BlockingQueue<MyTask> queue=new PriorityBlockingQueue<>(); public void schedule(Runnable runnable,long after) throws InterruptedException { MyTask myTask=new MyTask(runnable,after); queue.put(myTask); } public MyTimer() { //创建一个扫描线程 Thread t=new Thread(()-> { while (true) { //取出队首元素 try { //取出队首元素 MyTask task=queue.take(); long curTime=System.currentTimeMillis(); if(curTime>=task.getTime()) { //到时间执行任务 task.getRunnable().run(); } else { //没有到时间就进行等待 queue.put(task); } } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); } }
在这段代码中我们会发现一个问题，就是线程扫描的速度太快了 【while (true) 】转的太快了, 造成了无意义的 CPU 浪费
比如第一个任务设定的是 1 min 之后执行某个逻辑. 但是这里的 while (true) 会导致每秒钟访问队首元素几万次. 而当前距离任务执行的时间还有很久呢.
3）通过让线程等待一定时间，来解决忙等问题
因为wait、notify必须搭配synchronized来使用，所以需要实例化一个Object类作为锁对象，让多个线程竞争同一把锁。
如果从队首取出的任务时间还没有到，就重新放回队列，并让线程等待（wait）一段时间，时间长短由任务时间与当前时间差决定。
当有新任务放入队列中时，需要重新唤醒线程，再次判断优先级阻塞队列的队首元素是否已经到达了执行时间。
注意：
线程进行等待时为什么用wait而不用sleep，因为使用wait可以指定一个时间作为参数（可以通过当前时刻和任务开始时之间的时间间隔来算）
而且wait能够使用notify提前唤醒，如果插入新任务比上一个任务执行时间早，就需要提前唤醒线程，如果使用sleep则无法唤醒线程。
4）防止空打一炮
在修改过3的代码后如下，仍然存在一些问题
//这个类表示一个任务 class MyTask implements Comparable<MyTask> { //要执行的任务 private Runnable runnable; //什么时间来执行任务 private long time; public MyTask(Runnable runnable,long delay) { this.runnable=runnable; this.time=System.currentTimeMillis()+delay; } public Runnable getRunnable() { return runnable; } public long getTime() { return time; } @Override public int compareTo(MyTask o) { return (int)(this.time-o.time); } } class MyTimer { private BlockingQueue<MyTask> queue=new PriorityBlockingQueue<>(); //使用locker对象来解决忙等问题 private Object locker=new Object(); public void schedule(Runnable runnable,long after) throws InterruptedException { MyTask myTask=new MyTask(runnable,after); queue.put(myTask); //每次插入新的任务都要唤醒扫描线程，让扫描线程能够重新计算wait的时间，保证新的任务也不会错过 synchronized (locker) { locker.notify(); } } public MyTimer() { //创建一个扫描线程 Thread t=new Thread(()-> { while (true) { //取出队首元素 try { //取出队首元素 MyTask task=queue.take(); long curTime=System.currentTimeMillis(); if(curTime>=task.getTime()) { //到时间执行任务 task.getRunnable().run(); } else { //没有到时间就再放回队列 queue.put(task); //根据时间差进行等待 synchronized (locker) { locker.wait(task.getTime()-curTime); } } } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); } }
由于在扫描线程中，take()操作与wait()操作也是非原子的，如果刚新取出队首元素后，线程又被安排了一个新的任务，此时在扫描线程中得到的时间还是之前取出的任务的时间，如果按照那个时间去进行等待，就有可能导致新安排进来的任务被错过。
为了解决上述的问题，需要在扫描线程中加大锁的范围，使得take操作与wait操作是原子的。
更改后的完整代码见5）
5）完整代码
import java.util.concurrent.BlockingQueue; import java.util.concurrent.PriorityBlockingQueue; //这个类表示一个任务 class MyTask implements Comparable<MyTask> { //要执行的任务 private Runnable runnable; //什么时间来执行任务 private long time; public MyTask(Runnable runnable,long delay) { this.runnable=runnable; this.time=System.currentTimeMillis()+delay; } public Runnable getRunnable() { return runnable; } public long getTime() { return time; } @Override public int compareTo(MyTask o) { return (int)(this.time-o.time); } } class MyTimer { private BlockingQueue<MyTask> queue=new PriorityBlockingQueue<>(); //使用locker对象来解决忙等问题 private Object locker=new Object(); public void schedule(Runnable runnable,long after) throws InterruptedException { MyTask myTask=new MyTask(runnable,after); queue.put(myTask); //每次插入新的任务都要唤醒扫描线程，让扫描线程能够重新计算wait的时间，保证新的任务也不会错过 synchronized (locker) { locker.notify(); } } public MyTimer() { //创建一个扫描线程 Thread t=new Thread(()-> { while (true) { //取出队首元素 try { synchronized (locker) { //取出队首元素 MyTask task=queue.take(); long curTime=System.currentTimeMillis(); if(curTime>=task.getTime()) { //到时间执行任务 task.getRunnable().run(); } else { //没有到时间就再放回队列 queue.put(task); //根据时间差进行等待 locker.wait(task.getTime()-curTime); } } } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); } } public class Demo { public static void main(String[] args) throws InterruptedException { MyTimer timer=new MyTimer(); timer.schedule(new Runnable() { @Override public void run() { System.out.println("时间到1！"); } },3000); timer.schedule(new Runnable() { @Override public void run() { System.out.println("时间到2！"); } },4000); timer.schedule(new Runnable() { @Override public void run() { System.out.println("时间到3！"); } },5000); System.out.println("开始计时！"); } }
