目录

一.定时器Timer类的主要方法

二.定时器Timer类的使用 

三.定时器的模拟实现

---

一.定时器Timer类的主要方法

定时器Timer类在java.util包中。

使用前先进行实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定指定的任务task在指定的延迟delay (ms)后运行。要安排的任务就是一个Runnable,定时器任务类TimerTask是抽象类，继承TimerTask并重写其run()方法，可实现要完成的任务。
schedule(TimerTask task, Date time)将指定的任务安排在指定的时间执行，如果时间是过去的时间，任务将被调度为立即执行。
cancel()方法结束这个定时器。
要实现一个定时任务，运用java中的Timer类和TimerTask类能够现实时调用处理函数。

二.定时器Timer类的使用 

 一个定时器,可以同时往里面安排多个任务

import java.util.Timer;
import java.util.TimerTask;

public class Demo3 {
    public static void main(String[] args) {
        Timer timer = new Timer();//先实例化一个对象

        timer.schedule(new TimerTask() {
            @Override
            public void run() {//重写run方法
                System.out.println("2.时间到,该写作业了");
            }
        },4000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("3.时间到,该吃饭了");
            }
        },5000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("1.时间到,该学习了");
            }
        },3000);
        System.out.println("开始计时");
    }
}

运行结果:

运行的顺序时按照延迟的时间来运行的

在第二个任务的run方法中加入cancel就会在当前正在执行的任务结束后,结束进程,不会再继续执行后面剩余的任务

    timer.schedule(new TimerTask() {
        @Override
        public void run() {//重写run方法
            System.out.println("2.时间到,该写作业了");
            timer.cancel();
        }
    },4000);

 运行结果:

三.定时器的模拟实现

 schedule的第一个参数是一个要执行的任务

需要描述这个任务就包含两个方面的信息,一个是要执行啥工作,另一个是啥时候执行

class MyTask {
    private Runnable runnable;//执行的任务
    private long time;//什么时候执行,是一个时间戳

    public MyTask(Runnable runnable,long delay){
        this.runnable = runnable;
        this.time = System.currentTimeMillis()+delay;
    }
}

Timer是能够安排多个任务的,而不同的任务执行的时间又不相同,就需要有一个存储空间来存储

如果使用ArrayList的话,里面的元素是无序的,每次安排进去一个新的任务就得进行一次查找当前最先执行的任务,需要耗费O(n)的时间,所以需要一个每次一拿就能拿到最先执行的任务,就需要使用优先级队列,但是优先级队列PriorityQueue是线程不安全的,而我们的schedule是可能在多线程当中进行调用,就可能会出现问题,而阻塞队列的线程是安全的,使用优先级阻塞队列能够完成这项工作

BlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();

 此时安排任务就是有序又线程安全的了

有了这个队列后就需要创建一个单独的线程不断地来进行扫描队首元素,查看时间是否到了,到了就执行任务,而阻塞队列无法阻塞的取队首元素,所以时间没到就得把任务给放回去

MyTask2里面还需要有两个get方法来让外面的程序拿到任务和时间

public Runnable getRunnable() {
    return runnable;
}

public long getTime() {
    return time;
}

还需要一个schedule方法来安排任务,将任务放进去队列当中去

class MyTimer2{
    private BlockingQueue<MyTask2> queue = new PriorityBlockingQueue<MyTask2>();

    public MyTimer2(){
        Thread t = new Thread(() -> {
            while(true) {
                try {
                    MyTask2 task2 = queue.take();//获取首任务
                    if (System.currentTimeMillis() >= task2.getTime()) {//当前运行时间和任务开始执行的时间进行对比
                        task2.getRunnable().run();//时间到了,开始执行任务
                    } else {//时间未到,放回队列
                        queue.put(task2);
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();//启动线程
    }
    public void schedule(Runnable runnable,long after) throws InterruptedException {
        MyTask2 myTask2 = new MyTask2(runnable,after);//创建一个新的任务
        queue.put(myTask2);//将任务放进队列
    }
}

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        MyTimer2 timer = new MyTimer2();
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("时间到!");
            }
        },5000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余1秒!");
            }
        },4000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余2秒!");
            }
        },3000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余3秒!");
            }
        },2000);

        System.out.println("开始计时!");
    }
}

此时运行程序的时候就会发现一个问题

 发生了类型转换异常,所以在MyTask2里面还需要一个比较器

    public int compareTo(MyTask2 o) {
        return (int) (this.time - o.time);//此处得判断是谁减谁,可以让程序运行一下就可以判断,还需要进行类型转换
    }

 运行结果:

 

 但此时程序严重的问题

即程序一直处于循环的等待,等待过程中光看时间,完全做不了别的事情,而看时间对整个任务的进程没啥影响,此时CPU并没有空闲出来,这个循环就是在忙等,那这里的等待就没有意义了

例如:

如果使用sleep方法的话并不太行,因为如果当前的时间是0:00而第一个任务的执行时间是2:00,此时需要sleep2个小时,然后在这个过程中加入了一个新的任务在1:00执行,但此时程序sleep了,该任务就会错过执行的时间,导致工作线程无法在1:00执行此任务

使用wait和notify就可以解决这个问题

class MyTimer2{
    private BlockingQueue<MyTask2> queue = new PriorityBlockingQueue<MyTask2>();
    public Object locker = new Object();

    public MyTimer2(){
        Thread t = new Thread(() -> {
            while(true) {
                try {
                    MyTask2 task2 = queue.take();
                    long curTime = System.currentTimeMillis();
                    if (curTime >= task2.getTime()) {//当前运行时间和任务开始执行的时间进行对比
                        task2.getRunnable().run();//时间到了,开始执行任务
                    } else {//时间未到,放回队列
                        queue.put(task2);
                        synchronized (locker){
                            locker.wait(task2.getTime() - curTime);
                        }
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();//启动线程
    }
    public void schedule(Runnable runnable,long after) throws InterruptedException {
        MyTask2 myTask2 = new MyTask2(runnable,after);//创建一个新的任务
        queue.put(myTask2);//将任务放进队列
        synchronized (locker){
            locker.notify();//当加入一个新的任务后,notify能够唤醒上方的wait,扫描线程将会重新获取首任务,再次判断
        }
    }
}

但该程序仍存在一个问题

 因为当前的环境是多线程的环境,所以如果扫描线程拿到首任务task2后,然后再wait等待之前,线程切换到了schedule线程,schedule线程新增一个新的任务,而当前新的任务执行时间是在上面所取到的task2之前,然后线程切换回MyTimer2,从刚刚的地方继续往下执行,然后就会进行wait等待task2开始执行的时间,一样会造成新任务没办法按时执行,该问题产生的原因就是因为操作不是原子的

 所以需要将上方第一把锁的范围扩大,读比等操作都在同一把锁里面

public MyTimer2(){
    Thread t = new Thread(() -> {
        while(true) {
            try {
                synchronized (locker){//将🔒的范围扩大
                    MyTask2 task2 = queue.take();
                    long curTime = System.currentTimeMillis();
                    if (curTime >= task2.getTime()) {//当前运行时间和任务开始执行的时间进行对比
                        task2.getRunnable().run();//时间到了,开始执行任务
                    } else {//时间未到,放回队列
                        queue.put(task2);
                        locker.wait(task2.getTime() - curTime);
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
    t.start();
}

此时将锁的范围扩大后就可以避免了notify在take和wait之间执行,扫描线程会先拿到锁,然后take,然后中间逻辑,一直到wait

在这个过程中,schedule线程会阻塞等待锁,直到扫描线程执行到了wait之后,扫描线程释放了锁schedule线程就拿到了锁,新增任务后,notify通知,wait就被立刻唤醒了,接下来重新获取队首元素,就把新增的任务取出来了

完整代码

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;

class MyTask2 implements Comparable<MyTask2>{
    private Runnable runnable;
    private long time;

    public MyTask2(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(MyTask2 o) {
        return (int) (this.time - o.time);
    }
}

class MyTimer2{
    private BlockingQueue<MyTask2> queue = new PriorityBlockingQueue<MyTask2>();
    public Object locker = new Object();

    public MyTimer2(){
        Thread t = new Thread(() -> {
            while(true) {
                try {
                    synchronized (locker){
                        MyTask2 task2 = queue.take();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task2.getTime()) {//当前运行时间和任务开始执行的时间进行对比
                            task2.getRunnable().run();//时间到了,开始执行任务
                        } else {//时间未到,放回队列
                            queue.put(task2);
                            locker.wait(task2.getTime() - curTime);
                        }
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
    }
    public void schedule(Runnable runnable,long after) throws InterruptedException {
        MyTask2 myTask2 = new MyTask2(runnable,after);//创建一个新的任务
        queue.put(myTask2);//将任务放进队列
        synchronized (locker){
            locker.notify();
        }
    }
}

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        MyTimer2 timer = new MyTimer2();
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("时间到!");
            }
        },5000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余1秒!");
            }
        },4000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余2秒!");
            }
        },3000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余3秒!");
            }
        },2000);

        System.out.println("开始计时!");
    }
}