1.定时器是什么
定时器是软件开发中的一个重要组件,功能是当达到一个特定的时间后,就执行某个指定好的代码
定时器是一个非常常用的组件,特别是在网络编程中,当出现了"连接不上,卡了"的情况,就使用定时器做一些操作来止损
标准库中也提供了定时器
标准库中的Timer类
标准库提供了一个Timer类,Timer类的核心方法为schedule(安排，预定；将……列入计划表或清单)
schedule包含两个参数
第一个参数指定即将要执行的任务代码
第二个参数指定多多长时间之后执行(单位ms)
下面是用一下定时器
可以看到有两个参数
TimerTask类就是一个实现了Runnable接口的类,来描述指定的任务
delay是指定的时间后执行任务!
运行程序,经过指定的时间后,执行了run()中的语句
2.实现定时器
定时器的核心
注册任务后需要保证任务在指定的时间要被执行
单独在定时器内部,创建一个线程,让这个线程周期性的扫描,判定任务是否到时间了,如果到时间了就执行,没到就继续等待
一个定时器能连续注册N个任务,N个任务是按照最初约定的时间按顺序执行
这N个任务肯定需要一种数据结构来保存,不难发现,我们可以使用优先级队列,我们每个任务都是带有时间的,按照时间小的作为优先级高的,此时队首元素一定是最先要执行的任务,这时候扫描线程也只需要扫描队首元素即可,不必扫描整个队.如果队首元素没有到执行时间,那么其它元素也不可能到达执行时间!!
简而言之,定时器的核心:
1.有一个扫描线程,判断是否到执行时间.
2.还得有一个数据结构保存被注册的任务.
此处优先级队列是在多线程环境下使用的,因此要关注线程安全问题!自己手动加锁,或者使用标准库提供的PriorityBlockingQueue,它既有优先级又符合线程安全的要求
实现代码
我们先创建一个任务类
class MyTask{
//任务内容
private Runnable runnable;
//任务指定的时间(ms时间戳表示)
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();
}
队列里的"任务"使用Runnable表示,描述的是任务的内容
使用时间戳描述任务什么时候被执行
然后创建一个定时器
class MyTimer{
//扫描线程
private Thread t = null;
//阻塞优先级队列来保存任务
private PriorityBlockingQueue<MyTask> queue =
new PriorityBlockingQueue<>();
}
我们要给定时器类提供一个"schedule"方法来注册任务
//指定两个参数,一个是任务内容,一个是多长时间后执行任务
public void schedule(Runnable runnable,long after){
//注意时间的换算
MyTask myTask = new MyTask(runnable,System.currentTimeMillis()+after);
queue.put(myTask);
}
接下来要实现一个比较麻烦的操作,就是扫描线程的实现
public MyTimer(){
t = new Thread(()->{
while (true){
try {
//取出队首元素,检查是否到执行时间了
//如果到了,就执行
//如果没到,就放回队列
//如果没有元素证明没有任务,会阻塞等待
MyTask myTask = queue.take();
long curTime = System.currentTimeMillis();
if(curTime < myTask.getTime()){
//没到点,不用执行
//到点了,开始执行
queue.put(myTask);
}else{
myTask.run();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
}
上述代码大致实现了扫描线程的功能,但是还存在两个问题
第一个问题,我们还要明确我们的任务优先级是怎样的,还没指定
此时我们如果测试:
public static void main(String[] args) {
MyTimer timer = new MyTimer();
timer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("任务1");
}
},1000);
timer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("任务2");
}
},2000);
}
因为两个任务的优先级关系还没用comparable来设置,或者单独实现一个比较器comparator
运行程序
第二个问题,如果队首任务是四点进行执行,在两点的时候,线程开始扫描,就会一直从队首取出检查,发现没到执行时间,又放回去,反反复复!!直到四点开始执行.我们使用优先级队列来存储的,放回元素,堆就会进行一次调整,将这个任务又调整至队首,下次取出,还是这个元素!
这个循环没有阻塞,会快速的进行循环,是没有意义的,占用了cpu资源.这种情况称为"忙等”,我们要对代码进行调整,进行阻塞式等待,sleep,wait..
如果等待时间明确,我们使用sleep可行吗?
此处看似等待时间是明确的,但是我们可能任意时间会来一个新的任务调用schedule,注册任务,那么队首元素就换了,必须得扫描出来.
如果用sleep,那么在sleep过程中就可能注册新的任务,如果在队首元素执行的时间前就要执行新注册的任务,然而用的sleep,就会错过这个任务的执行了
因此使用wait()notify()更合适,使用wait()进行等待,如果有新任务调用schedule,就notify(),重新检查一次,计算等待的时间
并且,wait()还有个超时时间的版本,如果没有新任务,则最多等到队首元素的执行时间就自动唤醒了
这样改动之后,我们既不会一直重复无用操作,也不会错过执行新注册任务
线程安全问题
代码到这里,还有个线程安全问题
我们考虑一个极端情况
如果代码执行到wait之前,这个线程被调度走了,当线程又被调度执行时,接下来就要进行wait操作,它的wait时间是算好了的,比如curTime是13:00,getTime是14:00,即将会wait一个小时,但是还没执行wait.
在该线程被调度走的过程中,如果另一个线程调用了schedule,注册了一个13:30执行的任务,此时schedule会执行notify()将wait()唤醒,但是扫描线程的wait()还没有执行呢,所以notify并没有实际作用,虽然新任务插入到队列中了,也是在队首.但是这个线程紧接又执行wait()一个小时,错过了这次任务的执行时间13:30
这都是多线程随机调度产生的,take和wait操作并非是原子的,如果这个过程是原子的,给它加上锁,保证不会有新的任务过来,就解决问题了,换言之就是要保证每次notify时,确实都在wait!
我们将锁的粒度变大,保证take和wait操作是原子的,就不会出现线程安全问题了
原文链接: https://blog.csdn.net/chenchenchencl/article/details/128625021