多线程案例三

三、定时器

定时器是什么

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

定时器是一种实际开发中非常常用的组件.

比如网络通信中, 如果对方 500ms 内没有返回数据, 则断开连接尝试重连.

比如一个 Map, 希望里面的某个 key 在 3s 之后过期(自动删除).

类似于这样的场景就需要用到定时器.

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

标准库中的定时器

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

System.out.println("程序启动");
//这个 Timer 类就是标准库的定时器
Timer timer = new Timer();
timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("运行定时器任务1");}
},1000);
timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("运行定时器任务2");}
},2000);
timer.schedule(new TimerTask() {@Overridepublic 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();}@Overridepublic 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{@Overridepublic 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) {// 指定等待时间 waitmailBox.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();}@Overridepublic 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{@Overridepublic 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() {@Overridepublic 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();}@Overridepublic int compareTo(MyTask o) {//返回小于0 大于0  0//this 比 o 小，返回 < o//this 比 o 小，返回 > o//this 和 o 相等，返回 = o//当前要实现的效果，是队首元素 是时间最小的任务//这俩谁减谁不要去记！！！试试就知道了。//要么是 this.time - o.time   要么是 o.time - this.timereturn (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 之后，进行一个 waitthis.wait(myTask.getTime() - curTime);} else {//时间到了！！执行任务！！myTask.run();}}} catch (InterruptedException e) {e.printStackTrace();}}});t.start();}//指定两个参数//第一个参数是 任务 内容//第二个参数是 任务 在多少毫秒之后执行,形如 1000public 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() {@Overridepublic void run() {System.out.println("任务1");}},1000);myTImer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("任务2");}},2000);myTImer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("任务3");}},3000);}
}