【多线程】详解——模拟设计Timer（结尾附码源）

桃扇骨 2024-04-06 10:44 17阅读 0赞

**目录**

前言

Timer标准库中用法

Timer模拟实现

一、描述一个任务

二、创建MyTimer类，让MyTimer管理多个任务

四、创建一个扫描线程

五、各类问题及解决办法

模拟定时器代码

--------------------

## 前言 ##

在服务器开放中，客户端向服务器发送请求，等待服务器响应，但若因为某个故障，导致程序一直无响应，怎么办？这时总不可能让客户端一直都没有响应，一直等下去，很有可能程序就卡死了，所以为了应对此种情况，程序员就设置了一个定时器，若到在定时器规定的时间没有完成任务，会执行某一个动作，响应客户端；

--------------------

## Timer标准库中用法 ##

标准库中也有定时器（如下图）

![c7e907bd5afd47aead744484734e970c.png][]

标准库中定时器这个类里有个schedule方法，就是用来安排在多长时间之后来执行安排好的任务，因此他有两个参数（如下图）

![c3940d8bfc804d9c8c478ec4065fb74b.png][]

一个参数是要执行的任务，就是一个Runnable，需要继承TimerTask，重写run方法，从而指定要执行的任务； 另一个参数是等待时间（单位是毫秒），也即是经过多长时间后，执行任务；

一个定时器中，可以同时安排多个任务，并且执行完任务之后，进程并没有退出，Timer内部需要一组线程来执行任务，这里的线程才是“前台线程”，会影响进程的退出；

> 如下代码：（安排一个时间表）

public static void main(String[] args){
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("12:00 唱歌~");
                }
            }, 2000);
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("12:30 弹钢琴");
                }
            }, 3000);
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("13:00 弹吉他");
                }
            }, 4000);
            System.out.println("开始玩音乐");
        }

> 执行结果如下：

![0f480c083989400da56a140bd53100e8.png][]

--------------------

## Timer模拟实现 ##

#### 一、描述一个任务 ####

schedule方法的第一个参数便是任务，所以我们需要能够描述一个任务，怎么描述呢？这里的任务需要包含两个信息，一个是要干什么事（Runnable），另一个是要什么时候执行；（如下图）

![ca2ce52201114bfca55f42aa6cdb1c42.png][]

> 分析：

知道了任务和要执行的时间，这样就够了吗？想象一下，刚刚提到，**一个定时器可以同时安排多个任务**，那么这多个任务必然会涉及到先后发生的问题，那么**供大于求**的时候也就需要涉及到排序，可是任务是个类，怎么排序呢？比较器——继承Comparable接口，重写compareTo方法；（如下图）

![6b19a8e85dbd43a085475f5b521a2e36.png][]

> 分析：

这里由于time是long类型，所以需要强制类型转换，还有一个问题：“这里的return到底是this.time - o.time 还是 o.time - this.time 呢？”这里最好不要背，比较比较抽象，返回规则不是那么直观，所以，你只需要随便写一个，运行程序试一下，这多试几次，不也就知道吗~

#### 二、创建MyTimer类，让MyTimer管理多个任务 ####

可以用ArrayList吗？刚刚咱提到当**供大于求**时任务存储需要按序存储，ArrayList显然时无序，不方便找到时间最小的任务，所以这里不难想到使用优先级队列，但由于schedule时有可能在多线程中调用的，并且优先级队列并不是线程安全的，所以可以使用优先级阻塞队列（BlockingQueue）来实现；

#### 四、创建一个扫描线程 ####

从队列中取元素，可以用一个“扫描线程”来不停的检查队首元素，检查时间是否到了，若时间到了，则取出队首元素，执行任务，若时间没到，则将队首元素放回；（如下图）

![cc68d16fa31342d090e338fc34a5cef7.png][]

> 分析：

由于是阻塞队列，所以因该先取出任务，才能够判断时间是否已经到了，若时间还没到，就把任务继续放回队列

#### 五、各类问题及解决办法 ####

> 存在问题分析一：“忙等”

观察代码，不难发现当时间还没到的时候，队列会循环的将队首元素取出，然后放回，这个循环就是在忙等，CPU并没有空闲出来，因此这里的等待也就变的毫无意义；

**注意这里不可以用sleep()**，假设当前时间为9点，任务时间是10点，那么你将设置 sleep 的时间为一个小时，这样合理吗？看似合理，但在多线程的情况下，很有可能会有新的任务出现，若新的任务时间为9点半，那么新的任务就需要执行sleep到10点，那么就会导致新的任务无法在9点半的时候执行！

> 解决办法：

**使用wait()就可以很好的解决上述问题；如下图**

![25ba6c314b914361ac3a204cbc2e74ba.png][]

![74a1c777aaf344b0856aa9206957dec9.png][]

> 存在问题分析二：“notify()空唤醒”

假设当前时间为9点，而当前任务执行的时间为11点，试想如果schedule在t1线程刚执行完take，还没有到wait的时候又新增了一个任务，这个任务的执行时间为10点，这会发生什么？

首先notify会在t1线程还没有wait的时候先唤醒一次，就相当于啥也没做，但其实notify即使什么线程都没唤醒，并不会存在什么问题，但是严重的问题在后面！当扫描线程继续往下执行，发现时间还没到，就将刚刚take出来的任务又放回了阻塞队列，然后就进行了wait等待，这以等待便是2个小时，**这意味着，刚才新来的任务需要在10点的时候执行，却被错过了！**

> 解决办法：

刚才出现问题的原因实际上就是因为notify在take和wait之间执行的，现在只需要把扫描线程中的锁范围扩大，保证take和wait之间这段操作的原子性，这样，就可以避免notify在take和wait之间执行；

来分析一下具体过程，9点的时候来了一个任务，需要在11点执行，扫描线程会先拿到锁，然后take，**（这时将一个新的任务放入了队列，这个任务的执行时间为10点）**，接着实现中间逻辑，发现没到时间，就将take出的元素放入队列**（此时他已经不是队首元素了）**，最后到wait；在这个过程中，schedule线程会一直阻塞等待锁，当扫描线程执行了wait，释放了锁，这个时候需要在10点开始执行的任务才拿到锁，执行notify唤醒了正在wait的线程，于是**，继续循环取出队首元素，而此时，取出的队首元素便是要在10点执行的那个任务；（如下图）**

![cba6cc9d9f2440d29c388cc2570157e9.png][]

**这样写，就已经基本没问题了；**

> 最后可以思考这样一个问题：若这样写（如下图），会存在什么问题？

![8b0322808bf54e6e90105642a2dbed78.png][]

> 问题分析：“死锁”

假设当我new了一个刚刚写好的MyTimer，那么此时就会初始化并调用MyTimer构造方法，构造方法中会创建一个线程t1，并开始线程，那么就会执行run方法，**此时线程t1拿到锁，程序进入run方法，接着进行take操作，但是阻塞队列中没有元素，因此阻塞队列就会阻塞等待**，直到有任务放入队列中，此时，来了一个任务，通过myTimer.schedule(//任务...，//时间...)，此时进入schedule方法，**但是由于刚刚线程t1已经拿到锁，schedule也会阻塞等待**，所以此时schedule无法将任务put到队列中，**这时t1在阻塞等待，schedule也在阻塞等待，就出现了死锁；**

**所以一定要把put操作放在所外面!**

--------------------

## 模拟定时器代码 ##

//任务
    class MyTask implements Comparable<MyTask>{
        //将要执行的任务
        private Runnable runnable;
        //多久后执行任务
        private long time;
        public MyTask(Runnable runnable, long time){
            this.runnable = runnable;
            this.time = time + System.currentTimeMillis();
        }
        public Runnable getRunnable() {
            return runnable;
        }
        public long getTime() {
            return time;
        }
        public int compareTo(MyTask o) {
            return (int)(this.time - o.time);
        }
    }
    //计时器
    class MyTimer {
        //优先级阻塞队列来存放任务，保证时间最小的先出队
        private BlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
        private Object locker = new Object();
        public MyTimer() {
            //创建一个线程，不断来扫描下一个任务
                Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        synchronized(locker) {
                            try {
                                //取出队首元素
                                MyTask task = queue.take();
                                //获取当前时间
                                long nowTime = System.currentTimeMillis();
                                //若到时了就执行任务，若没到时就阻塞等待
                                if(nowTime >= task.getTime()){
                                    task.getRunnable().run();
                                }else{
                                    //先将取出的元素放回
                                    queue.put(task);
                                    locker.wait(task.getTime() - nowTime);
                                }
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            });
                t1.start();
        }
        //安排
        public void schedule(Runnable runnable, long time) throws InterruptedException {
            queue.put(new MyTask(runnable, time));
            synchronized(locker) {
                locker.notify();
            }
        }
    }
    //测试
    public class Test {
        public static void main(String[] args) throws InterruptedException {
            MyTimer myTimer = new MyTimer();
            myTimer.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行任务1");
                }
            }, 1000);
            myTimer.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行任务2");
                }
            },2000);
            myTimer.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行任务3");
                }
            },3000);
            System.out.println("开始执行任务");
        }
    }

--------------------

![9b6b2134ef6a4442aa1fd6905eebf67f.gif][]

[c7e907bd5afd47aead744484734e970c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/1c70189fb5544673a213ea14ea65a890.png
[c3940d8bfc804d9c8c478ec4065fb74b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/3e282c9723c842a6a9e79c4a5fe087b2.png
[0f480c083989400da56a140bd53100e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/a7b5637c8b9d4dfe8fdb9219c162cfd9.png
[ca2ce52201114bfca55f42aa6cdb1c42.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/9e220ebbe11c44f9967fcd6d14376f26.png
[6b19a8e85dbd43a085475f5b521a2e36.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/c243c49444a241dfbc95d0cea509d910.png
[cc68d16fa31342d090e338fc34a5cef7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/6b068688692f4effafffe86a1bfd5768.png
[25ba6c314b914361ac3a204cbc2e74ba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/2dc63cdb15ce426c906e5a2c5026ebbb.png
[74a1c777aaf344b0856aa9206957dec9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/332303a8549f4cd9b0cc5391f63df96b.png
[cba6cc9d9f2440d29c388cc2570157e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/62e8b9eda1a2403eb8ebab69e8c55f02.png
[8b0322808bf54e6e90105642a2dbed78.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/6e0d288d1f1147abbebbcf31addce9c9.png
[9b6b2134ef6a4442aa1fd6905eebf67f.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/81bbe77fb8f546f78158e5a68e52b4be.gif