【Java|多线程与高并发】定时器(Timer)详解

最新推荐文章于 2024-04-24 22:52:03 发布
最新推荐文章于 2024-04-24 22:52:03 发布
阅读量5.5k 收藏 19
点赞数 10
分类专栏： 从零开始的Java学习之旅 # 多线程与高并发的那些事 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63463510/article/details/131376176
版权

文章目录

1. 前言

在Java中，定时器Timer类是用于执行定时任务的工具类。它允许你安排一个任务在未来的某个时间点执行，或者以固定的时间间隔重复执行。

在服务器开发中,客户端向服务器发送请求,然后等待服务器响应. 但服务器什么时候返回响应,并不确定. 但也不能让客户端一直等下去, 如果一直死等,就没有意义了. 因此通常客户端会通过定时器设置一个"等待的最长时间".
在这里插入图片描述

2. 定时器的基本使用

Java的标准库库中就给我们提供了一个定时器Timer类

可以看到Timer这个类在很多包里面都有,注意要选择java.util里的

在这里插入图片描述

其中在Timer类中有一个十分重要的方法- schedule()方法
在这里插入图片描述

形参：

  • task：要执行的任务，必须是TimerTask的子类，可以通过继承TimerTask类并重写run()方法来定义具体的任务逻辑。
  • time：指定任务执行的时间，类型为java.util.Date。

当然一个Timer类中也可以执行设置多个任务.

示例:

public class Demo17 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("1s!");
            }
        },1000);
        
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("2s!");
            }
        },2000);
        
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("3s!");
            }
        },3000);
    }
}

运行结果:

在这里插入图片描述
仔细观察运行结果,会发现这个程序有些问题,为什么程序执行完了,进程没有退出呢?

是因为Timer内部需要一组线程来执行注册任务,这里的线程是前台线程,会影响进程的退出

3. 实现定时器

实现定时器,最主要的就是实现里面的schedule方法

class MyTask{
    // 要执行的任务
    private Runnable runnable;
    // 时间
    private long time;

    public MyTask(Runnable runnable, long time) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + time;
    }
}
public class MyTimer {
    public void schedule(Runnable runnable, long time){
        MyTask myTask = new MyTask(runnable,time);
    }
}

System.currentTimeMillis()是Java中的一个静态方法，用于获取当前时间的毫秒数。

描述一个任务,以及多久后执行定时器的第一步完成了

接下来就是如何让这个定时器能够管理多个任务,例如上述示例中输出1s,2s,3s的那个示例一样

关于如何管理这些任务,我们肯定是想让设置时间短的任务先执行,但是在设置任务时,不一定会按照时间从小到大的顺序去进行放入. 这时候就要使用到 优先级队列(PriorityQueue)

但是优先级队列并不是线程安全的, 在多线程环境下使用优先级队列可能会出现问题,我们可以使用阻塞队列
不要忘了,我们可以创建一个带有优先级的阻塞队列
在这里插入图片描述

将任务添加到阻塞队列中即可.

但是优先级队列的对象的类型必须是可比较的. 我们可以让Mytask实现Comparable接口,实现里面的compareTo方法. 比较的规则就是时间,时间小的优先级高.

接下来就要检查队首任务的时间是否到了,时间到了就要执行任务. 可以单独创建一个扫描线程来进行检查.

完整代码:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;

class MyTask implements Comparable<MyTask>{
    // 要执行的任务
    private Runnable runnable;
    // 时间
    private long time;

    public MyTask(Runnable runnable, long time) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + time;
    }

    public Runnable getRunnable() {
        return runnable;
    }

    public long getTime() {
        return time;
    }

    @Override
    public int compareTo(MyTask o) {
        return (int) (this.time - o.time);
    }
}
public class MyTimer {
    private BlockingQueue<MyTask> blockingQueue = new PriorityBlockingQueue<>();

    public MyTimer() {
        Thread t = new Thread(()->{
           while(true){
               try {
                   MyTask myTask = blockingQueue.take();
                   // 当前时间是否大于等于要执行任务的时间
                   if (System.currentTimeMillis() >= myTask.getTime()){
                       // 时间到了 执行任务
                       myTask.getRunnable().run();
                   }else {
                       // 时间没到,再把任务放回阻塞队列中
                       blockingQueue.put(myTask);
                   }
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        t.start();
    }

    public void schedule(Runnable runnable, long time) throws InterruptedException {
        MyTask myTask = new MyTask(runnable,time);
        blockingQueue.put(myTask);
    }
}

测试代码:

public class Demo18 {
    public static void main(String[] args) throws InterruptedException {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("2s");
            }
        },2000);

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

        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("3s");
            }
        },3000);

    }
}

运行结果:
在这里插入图片描述
结果没有问题.

4. 优化上述的定时器代码

但仔细思考上述代码中还存在一个问题:
在这里插入图片描述
这里的条件是while(true),说明程序会一直进行这里的循环, 这也是"忙等"

"忙等"是指一个线程在等待某个条件满足时，不断地进行无效的循环检查，而不释放CPU资源给其他线程执行。这种方式会浪费CPU资源，并且可能导致性能下降。

针对这个问题,我们可以使用 wait和notify来解决这个问题

通过使用wait和notify,对MyTimer这个类进行优化:

public class MyTimer {
    private BlockingQueue<MyTask> blockingQueue = new PriorityBlockingQueue<>();

    private Object locker = new Object();
    public MyTimer() {
        Thread t = new Thread(()->{
           while(true){
               try {
                   MyTask myTask = blockingQueue.take();
                   // 当前时间是否大于等于要执行任务的时间
                   if (System.currentTimeMillis() >= myTask.getTime()){
                       // 时间到了 执行任务
                       myTask.getRunnable().run();
                   }else {
                       // 时间没到,再把任务放回阻塞队列中
                       blockingQueue.put(myTask);
                       // 进行等待
                       synchronized (locker) {
                           locker.wait(myTask.getTime()-System.currentTimeMillis());
                       }
                   }
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        t.start();
    }

    public void schedule(Runnable runnable, long time) throws InterruptedException {
        MyTask myTask = new MyTask(runnable,time);
        blockingQueue.put(myTask);
        synchronized (locker) {
            locker.notify();
        }
    }
}

虽然解决了"忙等"问题,但是又带来了新的问题.

如果扫描线程再取出队首任务(10分钟后要执行)时,线程切换,执行schedule方法,新增任务(5分钟后执行)然后执行notify,但此时并没有通知线程并没有意义,因为扫描线程刚执行完take,并没有执行到wait,然后扫描线程继续执行,进行wait,等待10分钟. 这样就会把刚才新增的5分钟后执行的任务给错过了.

对于上述问题 产生的原因还是因为"锁"的粒度不够大, 这些操作不是原子的,只需放大锁的粒度即可

public class MyTimer {
    private BlockingQueue<MyTask> blockingQueue = new PriorityBlockingQueue<>();

    private Object locker = new Object();
    public MyTimer() {
        Thread t = new Thread(()->{
           while(true){
               try {
                   synchronized (locker) {
                       MyTask myTask = blockingQueue.take();
                       // 当前时间是否大于等于要执行任务的时间
                       if (System.currentTimeMillis() >= myTask.getTime()){
                           // 时间到了 执行任务
                           myTask.getRunnable().run();
                       }else {
                           // 时间没到,再把任务放回阻塞队列中
                           blockingQueue.put(myTask);
                           // 进行等待
                           locker.wait(myTask.getTime()-System.currentTimeMillis());
                       }
                   }
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        t.start();
    }

    public void schedule(Runnable runnable, long time) throws InterruptedException {
        MyTask myTask = new MyTask(runnable,time);
        blockingQueue.put(myTask);
        synchronized (locker) {
            locker.notify();
        }
    }
}

在这里插入图片描述
上述为了解决"忙等"问题,使用wait和notify进行优化,而在优化过程因为synchronized加锁的范围不一样,又带来了新的问题. 因此多线程问题很复杂,加锁的范围,线程的切换都会影响程序的执行效果.

5. 总结

文章主要介绍了定时器的基本使用,以及自定义实现定时器,实现一个定时器并不难.但如果要想将定时器实现的更好,也不是一件容易的事. 毕竟多线程环境中,很容易出现各种意想不到的问题.
在这里插入图片描述

感谢你的观看!希望这篇文章能帮到你!
专栏: 《从零开始的Java学习之旅》在不断更新中,欢迎订阅!
“愿与君共勉,携手共进!”
在这里插入图片描述

比奇堡的天没有云
关注
  • 10
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
Java定时器——Timer详解
mfmfmfo的博客
08-24 3382
Timer。
JAVA定时器JAVA定时器
12-15
JAVA定时器，只要服务开启，就能指定某些代码在某个时刻执行，例如：监狱里罪犯的余刑天数，每天都要减少，就可以设置一个定时器在每天的23：59：59来执行减少余刑天数的天。
java多线程之定时器Timer的使用详解
08-30
本篇文章主要介绍了java多线程之定时器Timer的使用详解，Time类主要负责完成定时计划任务的功能,有兴趣的可以了解一下。
【Java定时任务】SpringBoot+@Schedule注解
神也在Cpoy
01-21 535
可以看到，最大线程数使用的是Integer.MAX_VALUE，即对于每一次定时任务的执行都会创建新的线程，并发环境下，会。【3】实现类上要有组件的注解@Component，@Service，@Repository。【1】cron表达式配置的任务如果执行超时，会从上一个任务结束的时间开始计算间隔。启用@EnableAsync注解，并在每一个定时任务方法上使用@Async注解。下一次的任务执行时间是从上一次定时任务结束时间开始计算。下一次的任务执行时间是从上一次定时任务开始时间开始计算。
Java中的Timer类以及自己实现一个MyTimer
2201_75437633的博客
03-23 285
Timer类是 Java 提供的用于执行定时任务的工具类。它允许你安排任务在未来的某个时间点执行，也可以定期执行。下面是关于Timer。
Jave 定时任务：使用Timer类执行定时任务为何会发生任务阻塞？如何解决？
siaok的博客
11-19 719
java Timer类是一个用于调度任务的类，它可以在指定的时间间隔内执行一次或多次任务。它提供了一种简单的方式来安排和执行定时任务，可以用于各种应用程序中，如计划任务、定时器等。 Java Timer类位于java.util包中，它有两个主要的子类：Timer和TimerTask。其中，Timer类用于调度任务，而TimerTask类则表示一个具体的任务，需要实现run()方法来定义任务的具体行为。 如果发生任务超时，导致任务阻塞，该如何解决？
Java 中的定时器类Timer详解
swadian2008的博客
08-31 1706
Timer是Java中的一个定时器类，用于在指定时间之后执行某些任务，也可以在指定时间间隔内周期性地执行某些任务。它是在JDK 1.3中引入的。schedule(TimerTask task, Date time)：该方法用于在指定时间执行指定的任务。schedule(TimerTask task, long delay)：该方法用于在指定延迟时间之后执行指定的任务。
Java定时器（Timer）
热门推荐
老徐的博客只有干货
06-19 2万+
1.介绍 Timer和TimerTask是用于在后台线程中调度任务的java util类。简单地说，TimerTask是要执行的任务，Timer是调度器。 2.调度一次性任务 2.1 指定延迟后执行 让我们从简单地在定时器的帮助下运行单个任务开始： @Test public void givenUsingTimer_whenSchedulingTaskOnce_thenCorrect() { TimerTask task = new TimerTask() { public void
java--Timer 定时器
时光里的博客
05-26 4809
https://blog.csdn.net/qq_34291570/article/details/94874074? https://blog.csdn.net/u013164931/article/details/80762356? https://blog.csdn.net/hl_java/article/details/79035237? https://blog.csdn.net/xixi_haha123/article/details/81082321? https://blog.csdn.ne
Java Timer(定时器)
doublepg13的博客
12-14 7757
schedule(TimerTask task , Date time) // 安排在 "指定的时间" 执行 指定的任务。
Java定时器
m0_67683346的博客
09-21 6751
j认识并模拟实现ava中的定时器
Java定时器Timer使用方法详解
08-28
主要为大家详细介绍了Java定时器Timer的使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java线程Timer定时器用法详细总结
08-25
在本篇文章里小编给大家整理的是关于Java线程Timer定时器用法详细总结内容，需要的朋友们学习下吧。
Java多线程定时器Timer原理及实现
08-28
主要介绍了Java多线程定时器Timer原理及实现，涉及Timer的schedule的使用，定时器Timer的schedule等相关内容以及代码示例，具有一定参考价值，需要的朋友可以了解下。
详解Python 多线程 Timer定时器/延迟执行、Event事件
09-19
主要介绍了Python 多线程 Timer定时器/延迟执行、Event事件的相关知识，本文给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
string模拟实现
m0_73969414的博客
04-23 1403
c++中string的模拟实现，面试必会知识点
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 996
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
PageHelper实现分页查询
m0_63849044的博客
04-24 951
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
Lambda表达式特点
最新发布
weixin_57763462的博客
04-24 561
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
Java 多线程 定时器
07-28
在Java中，可以使用多线程和定时器来实现定时任务。你可以通过创建一个继承自Thread类或实现Runnable接口的类来定义一个线程，并在run方法中编写线程的执行逻辑。然后，使用定时器类Timer或ScheduledThreadPoolExecutor来调度线程的执行。 下面是一个使用定时器类Timer实现定时任务的示例代码： ```java import java.util.Timer; import java.util.TimerTask; public class MyTask extends TimerTask { public void run() { // 在这里写定时任务的逻辑 System.out.println("定时任务执行了"); } public static void main(String[] args) { Timer timer = new Timer(); MyTask task = new MyTask(); // 延迟1秒后开始执行任务，每隔2秒执行一次 timer.schedule(task, 1000, 2000); } } ``` 在上面的示例中，首先定义了一个继承自TimerTask的类MyTask，重写了run方法，在run方法中编写了定时任务的逻辑。然后，在main方法中创建了一个Timer对象和一个MyTask对象，使用schedule方法指定了任务的延迟时间和执行间隔。 当程序运行时，定时任务会在延迟1秒后开始执行，并且每隔2秒执行一次。你可以根据实际需求修改延迟时间和执行间隔。 除了使用Timer类，你还可以使用ScheduledThreadPoolExecutor类来实现定时任务。这个类提供了更灵活的定时任务调度方式，可以满足更多复杂的需求。你可以根据自己的需求选择适合的方式来实现Java多线程定时器。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

比奇堡的天没有云

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值