多线程案例(3)-定时器

超、凢脫俗 2024-04-28 07:10 110阅读 0赞

#### 文章目录 ####

*  多线程案例三
 *  三、 定时器

**大家好，我是晓星航。今天为大家带来的是 多线程案例三 相关的讲解！?**

## 多线程案例三 ##

## 三、 定时器 ##

**定时器是什么**

定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定 好的代码.

![202306192108619.png][]

> 定时器是一种实际开发中非常常用的组件.
> 
> 比如网络通信中, 如果对方 500ms 内没有返回数据, 则断开连接尝试重连.
> 
> 比如一个 Map, 希望里面的某个 key 在 3s 之后过期(自动删除).
> 
> 类似于这样的场景就需要用到定时器.

![202307291100466.png][]

这个方法的效果是，给定时器，注册一个任务。任务不会立即执行，而是在指定时间进行执行。

**标准库中的定时器**

*  标准库中提供了一个 Timer 类. Timer 类的核心方法为`schedule`.
 *  `schedule`包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后 执行 (单位为毫秒).

System.out.println("程序启动");
    //这个 Timer 类就是标准库的定时器
    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
        
        @Override
        public void run() {
        
            System.out.println("运行定时器任务1");
        }
    },1000);
    timer.schedule(new TimerTask() {
        
        @Override
        public void run() {
        
            System.out.println("运行定时器任务2");
        }
    },2000);
    timer.schedule(new TimerTask() {
        
        @Override
        public void run() {
        
            System.out.println("运行定时器任务3");
        }
    },3000);

![202307291105946.png][]

**实现定时器**

定时器的构成:

*  一个带优先级的阻塞队列

> 为啥要带优先级呢?
> 
> 因为阻塞队列中的任务都有各自的执行时刻 (delay). 最先执行的任务一定是 delay 最小的. 使用带 优先级的队列就可以高效的把这个 delay 最小的任务找出来.

*  队列中的每个元素是一个 Task 对象.
 *  Task 中带有一个时间属性, 队首元素就是即将
 *  同时有一个 worker 线程一直扫描队首元素, 看队首元素是否需要执行

1)Timer 类提供的核心接口为 schedule, 用于注册一个任务, 并指定这个任务多长时间后执行.

public class Timer {
        
        public void schedule(Runnable command, long after) {
        
     // TODO
       }
    }

2)Task 类用于描述一个任务(作为 Timer 的内部类). 里面包含一个 Runnable 对象和一个 time(毫秒时 间戳)

这个对象需要放到 优先队列 中. 因此需要实现 `Comparable`接口.

static class Task implements Comparable<Task> {
        
            private Runnable command;
            private long time;
            public Task(Runnable command, long time) {
        
                this.command = command;
                // time 中存的是绝对时间, 超过这个时间的任务就应该被执行
                this.time = System.currentTimeMillis() + time;
           }
            public void run() {
        
                command.run();
           }
            @Override
            public int compareTo(Task o) {
        
                // 谁的时间小谁排前面
                return (int)(time - o.time);
           }
       }
    }

3)Timer 实例中, 通过 PriorityBlockingQueue 来组织若干个 Task 对象.

通过 schedule 来往队列中插入一个个 Task 对象.

class Timer {
        
        // 核心结构
        private PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue();
        
        public void schedule(Runnable command, long after) {
        
            Task task = new Task(command, after);
            queue.offer(task);
       }    
    }

4)Timer 类中存在一个 worker 线程, 一直不停的扫描队首元素, 看看是否能执行这个任务

> 所谓 “能执行” 指的是该任务设定的时间已经到达了.

class Timer {
        
     // ... 前面的代码不变
        
        public Timer() {
        
            // 启动 worker 线程
            Worker worker = new Worker();
            worker.start();
       }
        
        class Worker extends Thread{
        
            @Override
            public void run() {
        
                while (true) {
        
                    try {
        
                        Task task = queue.take();
                        long curTime = System.currentTimeMillis();
                        if (task.time > curTime) {
        
                            // 时间还没到, 就把任务再塞回去
    queue.put(task);
                       } else {
        
                            // 时间到了, 可以执行任务
    task.run();
                       }
                   } catch (InterruptedException e) {
        
                        e.printStackTrace();
                        break;
                   }
               }
           }
       }
    }

但是当前这个代码中存在一个严重的问题, 就是 while (true) 转的太快了, 造成了无意义的 CPU 浪费.

> 比如第一个任务设定的是 1 min 之后执行某个逻辑. 但是这里的 while (true) 会导致每秒钟访问队 首元素几万次. 而当前距离任务执行的时间还有很久呢.

5)引入一个 mailBox 对象, 借助该对象的 wait / notify 来解决 while (true) 的忙等问题.

class Timer {
        
        // 存在的意义是避免 worker 线程出现忙等的情况
        private Object mailBox = new Object(); 
    }

修改 Worker 的 run 方法, 引入 wait, 等待一定的时间.

public void run() {
        
        while (true) {
        
            try {
        
                Task task = queue.take();
                long curTime = System.currentTimeMillis();
                if (task.time > curTime) {
        
                    // 时间还没到, 就把任务再塞回去
                    queue.put(task);
                    // [引入 wait] 等待时间按照队首元素的时间来设定. 
                    synchronized (mailBox) {
        
                        // 指定等待时间 wait
                        mailBox.wait(task.time - curTime);
                   }
                    
               } else {
        
                    // 时间到了, 可以执行任务
                    task.run();
               }
           } catch (InterruptedException e) {
        
                e.printStackTrace();
                break;
           }
       }
    }

修改 Timer 的 schedule 方法, 每次有新任务到来的时候唤醒一下 worker 线程. (因为新插入的任务可能 是需要马上执行的).

public void schedule(Runnable command, long after) {
        
        Task task = new Task(command, after);
        queue.offer(task);
        
        // [引入 notify] 每次有新的任务来了, 都唤醒一下 worker 线程, 检测下当前是否有
        synchronized (mailBox) {
        
            mailBox.notify();
       }
    }

完整代码

/**
    * 定时器的构成:
    * 一个带优先级的阻塞队列
    * 队列中的每个元素是一个 Task 对象.
    * Task 中带有一个时间属性, 队首元素就是即将
    * 同时有一个 worker 线程一直扫描队首元素, 看队首元素是否需要执行
    */
    public class Timer {
        
        static class Task implements Comparable<Task> {
        
            private Runnable command;
            private long time;
            public Task(Runnable command, long time) {
        
                this.command = command;
                // time 中存的是绝对时间, 超过这个时间的任务就应该被执行
                this.time = System.currentTimeMillis() + time;
           }
            public void run() {
        
                command.run();
           }
     @Override
            public int compareTo(Task o) {
        
                // 谁的时间小谁排前面
                return (int)(time - o.time);
           }
       }
        // 核心结构
        private PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue();
        // 存在的意义是避免 worker 线程出现忙等的情况
        private Object mailBox = new Object();
        class Worker extends Thread{
        
            @Override
            public void run() {
        
                while (true) {
        
                    try {
        
                        Task task = queue.take();
                        long curTime = System.currentTimeMillis();
                        if (task.time > curTime) {
        
                            // 时间还没到, 就把任务再塞回去
    queue.put(task);
                            synchronized (mailBox) {
        
                                // 指定等待时间 wait
    mailBox.wait(task.time - curTime);
                           }
                       } else {
        
                            // 时间到了, 可以执行任务
    task.run();
                       }
                   } catch (InterruptedException e) {
        
                        e.printStackTrace();
                        break;
                   }
               }
           }
       }
        public Timer() {
        
            // 启动 worker 线程
            Worker worker = new Worker();
            worker.start();
       }
        // schedule 原意为 "安排"
        public void schedule(Runnable command, long after) {
        
            Task task = new Task(command, after);
            queue.offer(task);
            synchronized (mailBox) {
        
                mailBox.notify();
           }
       }
        public static void main(String[] args) {
        
            Timer timer = new Timer();
            Runnable command = new Runnable() {
        
                @Override
                public void run() {
        
                 System.out.println("我来了");
                    timer.schedule(this, 3000);
               }
           };
            timer.schedule(command, 3000);
       }
    }

我们自己写的定时器：

咱们的定时器里面，核心

1.要有一个扫描线程，负责判定时间到/执行任务

2.还要有一个数据结构，来保存所有被注册的任务

我们在当前场景下，使用**优先级队列**，是一个很好的选择！！！

按照时间小的，作为优先级高的，此时队首元素就是整个队列中，最先要执行的任务。此时扫描线程**只需**要**扫一下队首元素即可**。不必遍历整个队列。(如果队首元素还没到执行时间，后续元素更不可能到时间！！！)

![202307291129492.png][]

此时我们自己写的定时器基本框架就已经搭构完成，我们用`MyTask`这个类来创建定义要执行的任务runnable和时间戳time，而后在MyTimer中使用他们

![202307291419272.png][]

阻塞队列，只能先把元素出队列，才好判定，不满足还得塞回去。这不像普通队列，可以直接取队首元素判定的。

定时器(自己版本)完整版：

import java.util.Timer;
    import java.util.TimerTask;
    import java.util.concurrent.PriorityBlockingQueue;
    /**
     * Created with IntelliJ IDEA.
     * Description:
     * User: 晓星航
     * Date: 2023-07-29
     * Time: 11:20
     */
    //使用这个类来表示一个定时器中的任务.
    class MyTask implements Comparable<MyTask>{
        
        //要执行的任务内容
        private Runnable runnable;
        //任务啥时候执行，(使用毫秒时间戳表示)
        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();
        }
    
        @Override
        public int compareTo(MyTask o) {
        
            //返回小于0 大于0  0
            //this 比 o 小，返回 < o
            //this 比 o 小，返回 > o
            //this 和 o 相等，返回 = o
            //当前要实现的效果，是队首元素 是时间最小的任务
            //这俩谁减谁不要去记！！！试试就知道了。
            //要么是 this.time - o.time   要么是 o.time - this.time
            return (int)(this.time - o.time);
        }
    }
    
    //自己写的简单的定时器
    class MyTimer {
        
        //扫描线程
        private Thread t = null;
    
        //有一个阻塞优先级队列，来保存任务。
        private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
    
        public MyTimer() {
        
            t = new Thread(()->{
        
                while (true) {
        
                    try {
        
                        //取出队首元素，检查看看队首元素任务是否到时间了。
                        //如果时间没到，就把任务塞回队列里去。
                        //如果时间到了，就把任务进行执行。
                        synchronized (this) {
        
                            MyTask myTask = queue.take();
                            long curTime = System.currentTimeMillis();
                            if (curTime < myTask.getTime()) {
        
                                //还没到点，先不必执行
                                queue.put(myTask);
                                //在 put 之后，进行一个 wait
                                    this.wait(myTask.getTime() - curTime);
                            } else {
        
                                //时间到了！！执行任务！！
                                myTask.run();
                            }
                        }
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    
        //指定两个参数
        //第一个参数是 任务 内容
        //第二个参数是 任务 在多少毫秒之后执行,形如 1000
        public void schedule(Runnable runnable,long after) {
        
            //注意这里的时间上的换算
            MyTask task = new MyTask(runnable,System.currentTimeMillis() + after);
            queue.put(task);
            synchronized (this) {
        
                this.notify();
            }
        }
    }
    public class ThreadDemo25 {
        
        public static void main(String[] args) {
        
            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);
        }
    }

![202307291535813.png][]

从运行结果不难看出，我们自己写的定时器和API自带的Timer是一样的，都会按照对应的时间进行启动。

*感谢各位读者的阅读，本文章有任何错误都可以在评论区发表你们的意见，我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞，你的每一次鼓励都是作者创作的动力哦！?*

[202306192108619.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/9cfd39cc55e94f49b4c94d8cef09ccae.png
[202307291100466.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/db18ad8dd5b8439ab2744de0a145dd10.png
[202307291105946.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/a43f1591137844a9ad1235f08ae7c354.png
[202307291129492.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/67698fa4c9584a7db94990eb7f26734f.png
[202307291419272.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/74460deed08c435ea8716b0f4d5be504.png
[202307291535813.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/74d6ac2699e64052bc149ead60ec3cdf.png