【Java多线程】定时器Timer

标准库中的Timer

标准库中有一个Timer类，java.util.Timer，核心方法为schedule，schedule有两个参数，第一个参数为即将要执行的任务，第二个参数为多久后执行该任务（单位为毫秒），任务为new TimerTask()，TimerTask为抽象类，实现了Ruannable接口，具体看一下使用

java 复制代码

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

public class Demo {
    public static void main(String[] args) {
        //Timer内部是专门有线程来执行我们注册的任务,这个线程在执行完一个任务还会等待别的任务执行
        Timer timer = new Timer();
        //schedule(任务，多久后执行任务)
        //TimerTask是一个抽象类，实现了Runnable接口
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello timer");
            }
        }, 3000);

        System.out.println("main");
    }
}

运行结果：先打印出main，3秒之后打印hello Timer

上述代码执行完，发现程序没有结束，原因是Timer内部是专门有线程来执行我们注册的任务,这个线程在执行完一个任务还会等待别的任务执行

模拟实现Timer

通过上述标准库中的Timer分析Timer内部需要啥东西

描述任务：创建一个类专门表示定时器中的一个任务
组织任务：使用数据结构来组织
执行时间到了的任务：创建定时器实例时，创建一个线程专门来执行此任务

描述任务

下面组织任务用到了优先级队列，优先级队列必须插入可以比较大小的元素，所以这里的任务类就必须实现比较器接口Comparable并重写compareTo方法，使得可以通过时间来进行比较大小，定时器在使用的时候需要获取时间最小的任务的时间，以此时间戳和当前时间戳比较看是否可以执行任务，所以此处也要提供getTime方法

java 复制代码

//描述任务
class MyTask implements Comparable<MyTask>{
    //任务具体的内容
    private Runnable runnable;
    //任务执行的时间戳
    private long time;

    //delay为时间间隔，不是具体的时间戳
    public MyTask(Runnable runnable, long delay){
        this.runnable = runnable;
        this.time = System.currentTimeMillis()+delay;
    }

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

    public void run(){
        runnable.run();
    }


    public long getTime() {
        return time;
    }

}

组织任务

现在有多个任务，比如一个小时后做作业，半个小时后吃饭...，定时器在执行任务的时候，按照时间顺序先后顺序执行的，所以我们需要在安排的所有任务中找出距离要执行任务时间最短的任务，依次类推，不难得出，可以使用优先级队列这一数据结构来组织任务

注意: 此处的优先级队列要考虑线程安全问题，因为可能多个线程进行注册任务，还有一个专门的线程来执行任务，所以使用PriorityBlockingQueue

这里创建了一个对象用于加锁，具体原因在下面介绍

java 复制代码

    private PriorityBlockingQueue<MyTask> p = new PriorityBlockingQueue<>();
    //创建一个对象用于加锁
    private Object locker = new Object();
    public void schedule(Runnable runnable, long delay){
        MyTask task = new MyTask(runnable, delay);
        p.put(task);
        //插入任务，可能执行时间已经过了，需要唤醒等待的线程进行判断是否执行
        synchronized (locker){
            locker.notify();
        }
    }

执行时间到了的任务

需要有一个线程不停的检查优先级队列队头元素，判断该元素的执行时间是不是到了，所以在定时器的构造方法中创建一个线程来执行任务

java 复制代码

       public MyTimer(){
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    try {
                        MyTask task = p.take();
                        if(task.getTime() > System.currentTimeMillis()){
                            p.put(task);
                            //当执行时间没到时，没必要一直进行判断，比较耗费CPU
                            //所以等待一定时间
                            synchronized (locker){
                                locker.wait(task.getTime()-System.currentTimeMillis());
                            }
                        }else {
                            task.run();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();
    }

为何等待使用wait和notify，而不使用sleep？

在任务的执行时间未到之前，可能判断次数很多，比较耗费CPU，而且没有必要一值判断，只需在一定时间内进行判断执行时间到没到即可，所以在还没有到执行时间时，使用wait(时间)来让该线程进行等待，在创建任务时唤醒等待即可，因为新的任务可能需要在刚才等待执行任务之前执行，也就是新创建的任务执行时间已经到了，所以要使用notify唤醒执行任务的线程继续进行判断时间是否执行，而且这个原因也是使用wait不使用sleep的原因，如果使用sleep，在新创建任务的执行时间在sleep等待结束时间之前，等待的线程没有办法唤醒，也就不能执行时间到了的任务