Java多线程案例——定时器
⭐️前言⭐️
博客主页： 【如风暖阳】
精品Java专栏【JavaSE】、【Java数据结构】、【备战蓝桥】、【JavaEE初阶】
欢迎点赞 收藏 ⭐留言评论 私信必回哟本文由 【如风暖阳】 原创，首发于 CSDN
博主将持续更新学习记录收获，友友们有任何问题可以在评论区留言
博客中涉及源码及博主日常练习代码均已上传码云(gitee)
内容导读
- Java多线程案例——定时器
-
- 定时器是什么
- 标准库中的定时器
- 实现定时器
Java多线程案例——定时器
定时器是什么
定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定
好的代码.
定时器是一种实际开发中非常常用的组件.
比如在浏览器访问某个网站时网卡了，浏览器就会转圈圈(阻塞等待)，这个等待不是无限的等待，到达一定时间以后，就显示超时访问
再比如在前端开发中网站上的动画效果，也是通过定时器实现的，比如每隔30ms，把页面往下滚动几个像素
标准库中的定时器
- 标准库中提供了一个 Timer 类. Timer 类的核心方法为 schedule .
- schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后
执行 (单位为毫秒).
System.out.println("代码开始执行");
Timer timer=new Timer();
//此处的TimerTask与Runnable功能相同，都是执行任务的代码
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("触发定时器！");
}
},3000);
//
代码开始执行
触发定时器！
实现定时器
定时器的构成:
- （1）队列中的每个元素是一个 Task 对象，Task中带有一个时间属性和一个Runnable任务属性
- （2）一个带优先级的阻塞队列
为啥要带优先级呢?
因为阻塞队列中的任务都有各自的执行时刻 (delay). 最先执行的任务一定是 delay 最小的. 使用带
优先级的队列就可以高效的把这个 delay 最小的任务找出来,使用带有阻塞功能的优先队列用以维护线程安全
- （3）一个schedule方法，该方法用于往队列中插入元素
- （4）一个扫描线程不断去扫描队首元素，看看队首元素是不是已经到点了，如果到点就执行这个任务，如果没有到点，就把这个队首元素塞回队列中，继续扫描
1）Task类用于描述一个任务，里面包含一个Runnable对象和一个time（毫秒时间戳）
这个对象需要放到优先队列中，因此需要实现Comparable接口
//这个类表示一个任务
class MyTask implements Comparable<MyTask> {
//要执行的任务
private Runnable runnable;
//什么时间来执行任务
private long time;
public MyTask(Runnable runnable,long delay) {
this.runnable=runnable;
this.time=System.currentTimeMillis()+delay;
}
public Runnable getRunnable() {
return runnable;
}
public long getTime() {
return time;
}
@Override
public int compareTo(MyTask o) {
return (int)(this.time-o.time);
}
//此处注意谁减谁如果不确定，可以换一下试试
}
2）MyTimer 实例中, 通过 PriorityBlockingQueue （优先级阻塞队列）来组织若干个 MyTask 对象. 通过 schedule 来往队列中插入一个个 Task 对象.
在实例化Timer类时，启动扫描线程
class MyTimer {
private BlockingQueue<MyTask> queue=new PriorityBlockingQueue<>();
public void schedule(Runnable runnable,long after) throws InterruptedException {
MyTask myTask=new MyTask(runnable,after);
queue.put(myTask);
}
public MyTimer() {
//创建一个扫描线程
Thread t=new Thread(()-> {
while (true) {
//取出队首元素
try {
//取出队首元素
MyTask task=queue.take();
long curTime=System.currentTimeMillis();
if(curTime>=task.getTime()) {
//到时间执行任务
task.getRunnable().run();
} else {
//没有到时间就进行等待
queue.put(task);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
}
}
在这段代码中我们会发现一个问题，就是线程扫描的速度太快了 【while (true) 】转的太快了, 造成了无意义的 CPU 浪费
比如第一个任务设定的是 1 min 之后执行某个逻辑. 但是这里的 while (true) 会导致每秒钟访问队首元素几万次. 而当前距离任务执行的时间还有很久呢.
3）通过让线程等待一定时间，来解决忙等问题
因为wait、notify必须搭配synchronized来使用，所以需要实例化一个Object类作为锁对象，让多个线程竞争同一把锁。
如果从队首取出的任务时间还没有到，就重新放回队列，并让线程等待（wait）一段时间，时间长短由任务时间与当前时间差决定。
当有新任务放入队列中时，需要重新唤醒线程，再次判断优先级阻塞队列的队首元素是否已经到达了执行时间。
注意：
线程进行等待时为什么用wait而不用sleep，因为使用wait可以指定一个时间作为参数（可以通过当前时刻和任务开始时之间的时间间隔来算）
而且wait能够使用notify提前唤醒，如果插入新任务比上一个任务执行时间早，就需要提前唤醒线程，如果使用sleep则无法唤醒线程。
4）防止空打一炮
在修改过3的代码后如下，仍然存在一些问题
//这个类表示一个任务
class MyTask implements Comparable<MyTask> {
//要执行的任务
private Runnable runnable;
//什么时间来执行任务
private long time;
public MyTask(Runnable runnable,long delay) {
this.runnable=runnable;
this.time=System.currentTimeMillis()+delay;
}
public Runnable getRunnable() {
return runnable;
}
public long getTime() {
return time;
}
@Override
public int compareTo(MyTask o) {
return (int)(this.time-o.time);
}
}
class MyTimer {
private BlockingQueue<MyTask> queue=new PriorityBlockingQueue<>();
//使用locker对象来解决忙等问题
private Object locker=new Object();
public void schedule(Runnable runnable,long after) throws InterruptedException {
MyTask myTask=new MyTask(runnable,after);
queue.put(myTask);
//每次插入新的任务都要唤醒扫描线程，让扫描线程能够重新计算wait的时间，保证新的任务也不会错过
synchronized (locker) {
locker.notify();
}
}
public MyTimer() {
//创建一个扫描线程
Thread t=new Thread(()-> {
while (true) {
//取出队首元素
try {
//取出队首元素
MyTask task=queue.take();
long curTime=System.currentTimeMillis();
if(curTime>=task.getTime()) {
//到时间执行任务
task.getRunnable().run();
} else {
//没有到时间就再放回队列
queue.put(task);
//根据时间差进行等待
synchronized (locker) {
locker.wait(task.getTime()-curTime);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
}
}
由于在扫描线程中，take()操作与wait()操作也是非原子的，如果刚新取出队首元素后，线程又被安排了一个新的任务，此时在扫描线程中得到的时间还是之前取出的任务的时间，如果按照那个时间去进行等待，就有可能导致新安排进来的任务被错过。
为了解决上述的问题，需要在扫描线程中加大锁的范围，使得take操作与wait操作是原子的。
更改后的完整代码见5）
5）完整代码
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
//这个类表示一个任务
class MyTask implements Comparable<MyTask> {
//要执行的任务
private Runnable runnable;
//什么时间来执行任务
private long time;
public MyTask(Runnable runnable,long delay) {
this.runnable=runnable;
this.time=System.currentTimeMillis()+delay;
}
public Runnable getRunnable() {
return runnable;
}
public long getTime() {
return time;
}
@Override
public int compareTo(MyTask o) {
return (int)(this.time-o.time);
}
}
class MyTimer {
private BlockingQueue<MyTask> queue=new PriorityBlockingQueue<>();
//使用locker对象来解决忙等问题
private Object locker=new Object();
public void schedule(Runnable runnable,long after) throws InterruptedException {
MyTask myTask=new MyTask(runnable,after);
queue.put(myTask);
//每次插入新的任务都要唤醒扫描线程，让扫描线程能够重新计算wait的时间，保证新的任务也不会错过
synchronized (locker) {
locker.notify();
}
}
public MyTimer() {
//创建一个扫描线程
Thread t=new Thread(()-> {
while (true) {
//取出队首元素
try {
synchronized (locker) {
//取出队首元素
MyTask task=queue.take();
long curTime=System.currentTimeMillis();
if(curTime>=task.getTime()) {
//到时间执行任务
task.getRunnable().run();
} else {
//没有到时间就再放回队列
queue.put(task);
//根据时间差进行等待
locker.wait(task.getTime()-curTime);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
}
}
public class Demo {
public static void main(String[] args) throws InterruptedException {
MyTimer timer=new MyTimer();
timer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("时间到1！");
}
},3000);
timer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("时间到2！");
}
},4000);
timer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("时间到3！");
}
},5000);
System.out.println("开始计时！");
}
}
⚡️最后的话⚡️
总结不易，希望uu们不要吝啬你们的哟(＾Ｕ＾)ノ~ＹＯ！！如有问题，欢迎评论区批评指正
