脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java多线程定时器Timer

Java多线程定时器Timer原理及实现

 更新时间：2017年11月14日 16:25:06   作者：五月的仓颉  
这篇文章主要介绍了Java多线程定时器Timer原理及实现，涉及Timer的schedule的使用，定时器Timer的schedule等相关内容以及代码示例，具有一定参考价值，需要的朋友可以了解下。

前言

定时/计划功能在Java应用的各个领域都使用得非常多，比方说Web层面，可能一个项目要定时采集话单、定时更新某些缓存、定时清理一批不活跃用户等等。定时计划任务功能在Java中主要使用的就是Timer对象，它在内部使用多线程方式进行处理，所以它和多线程技术关联还是相当大的。那和ThreadLocal一样，还是先讲原理再讲使用，Timer的实现原理不难，就简单扫一下就好了。

Timer的schedule(TimeTask task, Date time)的使用

该方法的作用是在执行的日期执行一次任务

1、执行任务的时间晚于当前时间：未来执行

private static Timer timer = new Timer();
static public class MyTask extends TimerTask
{
  public void run()
  {
    System.out.println("运行了！时间为：" + new Date());
  }
}
public static void main(String[] args) throws Exception
{
  MyTask task = new MyTask();
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  String dateString = "2015-10-6 12:14:00";
  Date dateRef = sdf.parse(dateString);
  System.out.println("字符串时间：" + dateRef.toLocaleString() + " 当前时间：" + new Date().toLocaleString());
  timer.schedule(task, dateRef);
}

看一下运行效果：

字符串时间：2015-10-6 12:14:00 当前时间：2015-10-6 12:13:23
运行了！时间为：Tue Oct 06 12:14:00 CST 2015

执行时间和但前时间不一致，而是和dateRef的时间一直，证明了未来执行。任务虽然执行完了，但进程没有销毁，控制台上的方框可以看到还是红色的，看下Timer的源代码：

public Timer() {
  this("Timer-" + serialNumber());
}
public Timer(String name) {
  thread.setName(name);
  thread.start();
}

所以，启动一个Timer就是启动一个新线程，但是这个新线程并不是守护线程，所以它会一直运行。要运行完就让进程停止的话，设置Timer为守护线程就好了，有专门的构造函数可以设置：

public Timer(boolean isDaemon) {
  this("Timer-" + serialNumber(), isDaemon);
}
public Timer(String name, boolean isDaemon) {
  thread.setName(name);
  thread.setDaemon(isDaemon);
  thread.start();
}

2、计划时间早于当前时间：立即执行

如果执行任务的时间早于当前时间，那么立即执行task的任务：

private static Timer timer = new Timer();
static public class MyTask extends TimerTask
{
  public void run()
  {
    System.out.println("运行了！时间为：" + new Date());
  }
}
public static void main(String[] args) throws Exception
{
  MyTask task = new MyTask();
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  String dateString = "2014-10-6 12:14:00";
  Date dateRef = sdf.parse(dateString);
  System.out.println("字符串时间：" + dateRef.toLocaleString() + " 当前时间：" + new Date().toLocaleString());
  timer.schedule(task, dateRef);
}

看一下运行效果：

字符串时间：2014-10-6 12:14:00 当前时间：2015-10-6 12:20:10
运行了！时间为：Tue Oct 06 12:20:10 CST 2015

执行时间和当前时间一致，证明了立即执行

3、多个TimerTask任务执行

Timer中允许有多个任务：

private static Timer timer = new Timer();
static public class MyTask extends TimerTask
{
  public void run()
  {
    System.out.println("运行了！时间为：" + new Date());
  }
}
public static void main(String[] args) throws Exception
{
  MyTask task1 = new MyTask();
  MyTask task2 = new MyTask();
  SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  String dateString1 = "2015-10-6 12:26:00";
  String dateString2 = "2015-10-6 12:27:00";
  Date dateRef1 = sdf1.parse(dateString1);
  Date dateRef2 = sdf2.parse(dateString2);
  System.out.println("字符串时间：" + dateRef1.toLocaleString() + " 当前时间：" + new Date().toLocaleString());
  System.out.println("字符串时间：" + dateRef2.toLocaleString() + " 当前时间：" + new Date().toLocaleString());
  timer.schedule(task1, dateRef1);
  timer.schedule(task2, dateRef2);
}

看一下运行结果：

字符串时间：2015-10-612:26:00当前时间：2015-10-612:25:38

字符串时间：2015-10-612:27:00当前时间：2015-10-612:25:38

运行了！时间为：TueOct0612:26:00CST2015

运行了！时间为：TueOct0612:27:00CST2015

可以看到，运行时间和设置的时间一致，证明了未来可以执行多个任务。另外注意，Task是以队列的方式一个一个被顺序执行的，所以执行的时间有可能和预期的时间不一致，因为前面的任务可能消耗过长，后面任务的运行时间也有可能被延迟。

代码就不写了，举个例子，任务1计划12:00:00被执行，任务2计划12:00:10被执行，结果任务1执行了30秒，那么任务2将在12:00:30被执行，因为Task是被放入队列中的，因此必须一个一个顺序运行。

Timer的schedule(TimerTasktask,DatefirstTime,longperiod)

该方法的作用是在指定的日期之后，按指定的间隔周期性地无限循环地执行某一人物

1、计划时间晚于当前时间：未来执行

static public class MyTask extends TimerTask
{
  public void run()
  {
    System.out.println("运行了！时间为：" + new Date());
  }
}
public static void main(String[] args) throws Exception
{
  MyTask task = new MyTask();
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  String dateString = "2015-10-6 18:00:00";
  Timer timer = new Timer();
  Date dateRef = sdf.parse(dateString);
  System.out.println("字符串时间：" + dateRef.toLocaleString() + " 当前时间：" + new Date().toLocaleString());
  timer.schedule(task, dateRef, 4000);
}

看一下运行结果：

字符串时间：2015-10-6 18:01:00 当前时间：2015-10-6 18:00:15
运行了！时间为：Tue Oct 06 18:01:00 CST 2015
运行了！时间为：Tue Oct 06 18:01:04 CST 2015
运行了！时间为：Tue Oct 06 18:01:08 CST 2015
运行了！时间为：Tue Oct 06 18:01:12 CST 2015
...

看到从设定的时间开始，每隔4秒打印一次，无限打印下去

2、计划时间早于当前时间：立即执行

static public class MyTask extends TimerTask
{
  public void run()
  {
    System.out.println("运行了！时间为：" + new Date());
  }
}
public static void main(String[] args) throws Exception
{
  MyTask task = new MyTask();
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  String dateString = "2014-10-6 18:01:00";
  Timer timer = new Timer();
  Date dateRef = sdf.parse(dateString);
  System.out.println("字符串时间：" + dateRef.toLocaleString() + " 当前时间：" + new Date().toLocaleString());
  timer.schedule(task, dateRef, 4000);
}

看一下运行结果：

字符串时间：2014-10-6 18:01:00 当前时间：2015-10-6 18:02:46
运行了！时间为：Tue Oct 06 18:02:46 CST 2015
运行了！时间为：Tue Oct 06 18:02:50 CST 2015
运行了！时间为：Tue Oct 06 18:02:54 CST 2015
运行了！时间为：Tue Oct 06 18:02:58 CST 2015
运行了！时间为：Tue Oct 06 18:03:02 CST 2015
...

看到运行时间比当前时间早，从当前时间开始，每隔4秒打印一次，无限循环下去

TimerTask的cancel()方法

TimerTask的cancel()方法的作用是将自身从任务队列中清除：

static public class MyTaskA extends TimerTask
{
  public void run()
  {
    System.out.println("A运行了！时间为：" + new Date());
    this.cancel();
  }
}
  
static public class MyTaskB extends TimerTask
{
  public void run()
  {
    System.out.println("B运行了！时间为：" + new Date());
  }
}
  
public static void main(String[] args) throws Exception
{
  MyTaskA taskA = new MyTaskA();
  MyTaskB taskB = new MyTaskB();
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  String dateString = "2015-10-6 18:10:00";
  Timer timer = new Timer();
  Date dateRef = sdf.parse(dateString);
  System.out.println("字符串时间：" + dateRef.toLocaleString() + " 当前时间：" + new Date().toLocaleString());
  timer.schedule(taskA, dateRef, 4000);
  timer.schedule(taskB, dateRef, 4000);  
}

看一下运行结果：

字符串时间：2015-10-6 18:10:00 当前时间：2015-10-6 18:09:47
A运行了！时间为：Tue Oct 06 18:10:00 CST 2015
B运行了！时间为：Tue Oct 06 18:10:00 CST 2015
B运行了！时间为：Tue Oct 06 18:10:04 CST 2015
B运行了！时间为：Tue Oct 06 18:10:08 CST 2015
B运行了！时间为：Tue Oct 06 18:10:12 CST 2015
...

看到TimeTask的cancel()方法是将自身从任务队列中被移除，其他任务不受影响

Timer的cancel()方法

把上面代码改动一下：

private static Timer timer = new Timer();
  
static public class MyTaskA extends TimerTask
{
  public void run()
  {
    System.out.println("A运行了！时间为：" + new Date());
    timer.cancel();
  }
}
  
static public class MyTaskB extends TimerTask
{
  public void run()
  {
    System.out.println("B运行了！时间为：" + new Date());
  }
}
  
public static void main(String[] args) throws Exception
{
  MyTaskA taskA = new MyTaskA();
  MyTaskB taskB = new MyTaskB();
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  String dateString = "2015-10-6 18:10:00";
  Date dateRef = sdf.parse(dateString);
  System.out.println("字符串时间：" + dateRef.toLocaleString() + " 当前时间：" + new Date().toLocaleString());
  timer.schedule(taskA, dateRef, 4000);
  timer.schedule(taskB, dateRef, 4000);
}

看一下运行结果：

字符串时间：2015-10-618:10:00当前时间：2015-10-618:14:15

A运行了！时间为：TueOct0618:14:15CST2015

全部任务都被清除，并且进程被销毁。不过注意一下，cancel()方法未必一定会停止执行计划任务，可能正常执行，因为cancel()方法会尝试去获取queue锁，如果并没有获取到queue锁的话，TimerTask类中的任务继续执行也是完全有可能的

其他方法

再列举一些Timer中的其他schedule的重载方法的作用，就不提供证明的代码了，可以自己尝试一下：

1、schedule(TimerTasktask,longdelay)

以当前时间为参考，在此时间基础上延迟指定的毫秒数后执行一次TimerTask任务

2、schedule(TimerTasktask,longdelay,longperiod)

以当前时间为参考，在此时间基础上延迟指定的毫秒数后，以period为循环周期，循环执行TimerTask任务

3、scheduleAtFixedRate(TimerTasktask,DatefirstTime,longperiod)

在延时的场景下，schedule方法和scheduleAtFixedRate方法没有区别，它们的区别只是在非延时上。如果执行任务的时间没有被延时，对于schedule方法来说，下一次任务执行的时间参考的是上一次任务的开始时间来计算的；对于scheduleAtFixedRate方法来说，下一次任务执行的时间参考的是上一次任务的结束时间来计算的

总结

以上就是本文关于Java多线程定时器Timer原理及实现的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站：

java多线程编程实例

浅谈Java多线程的优点及代码示例

Java多线程之readwritelock读写分离的实现代码

如有不足之处，欢迎留言指出。

您可能感兴趣的文章:

相关文章

  • java自动装箱拆箱深入剖析

    java自动装箱拆箱深入剖析

    基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。java语言规范中说道：在许多情况下包装与解包装是由编译器自行完成的（在这种情况下包装成为装箱，解包装称为拆箱）
    2012-11-11
  • Java多线程中的Phaser详解

    Java多线程中的Phaser详解

    这篇文章主要介绍了Java多线程中的Phaser详解,Pahser是一个可以重复使用的同步屏障,Phaser是按照不同阶段执行线程的,它本身维护着一个叫 phase 的成员变量代表当前执行的阶段,需要的朋友可以参考下
    2023-11-11
  • Java Vector和ArrayList的异同分析及实例讲解

    Java Vector和ArrayList的异同分析及实例讲解

    在本篇文章里小编给大家整理的是一篇关于Java Vector和ArrayList的异同分析及实例讲解内容，有兴趣的朋友们可以学习参考下。
    2021-01-01
  • Java模拟HTTP Get Post请求实现论坛自动回帖功能

    Java模拟HTTP Get Post请求实现论坛自动回帖功能

    这篇文章主要介绍了Java模拟HTTP Get Post请求实现论坛自动回帖功能,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2016-09-09
  • mybatis分页及模糊查询功能实现

    mybatis分页及模糊查询功能实现

    这篇文章主要为大家详细为大家详细介绍了mybatis实现分页及模糊查询功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2017-06-06
  • Spring Security实现统一登录与权限控制的示例代码

    Spring Security实现统一登录与权限控制的示例代码

    这篇文章主要介绍了Spring Security实现统一登录与权限控制,本文通过示例代码重点看一下统一认证中心和业务网关的建设，需要的朋友可以参考下
    2022-03-03
  • 详解mybatis-plus配置找不到Mapper接口路径的坑

    详解mybatis-plus配置找不到Mapper接口路径的坑

    这篇文章主要介绍了详解mybatis-plus配置找不到Mapper接口路径的坑，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-10-10
  • springboot使用kafka事务的示例代码

    springboot使用kafka事务的示例代码

    Kafka 同数据库一样支持事务,当发生异常的时候可以进行回滚,确保消息监听器不会接收到一些错误的或者不需要的消息,本文就来介绍一下springboot使用kafka事务的示例代码,具有一定的参考价值,感兴趣的可以了解一下
    2024-06-06
  • 详解java中DelayQueue的使用

    详解java中DelayQueue的使用

    这篇文章主要介绍了java中DelayQueue的使用，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
    2020-10-10
  • springboot 在xml里读取yml的配置信息的示例代码

    springboot 在xml里读取yml的配置信息的示例代码

    这篇文章主要介绍了springboot 在xml里读取yml的配置信息的示例代码,代码简单易懂，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-09-09

最新评论