定时器和Timer

♫什么是定时器

定时器是一种计时设备，通过定时器可以让某段代码达到设定的时间后再执行。定时器是一个常用的组件，如在进行网络编程时就常用定时器来定时重发数据包、定时检测网络连接状态、定时更新缓存等操作。

♫实现一个定时器

定时器需要有一个优先级的阻塞队列（定时器每次都先执行时间小的，按照时间小的作为优先级）来存储待执行的任务，还需要一有个扫描线程一直扫描队首元素，来判定到没到和执行任务的时间。

注：此处的优先级队列会在多线程环境下使用，需要考虑线程安全问题，故可以使用标准库提供的线程安全的阻塞队列：PriorityBlockingQueue

使用 MyTimer 类用来描述定时器，MyTimer 类的属性包括一个优先级队列和一个扫描线程：

public class MyTimer {
    //扫描线程
    private Thread t = null;
    //带有优先级的阻塞队列，用来存储任务
    private PriorityBlockingQueue<MyTask> queue = null;
}

还需要有一个 MyTask 类用于描述一个任务 ( 作为  MyTimer 的内部类 )， 里面包含一个  Runnable 对象（描述任务执行的内容）和一个 time( 毫秒时间戳来描述任务执行的时刻)，由于这个对象需要放到优先队列中， 因此需要实现 Comparable 接口或使用 Comparator 接口单独写个比较器：

    class MyTask implements Comparable<MyTask> {
        //要执行的任务内容
        private Runnable runnable;
        //执行的时刻
        private long time;

        public MyTask(Runnable runnable, long time) {
            this.runnable = runnable;
            this.time = time;
        }
        //获取当前任务的时间
        public long getTime() {
            return time;
        }
        //执行任务
        public void run() {
            runnable.run();
        }

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

MyTimer 类提供一个 schedule 方法，用于注册一个任务，并指定这个任务多长时间后执行：

  //添加任务
  public void schedule(Runnable runnable, long after) {
        MyTask myTask = new MyTask(runnable, System.currentTimeMillis() + after);
        queue.put(myTask);
    }

在 MyTimer 的构造方法里不断判断任务是否开始执行：

//在构造方法中扫描线程
    public MyTimer() {
        t = new Thread(() -> {
            while (true) {
                try {
                    MyTask myTask = queue.take();
                    long time = System.currentTimeMillis();
                    if (time < myTask.getTime()) {
                        queue.put(myTask);
                    } else {
                        myTask.run();
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }

但是当前这个代码中存在一个严重的问题，就是 while (true) 转的太快了，造成了无意义的 CPU 浪费，我们可以使用 wait 和 notify 使任务进入阻塞等待，指定一定 wait 时间，时间到或有新任务（可能执行时间比当前任务靠前），则通过 notify 唤醒：

    //添加任务
    public void schedule(Runnable runnable, long after) {
        MyTask myTask = new MyTask(runnable, System.currentTimeMillis() + after);
        queue.put(myTask);
        synchronized (this) {
            this.notify();
        }
    }

    //在构造方法中扫描线程
    public MyTimer() {
        t = new Thread(() -> {
            while (true) {
                try {
                    MyTask myTask = queue.take();
                    long time = System.currentTimeMillis();
                    if (time < myTask.getTime()) {
                        queue.put(myTask);
                        synchronized (this) {
                            this.wait(myTask.getTime() - time);
                        }
                    } else {
                        myTask.run();
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }

此时虽然解决了“忙等”的问题，但还有一个线程安全的问题：如果线程1运行到 this.wait(myTask.getTime() - time) 之前刚好被调度去其他线程执行添加新的任务操作，之后再调度到线程1执行wait操作，即先执行了 schedule() 里的 notify 后再执行构造方法里的 wait ，此时如果新添加的任务的执行时间更靠前仍不能提前唤醒线程1，就会有问题。上述问题是由于取堆顶元素和wait操作不是原子性的，故需要通过synchronized保证原子性：

    //在构造方法中扫描线程
    public MyTimer() {
        t = new Thread(() -> {
            while (true) {
                try {
                    synchronized (this) {
                        MyTask myTask = queue.take();
                        long time = System.currentTimeMillis();
                        if (time < myTask.getTime()) {
                            queue.put(myTask);
                            this.wait(myTask.getTime() - time);
                        } else {
                            myTask.run();
                        }
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }

♫Timer

Timer是标准库中的定时器。 Timer 类的核心方法为 schedule，schedule 包含两个参数：   第一个参数指定即将要执行的任务代码， 第二个参数指定多长时间之后执行 ( 单位为毫秒 )：

public class Test {
    public static void main(String[] args) {
        Timer timer = new Timer();
        //1000ms后打印A
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("A");
            }
        }, 1000);
        //2000ms后打印B
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("B");
            }
        }, 2000);
        //3000ms后打印C
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("C");
            }
        }, 3000);
    }
}

运行结果：

注：TimerTask实现了Runnable接口，TimerTask就是对Runnable的进一步封装