【Java】实现一个自己的定时器

上文讲了怎样使用Java自带的定时器【Java】定时器的简单应用

这篇博客就来讲如何来编写一个自己实现的定时器

1、代码框架

由定时器的使用方法得知，我们在使用定时器的时候会添加一个任务timerTask类，而timer类则是我们行使任务的类，因此可以得出我们需要编写的两个对象：

一个timerTask类，一个timer类

首先写下代码框架

class SelfTimerTask{}class SelfTimer{}public class demo {public static void main(String[] args) {}
}

2、SelfTimeTask类

这个类型用以存放我们要执行的任务

（1）成员变量

任务类中有两个成员：一个是Runnable类，用来存放要执行任务的内容；一个是参数time，用来存放执行任务的时间

为了防止内存可见性问题或指令重排序问题，给这两个参数都加上volatile关键字

private volatile Runnable runnable;
private volatile long time;

（2）构造方法

接着我们需要给SelfTimerTask类写一个构造方法

注意：上面成员变量time指的是任务执行的绝对时间，而我们传进来的参数delay是任务执行的相对时间（即此刻时间到任务执行绝对时间的差）

任务执行的绝对时间 = 此刻时间 + 相对时间参数

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

（3）get方法

由于两个成员变量访问限制都为private，所以我们需要写两个get方法

public Runnable getRunnable() {return runnable;
}public long getTime() {return time;
}

（4）compareTo方法

因为在任务执行时，要通过比较任务的time参数来进行排序，因此我们需要添加compareTo方法使SelfTimerTask类具有可比性

首先让类继承Comparable类

class SelfTimerTask implements Comparable<SelfTimerTask>

接着，重写compareTo方法

public int compareTo(SelfTimerTask o) {return (int) (this.time - o.time);
}

注意：这里到底谁减谁要根据后面的需求定；可以根据调试来确定谁减谁

（5）SelfTimerTask完整代码

class SelfTimerTask implements Comparable<SelfTimerTask> {private volatile Runnable runnable;private volatile long time;public SelfTimerTask(Runnable runnable,long delay){this.runnable = runnable;this.time = delay + System.currentTimeMillis();}@Overridepublic int compareTo(SelfTimerTask o) {return (int) (this.time - o.time);}public Runnable getRunnable() {return runnable;}public long getTime() {return time;}
}

3、SelfTimer类

编写完SelfTimerTask类，我们来编写SelfTimer类

SelfTimer类是用以按照时间先后顺序执行存储在其中的多个SelfTimerTask类中的任务的，因此我们采用优先级队列的数据结构来编写SelfTimerTask类

定义一个优先级队列

PriorityQueue<SelfTimerTask> queue = new PriorityQueue<>();

（1）schedule()方法

根据Timer类的使用可知，SelfTimer有一个schedule()方法来添加任务

public void schedule(Runnable runnable,long time){SelfTimerTask task = new SelfTimerTask(runnable,time);queue.offer(task);
}

由于下面有其他方法也要对queue进行操作，为了线程安全，我们在成员变量里定义一个locker对象

Object locker = new Object();

并给添加任务这段代码加上锁

public void schedule(Runnable runnable,long time){SelfTimerTask task = new SelfTimerTask(runnable,time);synchronized (locker){queue.offer(task);locker.notify();}
}

（2）SelfTimer()方法

因为在用schedule()方法添加任务后，代码自动执行了任务，因此我们需要在构造方法里书写一个线程来执行任务

    public SelfTimer(){Thread thread = new Thread(()->{});thread.start();}

下面来完善线程内代码内容

因为需要不停地扫描任务是否到了执行时间，因此我们采用一个while循环

并且由于下面的代码对queue进行了操作，我们需要加锁来保证线程安全

public SelfTimer(){Thread thread = new Thread(()->{while (true){synchronized (locker){}}});thread.start();}

· 大根堆还是小根堆？

由于我们每次执行的是时间已经到达的任务，那么这个任务的time参数一定是最小的

每次需要获取time最小的任务进行操作，当然是选用小根堆

实现小根堆的方法就是重写类中的compareTo()方法，上文已经阐述过，这里不再赘述

· 队列为空？

如果队列为空，我们则需要进行阻塞，一直到队列非空为止

另一方面，为了防止线程是发生异常而被唤醒，我们采用while循环进行判断

while (queue.isEmpty()){try {locker.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}
}

· 执行任务

执行任务时，首先判断现在的时间是否已经到达任务执行时间

若已经到了，则执行任务；若没有到，就使任务再阻塞task.getTime()-curTime的时间

之所以选择阻塞，是因为若这时队列中添加进了一个执行时间更靠前的任务，可以唤醒对象重新开始循环

SelfTimerTask task = queue.peek();
long curTime = System.currentTimeMillis();
if (task.getTime() <= curTime){task.getRunnable().run();queue.poll();
}else {try {locker.wait(task.getTime()-curTime);} catch (InterruptedException e) {throw new RuntimeException(e);}
}

（3）SelfTimer完整代码

class SelfTimer{PriorityQueue<SelfTimerTask> queue = new PriorityQueue<>();Object locker = new Object();public void schedule(Runnable runnable,long time){SelfTimerTask task = new SelfTimerTask(runnable,time);synchronized (locker){queue.offer(task);locker.notify();}}public SelfTimer(){Thread thread = new Thread(()->{while (true){synchronized (locker){while (queue.isEmpty()){try {locker.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}SelfTimerTask task = queue.peek();long curTime = System.currentTimeMillis();if (task.getTime() <= curTime){task.getRunnable().run();queue.poll();}else {try {locker.wait(task.getTime()-curTime);} catch (InterruptedException e) {throw new RuntimeException(e);}}}}});thread.start();}
}

4、完整代码

import java.util.PriorityQueue;class SelfTimerTask implements Comparable<SelfTimerTask> {private volatile Runnable runnable;private volatile long time;public SelfTimerTask(Runnable runnable,long delay){this.runnable = runnable;this.time = delay + System.currentTimeMillis();}@Overridepublic int compareTo(SelfTimerTask o) {return (int) (this.time - o.time);}public Runnable getRunnable() {return runnable;}public long getTime() {return time;}
}class SelfTimer{PriorityQueue<SelfTimerTask> queue = new PriorityQueue<>();Object locker = new Object();public void schedule(Runnable runnable,long time){SelfTimerTask task = new SelfTimerTask(runnable,time);synchronized (locker){queue.offer(task);locker.notify();}}public SelfTimer(){Thread thread = new Thread(()->{while (true){synchronized (locker){while (queue.isEmpty()){try {locker.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}SelfTimerTask task = queue.peek();long curTime = System.currentTimeMillis();if (task.getTime() <= curTime){task.getRunnable().run();queue.poll();}else {try {locker.wait(task.getTime()-curTime);} catch (InterruptedException e) {throw new RuntimeException(e);}}}}});thread.start();}
}public class demo {public static void main(String[] args) {SelfTimer timer = new SelfTimer();timer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("3000");}},3000);timer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("2000");}},2000);timer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("1000");}},1000);}
}

运行结果