15. 多线程案例(3)——定时器

以你之姓@ 2022-11-04 12:24 194阅读 0赞

定时器可以强制终止请求：浏览器内部都有一个定时器，发送了请求之后，定时器就开始计时。如果在打开浏览界面的时候，浏览器的响应时间过了响应时间，就会强制终止请求。

## 1.定时器的构成 ##

1.使用一个类来描述“一个逻辑”，也就是要执行的任务，同时也要记录这个任务啥时候来执行  
2.使用一个 阻塞优先队列（既支持阻塞的特性，又支持按优先级的“先进先出”，实际上是堆） 来组织若干个Task，也就是收让队首元素为最早的任务，如果队首元素的时间还没到，那么其他元素肯定也不能执行  
3.需要有一个扫描线程，要循环检测队首元素是否需要执行这个任务

## 2.定时器代码实现 ##

package day0302;
    
    import java.util.concurrent.PriorityBlockingQueue;
    
    public class ThreadDemo22 {
        
        static class Task implements Comparable<Task>{
        
            //Runnable中有run方法，可以借助这个方法，来描述要执行的具体任务
            private Runnable command;
            //time表示啥时候来执行command
            private long time;//time是一个绝对时间
    
            //after 的意思事表示多少毫秒之后执行（相对时间）
            public Task(Runnable command, long after){
        
                this.command = command;
                this.time = System.currentTimeMillis()+after;
            }
    
            //具体执行任务的逻辑
            public void run(){
        
                command.run();
            }
    
    
            @Override
            public int compareTo(Task o) {
        
                //排序：谁的时间少谁先执行
                return (int)(this.time - o.time);
            }
        }
    
        static class Worker extends Thread{
        
            private PriorityBlockingQueue<Task> queue = null;
    
            public Worker(PriorityBlockingQueue<Task> queue) {
        
                this.queue = queue;
            }
    
            @Override
            public void run() {
        
                //实现具体的线程执行的内容
                while (true){
        
                    try {
        
                        //1.取出队首元素，检查时间是否到了
                        Task task= queue.take();
                        //2.检查时间是否到了
                        long curTime = System.currentTimeMillis();
                        if (task.time > curTime){
        
                            //时间还没到，就把任务塞回队列中
                            queue.put(task);
                        }else {
        
                            task.run();
                        }
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
    
                }
            }
        }
        static class Timer{
        
            //定时器的构成
            //1.使用一个类来描述“一个逻辑”，也就是要执行的任务，同时也要记录这个任务啥时候来执行
            //2.使用一个 阻塞优先队列（既支持阻塞的特性，又支持按优先级的“先进先出”，实际上是堆） 来组织若干个Task
            private PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();//标准库中的阻塞优先队列
            //3.需要有一个扫描线程，要循环检测队首元素是否需要执行这个任务
            public Timer(){
        
                //创建线程
                Worker worker = new Worker(queue);
                worker.start();
            }
            //4.还需要提供一个方法，让调用者能把任务给“安排”进来
            public void schedule(Runnable command, long after){
        
                Task task = new Task(command,after);
                queue.put(task);
            }
        }
    
        public static void main(String[] args) {
        
            Timer timer = new Timer();
            timer.schedule(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("hh");
                }
            },5000);
        }
    
    }

但是以上代码执行过程中，可能会出现忙等，也就是以下代码导致的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]  
这是可以借助wait/notify来解决

**那么最终代码为：**

import java.util.concurrent.PriorityBlockingQueue;
    
    public class ThreadDemo22 {
        
        static class Task implements Comparable<Task>{
        
            //Runnable中有run方法，可以借助这个方法，来描述要执行的具体任务
            private Runnable command;
            //time表示啥时候来执行command
            private long time;//time是一个绝对时间
    
            //after 的意思事表示多少毫秒之后执行（相对时间）
            public Task(Runnable command, long after){
        
                this.command = command;
                this.time = System.currentTimeMillis()+after;
            }
    
            //具体执行任务的逻辑
            public void run(){
        
                command.run();
            }
    
    
            @Override
            public int compareTo(Task o) {
        
                //排序：谁的时间少谁先执行
                return (int)(this.time - o.time);
            }
        }
    
        static class Worker extends Thread{
        
            private PriorityBlockingQueue<Task> queue = null;
            private Object mailBox = null;
    
            public Worker(PriorityBlockingQueue<Task> queue,Object mailBox) {
        
                this.queue = queue;
                this.mailBox = mailBox;
            }
    
            @Override
            public void run() {
        
                //实现具体的线程执行的内容
                while (true){
        
                    try {
        
                        //1.取出队首元素，检查时间是否到了
                        Task task= queue.take();
                        //2.检查时间是否到了
                        long curTime = System.currentTimeMillis();
                        if (task.time > curTime){
        
                            //时间还没到，就把任务塞回队列中
                            queue.put(task);
                            synchronized (mailBox){
        
                                mailBox.wait(task.time - curTime);
                            }
                        }else {
        
                            task.run();
                        }
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
    
                }
            }
        }
        static class Timer{
        
            //为了避免盲等,需要使用wait方法
            private Object mailBox = new Object();
            
            //定时器的构成
            //1.使用一个类来描述“一个逻辑”，也就是要执行的任务，同时也要记录这个任务啥时候来执行
            //2.使用一个 阻塞优先队列（既支持阻塞的特性，又支持按优先级的“先进先出”，实际上是堆） 来组织若干个Task
            private PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();//标准库中的阻塞优先队列
            //3.需要有一个扫描线程，要循环检测队首元素是否需要执行这个任务
            public Timer(){
        
                //创建线程
                Worker worker = new Worker(queue,mailBox);
                worker.start();
            }
            //4.还需要提供一个方法，让调用者能把任务给“安排”进来
            public void schedule(Runnable command, long after){
        
                Task task = new Task(command,after);
                queue.put(task);
                synchronized (mailBox){
        
                    mailBox.notify();
                }
            }
        }
    
        public static void main(String[] args) {
        
            Timer timer = new Timer();
            timer.schedule(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("hh");
                    timer.schedule(this,2000);
                }
            },2000);
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]: /images/20221023/271d9cea106b4878b6c06989d04a5c26.png