多线程之定时器 - 详解

已于 2023-03-24 09:29:13 修改
阅读量910 收藏 1
点赞数
分类专栏： javaee 文章标签： java jvm servlet 定时器 后端
于 2023-03-24 09:26:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69119792/article/details/129734044
版权

前言

本篇了解定时器的方法，参数，并模拟实现定时器，进一步对定时器有了更深的理解，如有错误，请在评论区指正，让我们一起交流，共同进步！

文章目录


本文开始

1. 认识定时器

1.什么是定时器？
定时器就是设置一个时间，等待时间到了，就执行已经写好的代码；

2.定时器的类
Java标准库提供的定时器：Timer 它是java.util提供的一个类；
定时器的核心方法：schedule()；
它有两个参数：第一个是实现要执行的任务代码，第二个是多长时间之后执行（毫秒级别）；

定时器代码实现：

import java.util.Timer;
import java.util.TimerTask;

public class Test {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("run2");
            }
        },2000);
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("run1");
            }
        },1000);
        System.out.println("main");
    }
}

【注】这里的new TimerTask() 接口实现了Runnable 方法；

2. 模拟实现定时器

2.1 创建MyTimer类

定时器主要的类就是Timer，这里就得自己实现！
实现这个类就需要用到带有优先级的阻塞队列，为什么呢？
定时器内部有很多任务需要管理，多个线程可能都在执行schedule方法，但是它们的执行时间是不同的，就需要让他们按照顺序执行，并保证线程是安全的，这就用到了带有优先级的阻塞队列；

在多线程条件下，为了保证线程是安全的，此时Java标准库中有优先级阻塞队列就满足这些条件；
使用优先级阻塞队列: PriorityBlockingQueue

但是问题又来了，优先级阻塞队列里面放置什么元素呢？
优先级队列中存放的元素是什么？
因为放置的元素不是单一的，需要创建一个类，封装一下①执行的任务是什么(Runnable)；②任务什么时候执行(time)

2.2 创建优先级队列中放置的元素MyTask

1.描述执行的任务
public Runnable runnable;
2.描述要执行任务的时间点
public long time;
这里为了方便后续判定，使用绝对的时间戳;
取当前时刻的时间戳 + delay, 作为该任务实际执行的时间戳;
3.构造方法为下面初始化参数做准备
构造public MyTask()

2.3 在MyTimer类写核心方法schedule

1.参数
①Runnable runnable - 执行的任务；② long delay - 执行任务要等待的时间;
2.根据参数构造创建对象MyTask, 并把对象插入到阻塞队列中

    public void schedule(Runnable runnable, long delay) {
        //创建任务，并放入阻塞队列中， 此时也应该在MyTask任务中写带有两个构造参数的构造方法
        MyTask myTask = new MyTask(runnable,delay);
        queue.put(myTask);
    }

2.4 构造线程，执行具体任务

1.创建无参 public MyTimer() {…}
2.创建线程 t
3.使用循环，每次取出阻塞队列中的元素(任务)，获取当前任务的当前时间，判断任务执行时间与当前时间的大小；

    public MyTimer() {
        Thread t = new Thread( () -> {
           //使用循环不断取出阻塞队列中的元素，比较是否到任务执行的时间
           while (true) {
               try {
                   //取出阻塞队列中的元素
                   MyTask myTask = queue.take();
                   //获取当前任务的时间
                   long curTime = System.currentTimeMillis();
                   //比较时间到了就执行任务，时间没有到就放回到阻塞队列中
                   if(myTask.time < curTime) {
                       //执行任务
                       myTask.runnable.run(); 
                   }else {
                       //放回阻塞队列中
                       queue.put(myTask);
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }

基本的定时器框架已经完成，但是并不能执行，思考一下，这个定时器存在什么问题呢？？？
从代码中分析一下吧！定时器不完全代码：

class MyTask {
    public Runnable runnable;//描述要执行的任务
    public long time;//描述任务要执行的时间 =》 这里采取绝对时间
    public MyTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        //当前时间 + dealy = 执行任务的时间
        this.time = System.currentTimeMillis() + delay;
    }
}
class MyTimer {
    //构造优先级阻塞队列
    PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
    //构造schedule方法,delay=> 延迟
    public void schedule(Runnable runnable, long delay) {
        //创建任务，并放入阻塞队列中， 此时也应该在MyTask任务中写带有两个构造参数的构造方法
        MyTask myTask = new MyTask(runnable,delay);
        queue.put(myTask);
    }
    //创建线程
    public MyTimer() {
        Thread t = new Thread( () -> {
           //使用循环不断取出阻塞队列中的元素，比较是否到任务执行的时间
           while (true) {
               try {
                   //取出阻塞队列中的元素
                   MyTask myTask = queue.take();
                   //获取当前任务的时间
                   long curTime = System.currentTimeMillis();
                   //比较时间到了就执行任务，时间没有到就放回到阻塞队列中
                   if(myTask.time < curTime) {
                       //执行任务
                       myTask.runnable.run(); 
                   }else {
                       //放回阻塞队列中
                       queue.put(myTask);
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }

}

来看一下存在的问题！！！

2.5 出现的两种问题

1.优先级队列的比较规则
产生原因：在优先级阻塞队列中，每个任务执行的时间是不同的，为了保证有序执行，使用优先级阻塞队列，但是比较两个任务的执行时间的规则没有定，无法正常排序，所以需要实现自定义的比较规则；
解决方式：实现Comparable方法，重写comparTo()
代码实现：

class MyTask implements Comparable<MyTask>{
    public Runnable runnable;//描述要执行的任务
    public long time;//描述任务要执行的时间 =》 这里采取绝对时间
    public MyTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        //取当前时刻的时间戳 + delay, 作为该任务实际执行的时间戳
        //currentTimeMillis()=> 时间戳：当前时刻和基准时刻的ms数之差
        this.time = System.currentTimeMillis() + delay;
    }

    @Override
    public int compareTo(MyTask o) {
        //获取每次取出最小的时间
        return (int)(time - o.time);
    }
}

2.忙等
产生原因：假设一个任务执行的时间为12点，当前时间是11点30；在这期间，一直读取当前时间，cup一直处于被暂用的状态，会有资源的浪费 =》这就是忙等
解决方式：当没有到达任务要执行的时间，使用wait()方法等待，等时间到了再执行；
【注】wait() 需要配合加锁一起操作，就需要创建新的锁对象;
代码实现：在MyTimer中创建锁对象，调用wait()方法，这里简化跟上述重复的代码就不写了，只写增加的代码的部分；

//在MyTimer内
  	//使用wait方法，就需要加锁，加锁就需要锁对象，创建锁对象
    private Object locker = new Object();
    
        //创建线程
    public MyTimer() {
        Thread t = new Thread( () -> {
           while (true) {
               try {
                   synchronized (locker) {
                       //取出阻塞队列中的元素
                       MyTask myTask = queue.take();
                       //获取当前任务的时间
                       long curTime = System.currentTimeMillis();
                       if(myTask.time < curTime) {
                           //执行任务
                           myTask.runnable.run(); //???
                       }else {
                           //时间没到，放回阻塞队列中
                           queue.put(myTask);
                           //防止忙等，使用wait等待时间的差值
                           locker.wait(myTask.time - curTime);
                       }
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }

加锁wait()后，发现如果出现新的任务怎么办呢？
解决方式：在插入阻塞队列时，唤醒wait(), 可以使用notify()
代码实现：

    //构造schedule方法,delay=> 延迟
    public void schedule(Runnable runnable, long delay) {
        //创建任务，并放入阻塞队列中， 此时也应该在MyTask任务中写带有两个构造参数的构造方法
        MyTask myTask = new MyTask(runnable,delay);
        queue.put(myTask);
        //在加入新任务的时候，就唤醒
        synchronized (locker) {
            locker.notify();
        }
    }

2.6 测试代码

测试思想描述：
创建定时器，多个线程调用schdule方法，规定执行的任务和经过多次时间执行这个任务；

主函数测试代码：

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

执行结果：

在这里插入图片描述

3. 定时器总代码

代码如下：

import sun.applet.Main;

import java.util.concurrent.PriorityBlockingQueue;
//创建一个类封装一些，用来表示一个任务
class MyTask implements Comparable<MyTask>{
    //描述执行的任务
    public Runnable runnable;
    //为了方便后续判定，使用绝对时间戳
    public long time;//描述这个任务要执行的时间点 =》 任务要执行的绝对时间

    public MyTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        //取当前时刻的时间戳 + delay, 作为该任务实际执行的时间戳
        //currentTimeMillis()=> 时间戳：当前时刻和基准时刻的ms数之差
        this.time = System.currentTimeMillis() + delay;
    }

    //阻塞队列的比较规则
    @Override
    public int compareTo(MyTask o) {
        //每次取出时间最小的元素
        return (int)(time - o.time);
    }
}
class MyTimer {
    //使用带有优先级的阻塞队列
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
    //①优先级的比较规则：阻塞队列中MyTask元素的比较，需要设置一个比较规则

    //创建锁对象，进行加锁操作
    private Object locker = new Object();

    //定时器中的schedule方法
    //delay: 是一个像2000这样的数字（表示怎么长时间后，执行该任务）
    public void schedule(Runnable runnable, long delay) {
        //根据参数，构造MyTask, 插入阻塞对列
        MyTask myTask = new MyTask(runnable,delay);
        queue.put(myTask);
        //新的任务来了：插入元素的时候，唤醒等待
        synchronized (locker) {
            locker.notify();
        }
    }

    //构造线程，负责执行具体的任务
    public MyTimer() {
        //创建线程
        Thread t = new Thread( () -> {
            //②忙等：循环true会一直访问（相当于一直看时间到了执行时间没有）这样会一直占用cpu =》这就是忙等
            //解决方法：等待过程需要释放cpu，使用wait操作，可以随时提前结束
           while (true) {
               try {
                   //了解阻塞队列，只有则是队列的入队列和出队列，没有阻塞队列的查看对首元素
                   // =》只能出队列后才能看到该任务并判断到执行时间了没有，没有会塞会阻塞队列中
                   synchronized (locker) {
                       //取出阻塞队列中的元素
                       MyTask myTask = queue.take();
                       //获取当前任务的时间
                       long curTime = System.currentTimeMillis();
                       if(myTask.time <= curTime) {
                           //时间到了，执行任务；=》执行时间小于当前时间
                           myTask.runnable.run();  //???
                       }else {
                           //执行任务的时间还没到，
                           //把刚才取出的任务，重新塞会阻塞队列中
                           queue.put(myTask);
                           locker.wait(myTask.time - curTime);
                           //等待过程中，新任务来了为什么要中间唤醒原来的等待？？？
                           //因为可能会遇到下一个任务的时间比等待的时间要短的任务
                           // 此时唤醒等待，在取任务元素的时候，就会取到时间短的任务 =》 任务有优先级的排列
                           
                       }
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("run3");
            }
        },3000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("run2");
            }
        },2000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("run1");
            }
        },1000);
        System.out.println("main");
    }
}

总结

✨✨✨各位读友，本篇分享到内容如果对你有帮助给个👍赞鼓励一下吧！！
感谢每一位一起走到这的伙伴，我们可以一起交流进步！！！一起加油吧！！！

多线程案例之定时器
azhe12345690的博客
04-21 283
定时器是什么？ 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定好的代码. 我们先来看看标准库中的定时器： 标准库中提供了一个 Timer 类. Timer 类的核心方法为 schedule . schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后 执行 (单位为毫秒). 这里我们注意一下这个schedule方法，这里面其实就是实现了一个Runnable接口，这为我们后面自己设置定时器提供了思路。运行结果： 接下来我们实现自己的一个定时器：
java多线程之定时器Timer的使用详解
08-30
Java中的`Timer`类是用于实现定时计划任务的核心组件，它基于多线程机制，允许开发者在指定时间点或周期性地执行任务。`Timer`类的主要功能是创建一个后台线程，这个线程会按照预定的计划执行`TimerTask`实例。`...
定时器、多线程
diaochuanzhi7826的博客
02-17 197
1、几种定时介绍 1.1 NSTimer 定时器 1.2 CADisplayLink 定时器 1.3 子线程定时器的创建 2、定时任务 1）performSelector // 延时调用 /* 1.5 秒后自动调用 self 的 hideHUD 方法 */ [self performSelector:@selector(hideHUD) withObject:nil aft...
多线程——定时器
最新发布
HKJ_numb1的博客
10-31 892
本篇文章会利用多线程的知识来编写一个代码案例——定时器，我会先介绍一下什么是定时器，再来介绍一下我们标准库中的定时器以及操作演示我们标准库中定时器的效果，最后我来手撕出来一个功能上与所演示标准库中定时器效果差不多的定时器，并对其实现的具体逻辑，在代码中进行详细介绍，那么就开始本篇文章介绍的内容吧。
多线程之定时器
qq_56444564的博客
02-11 230
定时器也是软件开发中的一个重要组件. 类似于一个 "闹钟". 达到一个设定的时间之后, 就执行某个指定好的代码.比如网络通信中, 如果对方 500ms 内没有返回数据, 则断开连接尝试重连.比如一个 Map, 希望里面的某个 key 在 3s 之后过期(自动删除).定时器是一种实际开发中非常常用的组件.类似于这样的场景就需要用到定时器.
【多线程】定时器
m0_61814277的博客
07-27 3858
本期内容主要介绍定时器，定时器类Timer的使用以及核心方法schedule()，并介绍如何自己实现一个定时器。
多线程定时器
weixin_45412364的博客
02-06 114
定时器构成： 使用一个Task类来描述一段逻辑，同时记录该任务执行时间 使用一个阻塞优先队列，组织若干个Task 还需要一个扫描线程，检测队首元素是否需要执行 import java.util.concurrent.PriorityBlockingQueue; public class Thread1 { //定时器 //Task类用来描述一段逻辑 static class Task implements Comparable<Task>{ //优先队列中的元素必
详解Python 多线程 Timer定时器/延迟执行、Event事件
09-19
Python中的多线程是并发处理任务的重要工具，而`Timer`和`Event`则是Python标准库`threading`模块中的两个关键组件，用于控制线程的执行时机和交互。 `Timer`类是`Thread`的子类，它提供了一种定时执行任务的功能。...
JAVA多线程编程详解-详细操作例子
03-24
在 Java 中，多线程编程是一种强大的工具，它允许多个任务在同一个程序中并发执行，从而提高应用程序的效率和响应性。Java 为多线程编程提供了丰富的支持，包括两种主要的实现方式：继承 `Thread` 类和实现 `...
LabWindows/CVI多线程与异步定时器编程详解
在LabWindows/CVI 6.0中，多线程技术和异步定时器是实现高效并发操作的关键技术。 多线程在LabWindows/CVI中允许主线程和子线程并行执行任务。例如，主线程可以通过`CmtScheduleThreadPoolFunction`创建线程池，并...
线程中的定时器
weixin_51500673的博客
04-20 917
定时器是一种控制任务延时调用，或者周期调用的技术。 定时器的实现方式 方式一：Timer publicvoidschedule​(TimerTasktask, longdelay, longperiod)。 task:处理的任务 delay：延迟时间 perriod：周期时间 package com.itheima.d7_timer; import java.util.Timer; import java.util.TimerTask; public class TimerDe...
多线程案例（三）：定时器
Fug_Lee的博客
03-03 952
多线程案例之定时器
多线程（六）定时器
Aming_he博客
08-14 245
定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。在Java中，可以通过Timer和TimerTask类来实现定义调度的功能 Timer public Timer() public void schedule(TimerTask task, long delay) public void schedule(TimerTask task,long delay,long ...
多线程案例——定时器
weixin_48796138的博客
04-04 1247
目录🍉 定时器🍉标准库中的定时器🍉如何自己实现一个定时器🍉 自定义定时器总结 🍉 定时器 定时器就像是一个闹钟,在一定时间后被唤醒,唤醒后执行之前计划好的任务 可能有小伙伴会想到我们之前学的join和sleep方法,他们所起到的效果和定时器差不多,但本质上有区别,他们是基于系统内部定时器来实现的. 🍉标准库中的定时器 我们先学习一下标准库中的定时器,然后再设计一个自己的定时器 想必java.util大家都不会陌生,他还有一个类是我们使用定时器能够用到的,叫做 java.util.Timer,其中核心方法
线程的定时器
Avices
08-10 591
定时器 定时器的作用：间隔特定的时间，执行特定的程序。 在java中可以采用多种方式实现定时器： 可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。 在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。 Timer类的常用方法： Timer() // 创建一个新计时器。 Timer(boolean isDaemon) // 创建一个新计时器，可以指定其相关的线程作为守护程序运行。 Timer(String nam
多线程案例 __ 定时器
kim的博客
02-03 205
定时器，又称 任务定时执行器~即：到了一定的时间，就会去执行指定的任务~在 Java标准库中，提供了一个带有定时器功能的Timer类，Timer类 的核心方法是schedule方法schedule方法 包含了两个参数，第一个参数为 即将要执行的任务代码TimerTask，第二个参数为 指定多长时间后执行地一个参数中的代码（单位是 毫秒）~@Override}, 3000);
线程 —— 定时器介绍
李威威的博客
07-25 1021
TimerTask 是一个抽象类，实现 TimerTask 的 run 方法。示例 1：/** * Created by liwei on 16/7/19. */ /* * 定时器：可以让我们在指定的时间做某件事情，还可以重复的做某件事情。 * 依赖Timer和TimerTask这两个类： * Timer:定时 * public Timer() * public v
线程的定时器问题
qq_45726327的博客
04-01 1400
多线程的定时器是一种在多线程环境下实现定时任务的技术。它能够让多个线程在指定的时间点执行特定的任务，而不需要每个线程都自己实现一个定时器。使用多线程的定时器可以避免线程阻塞和任务调度的复杂性，提高代码的可读性和可维护性。在多线程的定时器中，一般通过一个定时器线程来维护所有的定时任务，该线程负责按照指定的时间间隔检查所有的任务，并在任务的执行时间点将任务放入一个线程池中，让线程池中的线程来执行任务。多线程的定时器可以通过Java内置的Timer类来实现，也可以使用第三方框架，如Quartz等。
Java的多线程定时器
01-14 562
Java写的一个定时器，多线程： /* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值