【JavaEE】多线程案例-定时器

不能再留遗憾了2023-09-19 14:48

文章目录

  • [1. 前言](#1. 前言)
  • [2. 如何使用Java标准库提供的定时器](#2. 如何使用Java标准库提供的定时器)
  • [3. 如何自己实现一个定时器](#3. 如何自己实现一个定时器)
    • [3.1 构建 MyTimerTask 任务类](#3.1 构建 MyTimerTask 任务类)
    • [3.2 使用优先级队列来存储多个任务](#3.2 使用优先级队列来存储多个任务)
    • [3.3 实现 schedule 方法来添加任务](#3.3 实现 schedule 方法来添加任务)
    • [3.4 实现 Timer 类当中的扫描线程和具体细节](#3.4 实现 Timer 类当中的扫描线程和具体细节)
    • [3.5 定时器的修改及优化](#3.5 定时器的修改及优化)
  • [4. 计时器完整代码](#4. 计时器完整代码)

1. 前言

在生活中，我们肯定遇到过访问某个网站的时候或者加载视频的时候，出现请求超时的现象吧，如果客户端向服务器发送请求，但是没有得到响应该怎么办呢？难道要让我们死等吗？这肯定是不现实的，那么这时候就需要用到我们的定时器。客户端向服务器发送请求，如果超过一段时间没有得到响应，那么定时器就会决定是重新发送请求还是停止请求。在多线程案例中，定时器是一个比较复杂的案例，同时也是比较重要的一个多线程案例。今天我将为大家分享关于定时器知识的分享。

2. 如何使用Java标准库提供的定时器

在 Java 的 util 包下提供了定时器的实现，我们可以直接使用 Java 标准库提供的定时器。

java 复制代码 
import java.util.Timer;
import java.util.TimerTask;

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

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(2000);
            }
        },2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(1000);
            }
        },1000);
        System.out.println("定时器开始");
    }
}
  • Timer 类表示定时器类
  • 调用 Timer 类的 schedule 方法，将 TimerTask 类添加到定时器内
  • TimerTask 类包括了该任务的具体实现内容，以及执行这个任务的时间

delay 表示从调用 schedule 方法开始的多长时间执行这个任务。不管哪个任务先添加的，总是按照时间的从小到大顺序执行。并且仔细观察我们可以发现，当执行完定时器当中的内容的时候，整个线程并没有结束，这是因为 Timer 内部的线程阻止了线程的结束。

3. 如何自己实现一个定时器

3.1 构建 MyTimerTask 任务类

虽然 Java 标准库为我们提供了定时器，但是我们作为初学者，还是需要知道他究竟是如何实现的，我们能自己实现一个计时器对理解定时器作用是非常大的。

java 复制代码 
class Mytimer {
    private long time;
    private Runnable runnable;
    public Mytimer(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }
    
    public long getTime() {
        return this.time;
    }
    
    public Runnable getRunnable() {
        return this.runnable;
    }
}

先创建一个 MyTimerTask 类用来描述任务的具体内容，包括执行的操作和执行的时间。

3.2 使用优先级队列来存储多个任务

当创建一个 MyTimerTask 类用来描述具体的内容之后，又该用什么来存储这多个 MyTimerTask 任务呢？因为它是按照时间的先后顺序执行的，时间近的任务优先级高，那么这样的话，我们就可以使用优先级队列这个数据结构来存储 MyTimerTask 类，并且创建的小根堆，时间最接近的放在堆顶。

java 复制代码 
	PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();

3.3 实现 schedule 方法来添加任务

当调用 schedule 方法的时候，就调用 PriorityQueue 的 offer 方法将任务添加到优先级队列中。

java 复制代码 
	public void schedule(MyTimerTask myTimerTask) {
        queue.offer(myTimerTask);
    }

3.4 实现 Timer 类当中的扫描线程和具体细节

Timer 线程中需要一个扫描线程来看堆顶任务是否该执行了。当优先级队列为空的时候，需要该线程进入等待状态，直到调用 schedule 方法向队列中添加任务的时候才唤醒该线程。所以我们前面的 schedule 方法就需要稍作调整。

java 复制代码 
	private static Object locker = new Object();

    public void schedule(MyTimerTask myTimerTask) {
        synchronized (locker) {
            queue.offer(myTimerTask);
            locker.notify();
        }
    }

    public MyTimer() {
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    synchronized (locker) {
                    	//通常线程被唤醒之后的判断不使用if，
                    	//而是使用while循环，因为唤醒线程的方法不止有notify
                    	//interrupt方法也可以唤醒处于等待状态的线程
                    	//当处于等待状态的线程是因为interrupt方法唤醒的时候
                    	//就说明没有执行schedule方法，此时queue中还是为空的
                        while (queue.isEmpty()) {
                            locker.wait();
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

这里在调用 schedule 方法的好处不止有唤醒当堆为空时的等待状态，还有一些好处，我们在后面遇到的时候为大家讲解。

当堆不为空的时候，就要判断堆顶的任务是否到了需要执行的时间，如果到了需要执行的时间，就执行，没到则不需要做。

java 复制代码 
	public MyTimer() {
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    synchronized (locker) {
                        while (queue.isEmpty()) {
                            locker.wait();
                        }

                        MyTimerTask task = queue.peek();
                        if (curTime >= task.getTime()) {
                            task.getRunnable().run();
                            queue.poll();
                        }else {
                            ;
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }

当我们运行这个计时器的时候，看看结果如何

java 复制代码 
import java.util.PriorityQueue;

class MyTimerTask {
    private long time;
    private Runnable runnable;
    public MyTimerTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }

    public long getTime() {
        return this.time;
    }

    public Runnable getRunnable() {
        return this.runnable;
    }
}

class MyTimer {
    PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
    private static Object locker = new Object();

    public void schedule(Runnable runnable, long delay) {
        synchronized (locker) {
            queue.offer(new MyTimerTask(runnable,delay));
            locker.notify();
        }
    }

    public MyTimer() {
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    synchronized (locker) {
                        while (queue.isEmpty()) {
                            locker.wait();
                        }

                        MyTimerTask task = queue.peek();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task.getTime()) {
                            task.getRunnable().run();
                            queue.poll();
                        }else {
                            ;
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

public class Demo3 {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(3000);
            }
        },3000);

        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(2000);
            }
        },2000);

        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(1000);
            }
        },1000);

        System.out.println("计时器开始");
    }
}

这里为什么会报错呢？

3.5 定时器的修改及优化

这里我们遗漏了一个细节，前面学习优先级队列的时候，我们知道优先级队列当中的元素必须是可比较的元素，跟 TreeMap 和 TreeSet 是一样的，但是 MyTimerTask 是一个类，类与类之间是不能够进行大小的比较的，所以我们需要重写 MyTimerTask 中的 compareTo 方法来指明比较方式。

java 复制代码 
class MyTimerTask implements Comparable<MyTimerTask>{
    private long time;
    private Runnable runnable;
    public MyTimerTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }

    public long getTime() {
        return this.time;
    }

    public Runnable getRunnable() {
        return this.runnable;
    }

    @Override
    public int compareTo(MyTimerTask o) {
        return (int) (this.time - o.time);
    }
}

当进行这样的修改之后，堆中的元素就是可比较的了。写到这里其实功能就已经实现了，但是呢？还需要做出优化：当堆顶元素未到达执行时间的时候，难道真的什么都不用做吗？如果什么都不做的话，那么代码就会回到上面的while循环部分，继续判断堆顶元素是否到达了执行时间，因为计算机的执行速度很快，那么在这个到达执行堆顶元素任务的时间之内又进行了上万次判断，那么这种情况就叫做忙等。要想解决这个忙等问题，当判断未到达堆顶元素的执行时间的时候，我们让该线程等待一定的时间，不让这个线程继续循环判断。

java 复制代码 
	public MyTimer() {
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    synchronized (locker) {
                        while (queue.isEmpty()) {
                            locker.wait();
                        }

                        MyTimerTask task = queue.peek();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task.getTime()) {
                            task.getRunnable().run();
                            queue.poll();
                        }else {
                            locker.wait(task.getTime() - curTime);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }

到这里就可以说说前面 schedule 方法的 notify 方法的又一个好处：如果在 Timer 计时器在等待执行堆顶元素的过程中，又加入了一个任务，并且这个任务的执行时间先于之前堆顶元素任务的执行时间，那么当添加完成之后就会唤醒 Timer 计时器的等待状态，然后将这个刚加入的任务放入堆顶，并且下一个执行该任务。

4. 计时器完整代码

java 复制代码 
import java.util.PriorityQueue;

class MyTimerTask implements Comparable<MyTimerTask>{
    private long time;
    private Runnable runnable;
    public MyTimerTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }

    public long getTime() {
        return this.time;
    }

    public Runnable getRunnable() {
        return this.runnable;
    }

    @Override
    public int compareTo(MyTimerTask o) {
        return (int) (this.time - o.time);
    }
}

class MyTimer {
    PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
    private static Object locker = new Object();

    public void schedule(Runnable runnable, long delay) {
        synchronized (locker) {
            queue.offer(new MyTimerTask(runnable,delay));
            locker.notify();
        }
    }

    public MyTimer() {
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    synchronized (locker) {
                        while (queue.isEmpty()) {
                            locker.wait();
                        }

                        MyTimerTask task = queue.peek();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task.getTime()) {
                            task.getRunnable().run();
                            queue.poll();
                        }else {
                            locker.wait(task.getTime() - curTime);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

public class Demo3 {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(3000);
            }
        },3000);

        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(2000);
            }
        },2000);

        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(1000);
            }
        },1000);

        System.out.println("计时器开始");
    }
}
相关推荐
测开小菜鸟17 分钟前
使用python向钉钉群聊发送消息
java·python·钉钉
P.H. Infinity1 小时前
【RabbitMQ】04-发送者可靠性
java·rabbitmq·java-rabbitmq
生命几十年3万天1 小时前
java的threadlocal为何内存泄漏
java
caridle1 小时前
教程：使用 InterBase Express 访问数据库（五）：TIBTransaction
java·数据库·express
^velpro^2 小时前
数据库连接池的创建
java·开发语言·数据库
苹果醋32 小时前
Java8-＞Java19的初步探索
java·运维·spring boot·mysql·nginx
秋の花2 小时前
【JAVA基础】Java集合基础
java·开发语言·windows
小松学前端2 小时前
第六章 7.0 LinkList
java·开发语言·网络
Wx-bishekaifayuan2 小时前
django电商易购系统-计算机设计毕业源码61059
java·spring boot·spring·spring cloud·django·sqlite·guava
customer082 小时前
【开源免费】基于SpringBoot+Vue.JS周边产品销售网站（JAVA毕业设计）
java·vue.js·spring boot·后端·spring cloud·java-ee·开源
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测05(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明06【经验分享】Ubuntu22.04安装微信(linux官方版)07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）09RAG 实践- Ollama+RagFlow 部署本地知识库10你还在傻傻的打开页面输用户名和密码？来我教你实现自动化