多线程案例-实现定时器

偏执的太偏执、 2023-10-10 15:58 17阅读 0赞

![822930f97a3643c0b9aa9b72c687a217.png][]

## 1.定时器是什么 ##

定时器是软件开发中的一个重要组件,功能是当达到一个特定的时间后,就执行某个指定好的代码

定时器是一个非常常用的组件,特别是在网络编程中,当出现了"连接不上,卡了"的情况,就使用定时器做一些操作来止损

标准库中也提供了定时器

### 标准库中的Timer类 ###

标准库提供了一个Timer类,Timer类的核心方法为schedule(安排，预定；将……列入计划表或清单)

> schedule包含两个参数  
> 第一个参数指定即将要执行的任务代码  
> 第二个参数指定多多长时间之后执行(单位ms)

下面是用一下定时器

![2e79763c5f2d4a869528ab8f46d7c0cd.png][]

可以看到有两个参数

TimerTask类就是一个实现了Runnable接口的类,来描述指定的任务

delay是指定的时间后执行任务!

![5239be1b860c4e4d8e3938039f34e45a.png][]

运行程序,经过指定的时间后,执行了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);
        }

![d2619465c8d74682ac9eb696a83e064f.png][]

因为两个任务的优先级关系还没用comparable来设置,或者单独实现一个比较器comparator

![df870cefbc0f4942b82e13ce5a77b9f2.png][]

![b88126e1eb5c48f2b0c916a8c001e6d9.png][]

运行程序

![9915586550294ab8aab3f1c52ac0aaf2.png][]

第二个问题,如果队首任务是四点进行执行,在两点的时候,线程开始扫描,就会一直从队首取出检查,发现没到执行时间,又放回去,反反复复!!直到四点开始执行.我们使用优先级队列来存储的,放回元素,堆就会进行一次调整,将这个任务又调整至队首,下次取出,还是这个元素!

这个循环没有阻塞,会快速的进行循环,是没有意义的,占用了cpu资源.这种情况称为"忙等",我们要对代码进行调整,进行阻塞式等待,sleep,wait..

如果等待时间明确,我们使用sleep可行吗?

此处看似等待时间是明确的,但是我们可能任意时间会来一个新的任务调用schedule,注册任务,那么队首元素就换了,必须得扫描出来.

> 如果用sleep,那么在sleep过程中就可能注册新的任务,如果在队首元素执行的时间前就要执行新注册的任务,然而用的sleep,就会错过这个任务的执行了  
> 因此使用wait()notify()更合适,使用wait()进行等待,如果有新任务调用schedule,就notify(),重新检查一次,计算等待的时间  
> 并且,wait()还有个超时时间的版本,如果没有新任务,则最多等到队首元素的执行时间就自动唤醒了

![c50bc015c89c40e6a4e7b60a2eb26f40.png][]

![000b6385d5cf4dfb8f9802d49334dd58.png][]

这样改动之后,我们既不会一直重复无用操作,也不会错过执行新注册任务

### 线程安全问题 ###

代码到这里,还有个线程安全问题

我们考虑一个极端情况

![78481ca75bd8456ab7eab44c2306e581.png][]

如果代码执行到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!

![23ea639109c440e4ab82b9772b5d72ce.png][]

我们将锁的粒度变大,保证take和wait操作是原子的,就不会出现线程安全问题了

[822930f97a3643c0b9aa9b72c687a217.png]: https://img-blog.csdnimg.cn/img_convert/822930f97a3643c0b9aa9b72c687a217.png
[2e79763c5f2d4a869528ab8f46d7c0cd.png]: https://img-blog.csdnimg.cn/img_convert/2e79763c5f2d4a869528ab8f46d7c0cd.png
[5239be1b860c4e4d8e3938039f34e45a.png]: https://img-blog.csdnimg.cn/img_convert/5239be1b860c4e4d8e3938039f34e45a.png
[d2619465c8d74682ac9eb696a83e064f.png]: https://img-blog.csdnimg.cn/img_convert/d2619465c8d74682ac9eb696a83e064f.png
[df870cefbc0f4942b82e13ce5a77b9f2.png]: https://img-blog.csdnimg.cn/img_convert/df870cefbc0f4942b82e13ce5a77b9f2.png
[b88126e1eb5c48f2b0c916a8c001e6d9.png]: https://img-blog.csdnimg.cn/img_convert/b88126e1eb5c48f2b0c916a8c001e6d9.png
[9915586550294ab8aab3f1c52ac0aaf2.png]: https://img-blog.csdnimg.cn/img_convert/9915586550294ab8aab3f1c52ac0aaf2.png
[c50bc015c89c40e6a4e7b60a2eb26f40.png]: https://img-blog.csdnimg.cn/img_convert/c50bc015c89c40e6a4e7b60a2eb26f40.png
[000b6385d5cf4dfb8f9802d49334dd58.png]: https://img-blog.csdnimg.cn/img_convert/000b6385d5cf4dfb8f9802d49334dd58.png
[78481ca75bd8456ab7eab44c2306e581.png]: https://img-blog.csdnimg.cn/img_convert/78481ca75bd8456ab7eab44c2306e581.png
[23ea639109c440e4ab82b9772b5d72ce.png]: https://img-blog.csdnimg.cn/img_convert/23ea639109c440e4ab82b9772b5d72ce.png