🚩标准库中的定时器

• 标准库中提供了一个 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类

  @Override
    public int compareTo(MyTask o) {
        return (int)(this.time-o.time);
    }

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("开始");
    }
}