多线程案例三

三、定时器

定时器是什么

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

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

比如网络通信中, 如果对方 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);
    }
}