实现定时器（基于标准库提供的定时器、基于优先级队列自实现的定时器）

迷南。 2024-03-30 15:33 36阅读 0赞

## 目录： ##

##### 一、基于标准库提供的定时器 #####

##### 二、基于优先级队列自实现的定时器 #####

--------------------

## 一、基于标准库提供的定时器 ##

public static void main(String[] args) {
            //Timer类就是标准库提供的定时器
            Timer timer = new Timer();
    
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("定时器任务3");
                }
            },3000);
    
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("定时器任务2");
                }
            },2000);
    
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("定时器任务1");
                }
            },1000);
        }

## 二、基于优先级队列自实现的定时器 ##

//这个类表示一个定时器中的任务
    class MyTask implements Comparable<MyTask>{
         //要执行的任务
        private Runnable runnable;
        //该任务在什么时候后执行
        private Long time;
    
        //提供有参构造方法
    
        public MyTask(Runnable runnable, Long time) {
            this.runnable = runnable;
            this.time = time;
        }
    
        //提供time的Get方法
        public Long getTime() {
            return time;
        }
    
        //执行任务
        public void run(){
            runnable.run();
        }
    
        @Override
        public int compareTo(MyTask o) {
            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){
                   synchronized (this){
                       try {
                           MyTask myTask = queue.take();
                           long curTime = System.currentTimeMillis();
                           if (curTime < myTask.getTime()){
                               //还没到时间，继续放回队列，这里再算一下需要等待的时间，避免忙等
                               queue.put(myTask);
                               this.wait(myTask.getTime() - curTime);
                           }else {
                               //时间到了
                               myTask.run();
                           }
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               }
            });
            t.start();
        }
    
    
        // 第一个参数是 任务 内容
        // 第二个参数是 任务 在多少毫秒之后执行
        // 把任务加入队列
        public void schedule(Runnable runnable,Long after){
            MyTask myTask = new MyTask(runnable,System.currentTimeMillis()+after);
            queue.put(myTask);
        //这里是每次新加入一个任务，都要去唤醒，再次重新计算需要等待的时间
            synchronized (this){
                this.notify();
            }
        }
    }
    public class ThreadDemo24 {
        public static void main(String[] args) {
            MyTimer myTimer = new MyTimer();
    
            myTimer.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("定时器任务3");
                }
            },3000L);
    
            myTimer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("定时器任务2");
                }
            },2000L);
    
            myTimer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("定时器任务1");
                }
            },1000L);
        }
    }