????标准库中的定时器
- 标准库中提供了一个 Timer 类. Timer 类的核心方法为 schedule .
- schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后执行 (单位为毫秒).
import java.util.Timer;
import java.util.TimerTask;
public class Test {
public static void main(String[] args) {
Timer timer=new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("2s后执行");
}
},2000);
System.out.println("开始执行");
}
}这段程序就是创建一个定时器，然后提交一个2000s后执行的任务。
此处使用的是匿名内部类的写法，继承了TimerTask并且创建出了一个实例。这样的目的是为了重写run，通过run描述任务的详细情况。因为TimerTask是个抽象类本身是没有方法的，它存在的意义是继承，本个案例是实现接口Runnable里面的run方法。通过run方法描述任务的详细情况。
另一个参数是相对时间，当前安排的任务，啥时候执行，此处填写的时间，就是以当前时刻为基准，往后再推xxx的时间。
主线程执行schedule方法的时候，就是把这个任务放到timer对象中了，与此同时，timer里头也包含了一个线程，这个线程叫做“扫描线程”，一旦时间到，扫描线程就会执行刚才安排的任务了。仔细观察，可以发现，整个进程其实并没有结束，就是因为Timer内部的线程，阻止了进程结束。等下面实现定时器的时候，我们就可以知道为什么不结束了。
????自定义定时器
我们自己实现一个定时器的前提是我们需要弄清楚定时器都有什么:
Timer timer=new Timer();- Timer中需要有一个线程，扫描任务是否到时间，可以执行了。
- 需要有一个数据结构，把所有的任务都保存起来。
- 还需要创建一个类，通过类的对象来描述一个任务（至少要包含任务内容和时间）
创建一个扫描线程相对比较简单，我们需要确定一个数据结构来保存我们提交的任务，我们提交过来的任务，是由任务和时间组成的，我们需要构建一个TimeTask对象，数据结构我们这里使用优先级队列，因为我们的任务是有时间顺序的，具有一个优先级，并且要保证在多线程下是安全的，所以我们这里使用:PriorityQueue比较合适。因为Timer中添加的这些任务，都是带有一个“时间”，一定是时间小的先执行，最先执行的就是时间最小的任务，如果时间最小的任务还没到时间，其他任务更不会执行了。（优先级队列，可以使用O(1)时间，来获取到时间最小的任务）。
????构造Task类
????相对时间和绝对时间
//执行任务的时间（绝对时间） private long time;此时记录的是一个“绝对的时间"(完整的时间戳）。
- 绝对时间：当前具体的时间
- 相对时间：时间间隔
schedule方法里面的第二个参数是相对时间，为什么构造的时候记录绝对时间呢？
后续扫描线程的时候，如何判定当前这个任务是否要执行？
- 获取到当前的时间戳 14：00
- 再获取到任务要执行的时间戳 14：05
- 对比俩个时间戳（时间没有到，不能执行）
当前的时间戳是利用到 System.currentTimeMillis()方法，现在我写的时间是20:02，此时时间戳转换成时间就是绝对时间。我们再扫描线程的时候，我们比较的是 当前的时间戳和我要执行的时候的绝对时间，所以我们最好是记录绝对时间。
public MyTask(Runnable runnable,long delay){ this.time=System.currentTimeMillis()+delay; this.runnable=runnable; }构造方法中的俩个参数是 执行任务的对象以及相对时间。因为再调用schedule方法的时候传的第二个参数是相对时间。我们只需要将 相对时间+时间戳=绝对时间，就可以算出来。
比如现在是20:07的时候，调用的是schedule方法，执行delay是5分钟，那么再对应上面的 System.currentTimeMillis()就是14:00,delay是5分钟，那么绝对时间也就是要执行的时间是14:05分。
当我们创建好属性和获取当前的对象和时间的时候，我们再代码中还有一定的问题。
我们要想到，我们用优先级队列来保存任务，那么用到优先级队列，要求里面的元素务必是可以比较的。所以我们需要实现Comparable接口，继承compareTo方法。
@Override
public int compareTo(MyTask o) {
return (int)(this.time-o.time);
}由于返回类型是int类型，而时间戳返回类型是long类型，所以我们需要强制类型转换。
我们所创建的任务类里面的成员属性（任务对象和绝对时间）还有构造方法，以及比较方法。为下面的扫描线程铺垫。
????构造MyTime类
实现计时器，首先我们要创建一个优先级队列，里面包含的元素是执行的任务，然后实现schedule方法，再调用schedule方法的时候，就插入队列中，而里面的扫描线程应该放在构造方法中，因为我们再创建MyTime类的时候，线程就启动。
class MyTime{
PriorityQueue<MyTask>queue=new PriorityQueue<>();
public void schedule(Runnable runnable,long delay){
queue.offer(new MyTask(runnable,delay));//插入队列中
}
public MyTime(){
Thread thread=new Thread(()->{
while(true){
}
});
thread.start();//放在构造方法中，再创建对象的时候，就启用线程。
}
}继续完善代码，
????队列空和队列不为空
如果队列是空的话，我们就要阻塞等待，等到再调用schedule后插入任务的时候，我们就可以继续执行。我们就会联想到wait()和notify()方法。要想要用wait()就需要加锁。但是我们再上一篇的 阻塞队列中我们知道
wait()再执行的时候要经过三个步骤。
- 释放锁 ——》前提是先拿到锁
- 等待通知
- 通知到来之后，唤醒，重新获得锁
其实我们可以看到我们再创建对象的时候扫描线程启动，当我们调用schedule方法的时候，这也是一个线程再给队列添加元素，不同的线程，再对同一个队列操作，是肯定有线程安全问题的，所以不管使不使用wait()都是得加锁的。
public void schedule(Runnable runnable,long delay){
synchronized (this){
queue.offer(new MyTask(runnable,delay));
this.notify();//当插入任务后，我们就要唤醒线程
}
}
public MyTime(){
Thread thread=new Thread(()->{
while(true){
try {
synchronized (this){
while(queue.isEmpty()){
this.wait();//如果队列为空，我们就要阻塞等待(队列插入任务)
}
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
});
thread.start();
}如果队列不为空的情况下
首先我们需要获取当前堆顶的元素(也就是执行时间最先的一个），然后我们需要获取当前的绝对时间(就是你现在再看我的博客的时间），我们需要和任务类里面的time绝对时间（这里的绝对时间是我们要执行任务的时间）相比较，如果当前时间大于等于执行任务时间，那么我们就得执行该任务，执行完后从队列中删除，如果当前时间小于要执行任务的时间，我们就得不执行，等到时间到了为止。
class MyTime{
PriorityQueue<MyTask>queue=new PriorityQueue<>();
public void schedule(Runnable runnable,long delay){
synchronized (this){
queue.offer(new MyTask(runnable,delay));
this.notify();
}
}
public MyTime(){
Thread thread=new Thread(()->{
while(true){
try {
synchronized (this){
while(queue.isEmpty()){
this.wait();
}
MyTask myTask=queue.peek();//获取最先执行的任务(里面有任务对象和绝对时间）
long currentTime=System.currentTimeMillis();//获得当前时间
if(currentTime>=myTask.getTime()){
myTask.getRunnable().run();//执行这个任务
queue.poll();//删除堆顶元素
}else{
}
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
});
thread.start();
}
}????wait(带参)解决消耗资源问题
程序到这里还是有点问题的。
这个程序到这里，比如，我队列中有一个任务，是14：30执行，当时时刻是14:00（时间未到），当时间没到的时候，此处的循环，会快速循环很多次，相当于，时间没到，但是我在这不停的看表，本来这个时间是可以休息的，但是这个不停看表的动作，使我并没有休息~同时，也没有干活。忙等，确实再等，但是也消耗了很多cpu资源，因为没有到时间依旧进入循环。所以此处也加个wait，这里的wait，引入带参数的版本（带有超时时间），把时间间隔作为wait的等待时间了，14:00——14：30 ，此时wait就直接等30min就可以了。
this.wait(myTask.getTime()-System.currentTimeMillis());//执行任务时间-当前时间而且当任务时间没到的时候，就wiat阻塞（线程不会再cpu上调度，也就把cpu资源让出来给别人了）
????为什么使用wait,不使用sleep
但是为啥使用wait，不使用sleep行不行？ ——wait是更好的
可能在等待过程中，主线程调用schedule添加一个新的任务，新的任务是14:10执行，比刚才最早的任务还早，恰好使用刚才的schedule中的notify就可以唤醒这里的wait，让循环再执行一遍，重新拿到队首的元素(14:10),接下来wait的时间就更新成10min。
if(currentTime>=myTask.getTime()){
myTask.getRunnable().run();//执行这个任务
queue.poll();//队列中执行完了，删除堆顶元素
}else{
//当前时间还没到任务时间，暂时不执行任务，但是先啥都不干，等待下一轮的循环判定
this.wait(myTask.getTime()-System.currentTimeMillis());//执行任务时间-当前时间
}????为什么使用PriorityQueue(),不使用PriorityBlockingQueue()
为什么使用priorityQueue()，其实就是因为要处理俩个wait地方，如果使用阻塞版本的优先级队列，不方便实现这样的俩处等待。
用priorityQueue优先级队列时，一个notify()可以用到俩个wait()，入完任务之后，队列不为空，就唤醒，当最新任务时间还没到的时候，进入阻塞，新的任务来了之后，就唤醒一下，然后重新判定一下最早的任务是啥以及更新等待时间。（所以notify可以同时唤醒俩个wait()，因为入完队列俩个都得唤醒）
????测试
public class Test_Timer2 {
public static void main(String[] args) {
MyTimer myTimer=new MyTimer();
myTimer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("chenle");
}
},2000);
myTimer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("zyf");
}
},3000);
System.out.println("开始");
}
}