【Java多线程案例】定时器

最新推荐文章于 2024-05-16 15:30:42 发布
最新推荐文章于 2024-05-16 15:30:42 发布
阅读量619 收藏 22
点赞数 14
分类专栏： 多线程编程 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62533201/article/details/136123132
版权

1. 定时器简介

定时器：想必大家一定对定时器这个概念不陌生！因为它经常出现在我们的日常生活和编程学习中，定时器就好比是一个"闹钟"，会在指定时间处理某件事（例如响铃），而在编程世界中，定时器可以实现到达设定时候时执行对应代码逻辑的功能！

2. 标准库中的定时器

Java标准库中提供了 定时器 的实现，即类Timer，并且提供了schedule方法可以安排需要处理的代码，并需要提供参数delay表示多少时间后执行，下面我们就通过代码来演示Java标准库中Timer类的使用方法：

/**
 * 测试Java标准库提供的Timer类
 */
public class TestTimer {
    public static void main(String[] args) {
        // 1. 创建定时器
        Timer timer = new Timer();
        // 2. 安排任务并在3s后执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("timer 3000");
            }
        }, 3000);
        // 3. 安排任务并在2s后执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("timer 2000");
            }
        }, 2000);
        // 4. 安排任务并在1s后执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("timer 1000");
            }
        }, 1000);
        System.out.println("timer main");
    }
}

运行效果：
image.png
可以看到，程序启动后，分别在1s，2s，3s时刻打印timer 1000、timer 2000、timer 3000，并且分线程是一个 前台线程 ，如果用户不强制停止主线程运行，分线程不会结束，会一直等待任务的加入！

3. 自定义定时器

3.1 前置准备

现在我们想要自己来模拟实现Java标准库中的定时器，应该准备哪些内容呢？

  1. 首先我们需要设计一个数据结构用来保存需要处理的逻辑业务以及对应执行的时间，即标准库中提供的 TimerTask 类
  2. 其次Timer类内部需要有一个数据结构来保存多个TimerTask对象，并且我们需要尽快的找到最先执行的任务（PS：如果时间最早的任务都不需要执行，那么后续的任务都不需要考虑执行），因此我们考虑使用 优先级队列 这样的数据结构进行保存
  3. 最后由于Timer内部需要不断判断当前时间是否达到某个任务的执行时间，因此内部一定有一个 分线程 不断扫描优先级队列进行判断操作

3.2 基本实现

3.2.1 实现MyTimerTask类

现在我们先来自定义数据结构MyTimerTask用来模拟Java标准库中的TimerTask类，该类的主要功能就是保存需要处理执行的业务逻辑代码以及对应执行的时间：
TimerTask：

/**
 * 自定义TimerTask类
 */
public class MyTimerTask {
    private Runnable runnable; // 需要执行的代码
    private long executeTime; // 执行时间

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

    public void run() {
        runnable.run();
    }

    public long getExecuteTime() {
        return executeTime;
    }
}

我们定义了成员变量runnable用于表示需要处理执行的业务逻辑代码，executeTime表示该任务预计执行时间（当前系统时间+延迟时间delay），并且提供构造方法初始化这两个成员变量

注意：仔细思考一下，这个代码其实有个致命的问题！因为我们在设计之初就规定好Timer类内部有一个优先级队列保存多个TimerTask任务，但是并不是所有类的实例都可以成为优先级队列的元素的，只有实现比较器重写比较方法的类才可以成为优先级队列的元素！！！

实现比较器，重写比较方法主要有如下两种方式：

  1. 实现Comparable接口
  2. 实现Comparator接口

我们这里采用第一种方式：
改进后的MyTimerTask：

/**
 * 自定义TimerTask类
 */
public class MyTimerTask implements Comparable<MyTimerTask> {
    private Runnable runnable; // 需要执行的代码
    private long executeTime; // 执行时间

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

    public void run() {
        runnable.run();
    }

    public long getExecuteTime() {
        return executeTime;
    }

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

3.2.2 实现MyTimer类

实现MyTimer类主要需要关注schedule方法的实现以及分线程的执行过程

public class MyTimer {
    private PriorityQueue<MyTimerTask> queue; // 优先级队列
    private Thread t; // 分线程

    public MyTimer() {
        this.queue = new PriorityQueue<>();
        // 线程
        this.t = new Thread(() -> {
            // 不断扫描优先级队列处理
            while (true) {
                if (queue.isEmpty()) {
                    // 队列为空不处理
                    continue;
                }
                // 取出队头元素
                MyTimerTask topTask = queue.peek();
                long curTime = System.currentTimeMillis();
                if (curTime >= topTask.getExecuteTime()) {
                    // 可以执行
                    topTask.run();
                    queue.poll();
                }
            }
        });
        t.start(); // 一定要启动分线程
    }

    public void schedule(Runnable runnable, long delay) {
        MyTimerTask timerTask = new MyTimerTask(runnable, delay);
        queue.offer(timerTask);
    }
}
  • schedule方法调用后，我们创建出一个TimerTask对象，然后使用将该对象加入优先级队列中
  • 在构造方法中，我们启动分线程，该分线程循环判断当前优先级队列首元素，如果队列为空不处理，不为空就取出队首元素（此时队首元素一定是执行时间最早的），如果当前系统时间已经晚于执行时间就执行对应的任务，如果还没到达指定时间就不处理
3.2.2.1 问题（一）

但是上述代码仍然有一定问题，最明显的问题就是 线程安全问题 ！因为schedule方法中进行了入队列操作，但是并不是t线程负责调用的，而是由main主线程进行调用的，而t线程中负责取出队首元素出队列操作，这样就导致了不同线程修改同一变量的场景，就引发了本章的重点——线程安全问题

对于线程安全问题如何解决呢？其实我们已经轻车熟路了，那就是引入 锁机制 进行加锁处理！
引入锁机制后的MyTimer类：

public class MyTimer {
    private PriorityQueue<MyTimerTask> queue; // 优先级队列
    private Thread t; // 分线程
    private Object locker = new Object();

    public MyTimer() {
        this.queue = new PriorityQueue<>();
        // 线程
        this.t = new Thread(() -> {
            // 不断扫描优先级队列处理
            while (true) {
                synchronized (locker) {
                    if (queue.isEmpty()) {
                        // 队列为空不处理
                        continue;
                    }
                    // 取出队头元素
                    MyTimerTask topTask = queue.peek();
                    long curTime = System.currentTimeMillis();
                    if (curTime >= topTask.getExecuteTime()) {
                        // 可以执行
                        topTask.run();
                        queue.poll();
                    }
                }

            }
        });
        t.start(); // 一定要启动分线程
    }

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

注意：synchronized加锁位置一定需要放在while (true)循环内部！试想一下，如果把加锁位置放在while (true)外部，那么当构造方法一调用，就会尝试给t线程加锁，此时t线程进入死循环判断永远都没有释放锁，这时进行入队列操作的schedule方法没有机会获取到锁对象！

3.2.2.2 问题（二）

但是现有的代码依旧存在问题！如果有小伙伴了解轻量级锁的实现就可以知道当前代码t线程内部使用while循环不断尝试加锁，这种类似于自旋锁的实现方式执行速度非常快，很容易再次获取到锁对象，因此该代码实际上也会导致其他线程饿死！因此我们引入 wait/notify 机制解决该问题：

public class MyTimer {
    private PriorityQueue<MyTimerTask> queue; // 优先级队列
    private Thread t; // 分线程
    private Object locker = new Object();

    public MyTimer() {
        this.queue = new PriorityQueue<>();
        // 线程
        this.t = new Thread(() -> {
            // 不断扫描优先级队列处理
            while (true) {
                synchronized (locker) {
                    try {
                        while (queue.isEmpty()) {
                            // 队列为空不处理
                            locker.wait();
                        }
                        // 取出队头元素
                        MyTimerTask topTask = queue.peek();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= topTask.getExecuteTime()) {
                            // 可以执行
                            topTask.run();
                            queue.poll();
                        } else {
                            locker.wait(topTask.getExecuteTime() - curTime); // 阻塞等待
                        }
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                }

            }
        });
        t.start(); // 一定要启动分线程
    }

    public void schedule(Runnable runnable, long delay) {
        synchronized (locker) {
            MyTimerTask timerTask = new MyTimerTask(runnable, delay);
            queue.offer(timerTask);
            locker.notify(); // 线程唤醒
        }
    }
}

由于wait方法执行时阻塞等待并且释放锁，因此可以让其他线程获取到锁对象，于是我们就彻底解决了线程安全问题，我们编写如下测试类：

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

运行结果：
image.png

米饭好好吃.
关注
  • 14
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程编程_java多线程_
09-29
1.讲解了Java多线程的基础， 包括Thread类的核心API的使用。2.讲解了在多线程中对并发访问的控制， 主要就是synchronized的使用， 由于此关键字在使用上非常灵活， 所以书中用了很多案例来介绍此关键字的使用， 为...
Java多线程案例之定时器
trong_ 的烂笔头
01-24 1720
定时器是一种实际开发中非常常用的组件, 类似于一个 “闹钟”, 达到一个设定的时间之后, 就执行某个指定好的代码.
Java多线程案例——定时器
如风暖阳的博客
05-09 872
Java多线程案例——定时器
Java多线程案例【定时器】
积跬步以至千里
10-19 2053
定时器也是软件开发中的一个重要组件. 类似于一个“闹钟”. 达到一个设定的时间之后, 就执行某个指定好的代码1.比如网络通信中, 如果对方 500ms 内没有返回数据, 则断开连接尝试重连2.比如一个 Map, 希望里面的某个 key 在 3s 之后过期(自动删除)以上类似于这样的场景就需要用到定时器。
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5359
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
教你实现多线程案例定时器
欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
08-05 613
当我们在做计划的时候,有事就会定个闹钟或者利用待办事项来提醒你要做这件事了,并且哪件事安排的时间最早就先执行谁.而我们软件开发中的定时器也是一样的--------需要我们安排任务并且记录多长时间后执行此任务.在Java标准库中定时器是利用Timer类,通过调用timer类的schedule方法来表示多长时间后执行什么任务.schedule方法第一个参数是表示要执行的任务(TimerTask类这个类实现了Runnable接口),第二个参数表示多长时间后执行。...
【多线程案例】Java实现简单定时器（Timer）
m0_73381672的博客
10-10 304
在日常生活中,如果我们想要在 t 时间 后去做一件重要的事情,那么为了防止忘记,我们就可以使用闹钟的计时器功能,它会在t时间后执行任务（响铃）提醒我们去执行这件事情. — 这就是Java定时器的简单功能。它作为一种日常开发组件。约定一个时间，时间到达之后，执行某个任务。常被用于网络通信。 ​
多线程案例之定时器
panpanaa的博客
10-28 387
多线程案例之定时器
多线程案例-实现定时器
chenchenchencl的博客
01-11 6436
多线程案例-实现定时器
java多线程案例-定时器
萌新
03-25 500
定时器是软件开发中的一个重要组件。类似于一个 “闹钟”,达到一个设定的时间之后, 就执行某个指定好的代码访问某个网站出现了网络卡顿，浏览器就会转圈圈(阻塞等待)，这个等待不是无限的等待，到达一定时间以后，就显示超时访问在前端开发中网站上的动画效果，也是通过定时器实现的，比如每隔30ms，把页面往下滚动几个像素。
多线程案例——定时器
AwwzJ_0821的博客
03-18 346
定时器类似一个闹钟，经过指定的时间后执行要求的代码。1.描述一个任务： Runnable +time 2.使用优先级队列来组织若干个任务：PriorityBlockingQueue 3. 实现 schedule方法来将任务放入优先级队列中 4.创建一个线程，用这个扫描线程不断获取队列的队首元素，并且判断时间是否到达 5.注意：①让 MyTimerTask支持比较；②解决线程的忙等问题
java范例开发大全源代码
10-30
第1篇 Java编程基础 　第1章 Java开发环境的搭建（教学视频：9分钟） 2 　1.1 理解Java 2 　1.2 搭建Java所需环境 3 　1.2.1 下载JDK 3 　1.2.2 安装JDK 4 　1.2.3 配置环境 5 　1.2.4 测试JDK配置...
JAVA 范例大全 光盘 资源
03-07
第21章 Java程序综合案例：教务处管理系统 705 21.1 登录界面的设计与代码实现 705 21.2 功能选择界面的设计 708 21.3 学生信息系统界面的设计 716 21.4 教师信息系统界面的设计 727 21.5 领导信息系统界面的...
Java范例开发大全 (源程序）
04-27
　第13章 多线程编程（教学视频：121分钟） 405 　13.1 多线程的五种基本状态 405 　实例222 启动线程 405 　实例223 参赛者的比赛生活（线程休眠唤醒） 407 　实例224 资源搜索并下载（线程...
jar包增量更新分析
junlaiyan的专栏
05-16 245
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 611
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
最新发布
yzqy_的博客
05-16 896
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
命令执行漏洞（二）
XLbb的博客
05-15 896
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
Java 多线程 定时器
07-28
在Java中，可以使用多线程和定时器来实现定时任务。你可以通过创建一个继承自Thread类或实现Runnable接口的类来定义一个线程，并在run方法中编写线程的...你可以根据自己的需求选择适合的方式来实现Java多线程定时器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值