《javaEE篇》--定时器

定时器概念

当我们不需要某个线程立刻执行，而是在指定时间点或指定时间段之后执行，假如我们要定期清理数据库里的一些信息时，如果每次都手动清理的话就太麻烦，所以就可以使用定时器。定时器就可以比作一个闹钟，可以让我们的线程在指定的时间执行，还可以指定时间循环执行。

标准库中的定时器

在标准库中提供了一个Timer类，Timer是一种定时器工具，可以让一个线程在指定时间一次或反复执行。

Timer的构造方法

Timer()
Timer(String name)	设定定时器的名字
Timer(boolean isDeamon)	是否将定时器作为守护线程
Timer(String name,boolean isDeamon)	设定定时器名字，并设定是否为守护线程执行

非守护线程：JVM会等待所有非守护线程执行完毕之后才会退出

守护线程：JVM不会等待守护线程执行完毕，当没有非守护线程在执行JVM就会关闭，即使有守护线程在执行

TimerTask是一个抽象类，表示的是一个可以被timer执行的任务，任务的具体实现在TimerTask的run方法里。

schedule方法是Timer中的核心方法用来执行TimerTask的任务并设定时间，具体的参数有以下几种

schedule(TimerTask task，Date time);

在time时间(时间点)执行任务一次

schedule(TimerTask task，long delay);

在delay时间后执行任务一次(单位毫秒)

schedule(TimerTask task，Date firstTime，long period);

在firstTime时间点执行一次任务，在定期的period时间段后反复执行(如果时间点是已经过去的时间就会立刻执行)

schedule(TimerTask task，long delay，long period);

在延迟delay毫秒后执行任务一次，在定期的period时间段后反复执行(如果时间点是已经过去的时间就会立刻执行)

定时器的使用

在指定时间段后执行

public static void main(String[] args) {
        Timer timer = new Timer();//对象被创建时，线程也跟着被创建，后续timer执行任务都是由这个线程执行
        //给定时器安排一个任务，xxxms后执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("开始执行定时器任务");
            }
        },1000);
        System.out.println("执行任务");
    }

主线程执行schedule方法的时候，就是把这个任务放到timer对象中了，与此同时timer里头也有一个线程叫做“扫描线程”，一旦时间到扫描线程就会执行刚才安排的任务了，仔细观察可以发现，整个线程，其实没有结束，就是因为Timer内部的线程阻止了进程的结束，而且在timer里是可以安排多个任务的，这些任务会按照时间顺序执行。(也就是我们刚刚说过的非守护线程，给timer设置成守护线程，此时整个线程就会结束了)

在指定时间点执行

 public static void main(String[] args) {
        Timer timer = new Timer();//对象被创建时，线程也跟着被创建，后续timer执行任务都是由这个线程执行
        //给定时器安排一个任务，xxxms后执行

        //获取5秒后的一个时间点：doTime
        Calendar cal=Calendar.getInstance();
        cal.add(Calendar.SECOND,5);
        Date doTime=cal.getTime();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("开始执行定时器任务" + new Date());
            }
        },doTime);
        System.out.println(new Date());
    }

在指定时间段后定期循环执行

public static void main(String[] args) {
        Timer timer = new Timer();//对象被创建时，线程也跟着被创建，后续timer执行任务都是由这个线程执行
        //给定时器安排一个任务，xxxms后执行

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("开始执行定时器任务" + new Date());
            }
        },2000,1000);
        System.out.println(new Date());
    }

在指定时间点后定期循环执行

public static void main(String[] args) {
        Timer timer = new Timer();//对象被创建时，线程也跟着被创建，后续timer执行任务都是由这个线程执行
        //给定时器安排一个任务，xxxms后执行

        //获取5秒后的一个时间点：doTime
        Calendar cal=Calendar.getInstance();
        cal.add(Calendar.SECOND,5);
        Date doTime=cal.getTime();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("开始执行定时器任务" + new Date());
            }
        },doTime,1000);
        System.out.println(new Date());
    }

定时器的实现

这里我们来简单实现一个定时器

初步分析

Timer中要有一个扫描线程线程，扫描任务是否到时间可以执行了
需要一种数据结构来储存这些任务
还需要创建一个类来描述一个任务，要包含内容和时间

先来考虑使用什么数据结构来储存任务，既然Timer中的任务是从时间最小的开始执行，那么我们就可以使用优先级队列！！

实现

MyTimerTask

一个执行的任务至少要包含任务内容和执行的时间，这里我用的是绝对时间当要判断一个线程是否需要执行时，先获取一个当前的时间戳(2:30)，在获取任务要执行的时间戳(2:35)，最后对比两个时间戳就知道现在是否要执行任务。

但是我们刚刚有提到，要使用优先级队列来存储任务，所以我们还要有一个任务的比较规则（我们要让队列知道该怎么比）

所以完整的代码如下：

class MytimerTask implements Comparable<MytimerTask>{
    //要执行的任务
    private Runnable runnable;
    //要执行任务的绝对时间
    private long time;
    public MytimerTask(Runnable runnable,long time){
        this.runnable = runnable;
        //此处this.time是应该开始执行任务的时间，time是多久后执行
        this.time = System.currentTimeMillis() + time;
    }
    //任务的比较规则
    @Override
    public int compareTo(MytimerTask o) {
        return (int)(this.time - o.time);
    }

    public Runnable getRunnable() {
        return runnable;
    }

    public long getTime() {
        return this.time;
    }
}

MyTimer

定义一个优先级队列，实现schedule方法

 private PriorityQueue<MytimerTask> queue = new PriorityQueue<>();

    public void schedule(Runnable runnable,long time){  
            //向队列里插入一个任务，以及过多久后执行该任务
            queue.offer(new MytimerTask(runnable,time));
    }

实现扫描线程

private Object locker = new Object();
    public MyTimer(){
        //创建一个扫描线程
        Thread t = new Thread(() -> {
            //扫描线程，需要不停扫描队首元素，看是否到达时间
            while (true){
                 try {
                     synchronized (locker){
                         //使用while是为了在wait被唤醒的时候，再次确认一下条件
                         while (queue.isEmpty()){
                             //这里的wait，需要有另外线程唤醒
                             //添加新的任务就应该唤醒
                             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 (InterruptedException e){
                     e.printStackTrace();
                     break;
                 }
            }
        });
        t.start();
    }

因为我们需要不断的判断队列里的线程是否到达时间，所以使用while循环

因为当前可能会是在多线程下使用，所以我们要保证线程安全问题，使用synchronization来进行加锁

如果队列为空的话，就需要阻塞等待直到有新的任务加入，所以schedule方法应该这样实现

public void schedule(Runnable runnable,long time){
        synchronized (locker){
            //向队列里插入一个任务，以及过多久后执行该任务
            queue.offer(new MytimerTask(runnable,time));
            //当队列为空时，此时插入一个任务之后唤醒wait
            locker.notify();
        }
    }

这里还有一个问题，因为while的执行速度很快，如果让他一直不断的循环，就会造成忙等问题(在消耗cpu资源但是并没有实质性的用处)，假如最近一个要执行的任务是十分钟之后，那么从现在开始的十分钟之内，while是没有执行的必要的，不停的循环只会浪费资源。

所以我们可以进行判断，当还没有到最近一个任务执行时间时，我们就让线程阻塞，阻塞的时间就是现在到最近一个要执行的任务的时间，这样就可以解决忙等问题。

那么可不可以使用sleep呢？当然是不行的。

可能在等待过程中主线程调用schedule又添加一个新任务，这个任务比其他任务执行的时间更早，使用wait就恰好可以利用刚才schedule中的notify来唤醒这里的wait，让循环再执行一遍，重新拿到队首执行时间最少的任务

之所以刚刚的代码使用的是PriorityQueue而不是PriorityBlockingQueue，其实就是因为要处理两个wait的地方，使用阻塞版本的优先级队列，不方便实现。

完整代码如下

class MytimerTask implements Comparable<MytimerTask>{
    //要执行的任务
    private Runnable runnable;
    //要执行任务的绝对时间
    private long time;
    public MytimerTask(Runnable runnable,long time){
        this.runnable = runnable;
        //此处this.time是应该开始执行任务的时间，time是多久后执行
        this.time = System.currentTimeMillis() + time;
    }
    //任务的比较规则
    @Override
    public int compareTo(MytimerTask o) {
        return (int)(this.time - o.time);
    }

    public Runnable getRunnable() {
        return runnable;
    }

    public long getTime() {
        return this.time;
    }
}
//自己的定时器
class MyTimer{
    private PriorityQueue<MytimerTask> queue = new PriorityQueue<>();

    public void schedule(Runnable runnable,long time){
        synchronized (locker){
            //向队列里插入一个任务，以及过多久后执行该任务
            queue.offer(new MytimerTask(runnable,time));
            //当队列为空时，此时插入一个任务之后唤醒wait
            locker.notify();
        }
    }
    private Object locker = new Object();
    public MyTimer(){
        //创建一个扫描线程
        Thread t = new Thread(() -> {
            //扫描线程，需要不停扫描队首元素，看是否到达时间
            while (true){
                //开始进行一次扫描
                 try {
                     synchronized (locker){
                         //使用while是为了在wait被唤醒的时候，再次确认一下条件
                         while (queue.isEmpty()){
                             //这里的wait，需要有另外线程唤醒
                             //添加新的任务就应该唤醒
                             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 (InterruptedException e){
                     e.printStackTrace();
                     break;
                 }
            }
        });
        t.start();
    }
}

到这里一个简单的定时器就完成了

测试

  public static void main(String[] args) {
        MyTimer timer = new MyTimer();
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("3000" + new Date());
            }
        },3000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("2000"+ new Date());
            }
        },2000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("1000"+ new Date());
            }
        },1000);
        System.out.println("启动程序");
    }