多线程案例-定时器(附完整代码)

我不是女神ヾ 2024-02-05 14:53 54阅读 0赞

## 定时器是什么 ##

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

> 定时器是一种实际开发中非常常用的组件.
> 
> 比如网络通信种,如果对方500ms内没有返回数据,则断开尝试重连.
> 
> 比如一个Map,希望里面的某个key在3s之后过期(自动删除)
> 
> 类似于这样的场景就需要用到定时器.

## 标准库中的定时器 ##

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

下面是代码示例:

public class TestTimer {
        public static void main(String[] args) {
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("hello timer");
                }
            }, 3000);
    
            System.out.println("hello main");
        }
    }

运行代码,我们可以观察到一上来直接打印"hello main",然后三秒之后执行了"hello timer",为什么会出现这种情况呢?显然是每个Timer内置了一个线程.

> 注:由于Timer内置了线程(前台线程),会阻止进程结束.这是因为timer不知道代码是否还会添加新的任务进来,就处于一种严阵以待的状态.
> 
> 所以此处需要使用cancel()方法来主动结束,否则timer不知道其它什么地方还会添加任务.

public class TestTimer {
        public static void main(String[] args) throws InterruptedException {
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("hello timer");
                }
            }, 3000);
    
            System.out.println("hello main");
            Thread.sleep(4000);
            timer.cancel();
        }
    }

这时就可以观察到进程结束成功了.

![07278bcbce284521a1a53268858c735a.png][]

## 实现定时器 ##

定时器的构成

> 一个带优先级队列(**不要使用PriorityBlockingQueue**,容易死锁!),而是使用PriorityQueue
> 
> 实现原理:
> 
> 1.队列中每个元素是一个Task对象.
> 
> 2.Task中带有时间属性,队首元素就是即将要执行的任务
> 
> 3.同时有一个worker线程一直在扫描队首元素,看队首元素是否需要执行(先执行时间小的,后执行时间大的).

1.Timer类提供的核心接口为schedule,用于注册一个任务,并指定这个任务多长时间后执行.

public class MyTimer {
        public void schedule(Runnable runnable, long time) {
            //TODO
        }
    }

2.Task类用于描述一个任务(作为Timer的内部类).里面包含着一个Runnable对象和一个time(毫秒时间戳)

这个对象需要放到优先级队列中,因此需要实现Comparable接口.

> **PriorityQueue, TreeMap, TreeSet都要求元素是"可比较大小的".需要Comparable,Comparator.**
> 
> **HashMap, HashSet则是要求元素是"可比较相等的","可hash的".因此需要实现**
> 
> **equals,hashCode方法**.

class MyTimerTask implements Comparable<MyTimerTask> {
        private Runnable runnable;
        //为了方便后续判定,使用了绝对的时间戳
        private long time;
        
        public MyTimerTask(Runnable runnable, long delay) {
            this.runnable = runnable;
            //取当前时刻的时间戳 + delay,作为该任务实际执行的时间戳
            this.time = System.currentTimeMillis() + delay;
        }
    
        @Override
        public int compareTo(MyTimerTask o) {
            //这样的写法意味着每次去除的是时间最小的元素
            //到底是谁减谁,不要记,建议随便写个试一试
            return (int)(this.time - o.time);
        }
    }

3.Timer实例中,通过PriorityQueue来组织若干个Task对象.

通过schedule往队列中插入一个个Task对象

class MyTimer {
        //核心结构
        private PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
        //创建一个锁对象
        private Object locker = new Object();
        
        public void schedule(Runnable runnable, long time) {
            //根据参数,构造MyTimerTask,插入队列即可
            synchronized(locker) {
                MyTimerTask myTimerTask = new MyTimerTask(runnable, delay);
                queue.offer(myTimerTask);
                locker.notify();
            }
        }
    }

4.Timer类中存在一个worker线程,一直不停地扫描队首元素,看看是否能执行这个任务.

> 所谓能执行就是时间已经到达了.

//在这里构建线程,负责执行具体的任务了
    public MyTimer() {
        Thread t = new Thread(() -> {
            while(true) {
                try {
                    synchronized(locker) {
                        //阻塞队列,只有阻塞的入队列和阻塞的出队列,没有阻塞查看队首元素
                        while(!queue.isEmpty()) {
                            locker.wait();
                        }
                        MyTimerTask myTimerTask = queue.peek();
                        long curTime = System.currentTimeMillis();
                        if(curTime >= myTimerTask.getTime()) {
                            //时间到了,可以执行任务了
                            queue.poll();
                            myTimerTask.run();
                        } else {
                            //时间还没到
                            locker.wait(myTimerTask.time - curTime);
                        }
                    }
                } catch(InterruptException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }

下面附上完整代码以及解析:

import java.util.PriorityQueue;
    
    //通过这个类,来描述一个任务,这一整个任务,是要放到优先级队列中的
    class MyTimerTask implements Comparable<MyTimerTask>{
        //在什么时间来执行这个任务
        //此处的time是一个ms级别的时间戳
        private long time;
        //实际任务要执行的代码
        private Runnable runnable;
        //delay期望是一个相对时间
        public MyTimerTask(Runnable runnable, long delay) {
            this.runnable = runnable;
            //计算一下要执行任务的绝对时间.(使用绝对时间,方便判定任务是否到达时间的)
            this.time = System.currentTimeMillis() + delay;
        }
    
        //实际执行代码的方法(一般在主函数中重写)
        public void run() {
            runnable.run();
        }
    
        //用于获得任务执行时间
        public long getTime() {
            return this.time;
        }
    
        //构建一个比较器(因为在优先级队列中是按时间对任务进行比较)
        @Override
        public int compareTo(MyTimerTask o) {
            return (int)(this.time - o.time);
        }
    }
    
    public class MyTimer{
        //构建一个线程
        private Thread t = null;
        //创建存放任务的主体--优先级队列
        private PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
        //创建一个锁对象
        private Object locker = new Object();
    
        //结束进程的方法
        public void cancel() {
            t.interrupt();
        }
        //构造方法:以用于创建线程
        public MyTimer() {
            t = new Thread(() -> {
                while(!Thread.interrupted()) {
                    try {
                        synchronized (locker) {
                            while(queue.isEmpty()) {
                                //当队列为空时,这个线程就一直处于阻塞等待的状态
                                locker.wait();
                            }
                            //获得队列头部元素
                            MyTimerTask task = queue.peek();
                            //计算系统当前时间
                            long curTime = System.currentTimeMillis();
                            //判断是否应该执行
                            if(curTime >= task.getTime()) {
                                //执行任务
                                queue.poll();
                                task.run();
                            } else {
                                //等待到指定时间再执行任务
                                locker.wait(task.getTime() - curTime);
                            }
                        }
                    } catch (InterruptedException e) {
                        break;
                    }
                }
            });
            t.start();
        }
        //通过这个方法来执行实际的任务
        public void schedule(Runnable runnable, long delay) {
            synchronized (locker) {
                //先创建一个任务,后将任务放入队列
                MyTimerTask myTimerTask = new MyTimerTask(runnable, delay);
                queue.offer(myTimerTask);
                //唤醒因为队列中因为没有任务而阻塞等待的线程
                locker.notify();
            }
        }
    }

[07278bcbce284521a1a53268858c735a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/70426e9781d24bf7924087418bc3492b.png