专栏简介: JavaEE从入门到进阶

题目来源: leetcode,牛客,剑指offer.

创作目标: 记录学习JavaEE学习历程

希望在提升自己的同时,帮助他人,,与大家一起共同进步,互相成长.

学历代表过去,能力代表现在,学习能力代表未来! 

目录: 

1.定时器的概念

2.标准库中的定时器

3.实现定时器

3.1定时期的构成:

3.2 实现步骤:

---

1.定时器的概念

定时器类似于一个"闹钟" , 是软件开发中的一个重要组件 , 达到一个设定时间后就会执行某段代码.

例如网络通信中 , 如果对方500ms都没有返回数据 , 那么就执行定时器中的任务:断开重连.

例如实现一个Map , 希望 Map 中的 key 在3s后过期(自动删除).

...............................

类似于以上的场景就需要用到定时器.

---

2.标准库中的定时器

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

public static void main(String[] args) {
Timer timer &＃61; new Timer();
timer.schedule(new TimerTask() {
&＃64;Override
public void run() {
System.out.println("hello");
}
},500);
}

---

3.实现定时器

3.1定时期的构成:

• 一个带优先级的阻塞队列 , 用来存放待执行的任务.

为什么要带优先级? 如果优先级队列按待执行时间(delay)来排序的话 , 每次只需取出队首的元素就可高效的把delay最小的任务给找出来.

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

3.2 实现步骤:

• 1.Timer 类提供的核心方法是 schedule() , 用于注册一个任务并指定这个任务何时执行.

class MyTimer{
public void schedule(Runnable runnable, long after){
//具体执行的任务
}
}

• 2.Task 类用于描述一个任务 , 里面包含一个 Runnable 对象和一个 time毫秒时间戳. 该类的对象需要放入优先级队列中 , 因此需要实现 Comparable 接口.

class MyTask implements Comparable{
private Runnable runnable;
private long time;
public MyTask(Runnable runnable, long time) {
this.runnable &＃61; runnable;
this.time &＃61; time;
}
//获取当前任务的时间
public long getTime(){
return time;
}
//执行任务
public void run(){
runnable.run();
}
&＃64;Override
public int compareTo(MyTask1 o) {
return (int) (this.time-o.time);
}
}

• 3.Timer 实例中 , 通过PriorityQueue来组织若干个 Task 对象 , 通过 schedule 往队列中插入一个个 Task 对象.

class MyTimer{
PriorityBlockingQueue queue &＃61; new PriorityBlockingQueue<>();
public void schedule(Runnable runnable , long after){
MyTask1 myTask &＃61; new MyTask(runnable , System.currentTimeMillis()&＃43;after);
queue.put(myTask);
}
}

• 4.Timer 类中存在一个扫描线程 , 不断的查看队首元素是否到达执行时间.

class MyTimer1 {
Thread scan &＃61; null;
PriorityBlockingQueue queue &＃61; new PriorityBlockingQueue<>();
public void schedule(Runnable runnable, long after) {
MyTask1 myTask1 &＃61; new MyTask1(runnable, System.currentTimeMillis() &＃43; after);
queue.put(myTask1);
}
public MyTimer1() {
scan &＃61; new Thread(() -> {
while (true) {
try {
MyTask1 myTask1 &＃61; queue.take();
if (System.currentTimeMillis() //时间还没到把任务塞回去
queue.put(myTask1);
} else {
//时间到了执行任务
myTask1.run();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
scan.start();
}
}

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

• 5. 借助 wait/notify 来解决 while(true) 问题 , 并且修改 MyTimer的 schedule方法 , 一但有新的任务加入就通知 wait 再次判断.

public void schedule(Runnable runnable, long after) {
MyTask1 myTask1 &＃61; new MyTask1(runnable, System.currentTimeMillis() &＃43; after);
queue.put(myTask1);
//一但加入新的元素就唤醒 wait ,重新判断
synchronized (this) {
this.notify();
}
}
public MyTimer1() {
scan &＃61; new Thread(() -> {
while (true) {
try {
MyTask1 myTask1 &＃61; queue.take();
if (System.currentTimeMillis() //时间还没到把任务塞回去
queue.put(myTask1);
synchronized (this) {
this.wait(myTask1.getTime()-System.currentTimeMillis());
}
} else {
//时间到了执行任务
myTask1.run();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
scan.start();
}

此时代码还存在一点瑕疵 , 假设当前时间是 13:00 如果队首的任务执行时间是 14:00  , 这时当代码执行到 queue.put(myTask1);时该线程被 CPU 调度走 , 与此同时另一个线程调用 schedule 方法 , 注册一个 13:30 执行的任务 , 将其放入队首并通知 wait.但此时 notify 方法空打一炮 , 等到扫描线程被调度回来时 , wait 还是要等待1h , 这样机会导致 13:30 的任务错过其执行时间.

产生上述问题的根本原因是 , take() 和 wait 操作不是原子的 , 如果在 take() 和 wait 之间加上锁 , 保证这个执行过程中不会有新的任务进来 , 问题自然解决.

public MyTimer1() {
scan &＃61; new Thread(() -> {
while (true) {
synchronized (this) {
try {
MyTask1 myTask1 &＃61; queue.take();
if (System.currentTimeMillis() //时间还没到把任务塞回去
queue.put(myTask1);
this.wait(myTask1.getTime()-System.currentTimeMillis());
} else {
//时间到了执行任务
myTask1.run();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
});
scan.start();
}

完整代码如下:

class MyTask1 implements Comparable{
private Runnable runnable;
private long time;
public MyTask1(Runnable runnable, long time) {
this.runnable &＃61; runnable;
this.time &＃61; time;
}
//获取当前任务的时间
public long getTime(){
return time;
}
//执行任务
public void run(){
runnable.run();
}
&＃64;Override
public int compareTo(MyTask1 o) {
return (int) (this.time-o.time);
}
}
/**
* 定时器类
*/
class MyTimer1 {
Thread scan &＃61; null;
PriorityBlockingQueue queue &＃61; new PriorityBlockingQueue<>();
public void schedule(Runnable runnable, long after) {
MyTask1 myTask1 &＃61; new MyTask1(runnable, System.currentTimeMillis() &＃43; after);
queue.put(myTask1);
//一但加入新的元素就唤醒 wait ,重新判断
synchronized (this) {
this.notify();
}
}
public MyTimer1() {
scan &＃61; new Thread(() -> {
while (true) {
synchronized (this) {
try {
MyTask1 myTask1 &＃61; queue.take();
if (System.currentTimeMillis() //时间还没到把任务塞回去
queue.put(myTask1);
this.wait(myTask1.getTime()-System.currentTimeMillis());
} else {
//时间到了执行任务
myTask1.run();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
});
scan.start();
}
}
public class ThreadDemo8 {
public static void main(String[] args) {
MyTimer1 myTimer1 &＃61; new MyTimer1();
myTimer1.schedule(new Runnable() {
&＃64;Override
public void run() {
System.out.println("hello,1");
}
},300);
myTimer1.schedule(new Runnable() {
&＃64;Override
public void run() {
System.out.println("hello,2");
}
},600);
}
}