大家好，我是晓星航。今天为大家带来的是 多线程案例三 相关的讲解！😀
多线程案例三
三、 定时器
定时器是什么
定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定 好的代码.
定时器是一种实际开发中非常常用的组件.
比如网络通信中, 如果对方 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);
}
}
}
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是一样的，都会按照对应的时间进行启动。文章来源：https://www.toymoban.com/news/detail-630180.html
感谢各位读者的阅读，本文章有任何错误都可以在评论区发表你们的意见，我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞，你的每一次鼓励都是作者创作的动力哦！😘文章来源地址https://www.toymoban.com/news/detail-630180.html
到了这里，关于多线程案例(3)-定时器的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
