定时器概念
当我们不需要某个线程立刻执行，而是在指定时间点或指定时间段之后执行，假如我们要定期清理数据库里的一些信息时，如果每次都手动清理的话就太麻烦，所以就可以使用定时器。定时器就可以比作一个闹钟，可以让我们的线程在指定的时间执行，还可以指定时间循环执行。
标准库中的定时器
在标准库中提供了一个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时间段后反复执行(如果时间点是已经过去的时间就会立刻执行)
定时器的使用
在指定时间段后执行
java
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设置成守护线程，此时整个线程就会结束了)
在指定时间点执行
java
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());
}
在指定时间段后定期循环执行
java
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());
}
在指定时间点后定期循环执行
java
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)，最后对比两个时间戳就知道现在是否要执行任务。
但是我们刚刚有提到，要使用优先级队列来存储任务，所以我们还要有一个任务的比较规则（我们要让队列知道该怎么比）
所以完整的代码如下：
java
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方法
java
private PriorityQueue<MytimerTask> queue = new PriorityQueue<>();
public void schedule(Runnable runnable,long time){
//向队列里插入一个任务，以及过多久后执行该任务
queue.offer(new MytimerTask(runnable,time));
}实现扫描线程
java
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方法应该这样实现
java
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的地方，使用阻塞版本的优先级队列，不方便实现。
完整代码如下
java
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();
}
}到这里一个简单的定时器就完成了
测试
java
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("启动程序");
}
以上就是博主对定时器知识的分享，如果有不懂的或者有其他见解的欢迎在下方评论或者私信博主，也希望多多支持博主之后和博客！！🥰🥰