大家好，我是晓星航。今天为大家带来的是 多线程案例三 相关的讲解！😀
多线程案例三
三、 定时器
定时器是什么
定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定 好的代码.
定时器是一种实际开发中非常常用的组件.
比如网络通信中, 如果对方 500ms 内没有返回数据, 则断开连接尝试重连.
比如一个 Map, 希望里面的某个 key 在 3s 之后过期(自动删除).
类似于这样的场景就需要用到定时器.
这个方法的效果是，给定时器，注册一个任务。任务不会立即执行，而是在指定时间进行执行。
标准库中的定时器
- 标准库中提供了一个 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);
实现定时器
定时器的构成:
- 一个带优先级的阻塞队列
为啥要带优先级呢?
因为阻塞队列中的任务都有各自的执行时刻 (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); } } } • 16 • 17 • 18
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.还要有一个数据结构，来保存所有被注册的任务
我们在当前场景下，使用优先级队列，是一个很好的选择！！！
按照时间小的，作为优先级高的，此时队首元素就是整个队列中，最先要执行的任务。此时扫描线程只需要扫一下队首元素即可。不必遍历整个队列。(如果队首元素还没到执行时间，后续元素更不可能到时间！！！)
此时我们自己写的定时器基本框架就已经搭构完成，我们用MyTask这个类来创建定义要执行的任务runnable和时间戳time，而后在MyTimer中使用他们
阻塞队列，只能先把元素出队列，才好判定，不满足还得塞回去。这不像普通队列，可以直接取队首元素判定的。
定时器(自己版本)完整版：
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); } }
从运行结果不难看出，我们自己写的定时器和API自带的Timer是一样的，都会按照对应的时间进行启动。
感谢各位读者的阅读，本文章有任何错误都可以在评论区发表你们的意见，我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞，你的每一次鼓励都是作者创作的动力哦！😘
