`

定时器的实现,java定时器Timer和Quartz的介绍

 
阅读更多
在项目中看到了定时器,虽然自己没去写,但是还是想了解一下,在网上找了些资料
来源:http://blog.csdn.net/sup_heaven/article/details/37738255


1定时器的作用
在实际的开发中,如果项目中需要定时执行或者需要重复执行一定的工作,定时器显现的尤为重要。
当然如果我们不了解定时器就会用线程去实现,例如:


package org.lzstone.action
public class FinanceAction extends Thread{
       private Date date;
       public void run{
       try{
       while(true){
       Thread.sleep((int)(Math.random()*1000));
       date = new Date();
       //定时执行任务
       }
       }catch(Exception e){
        e.printStackTrace();
       }
}
}


自己实现定时器的工作很复杂,如果实现不好占用内存过多,系统就此Over,所以处理定时执行或者重复执行的任务,定时器是很好的选择


2.java中常见的定时器
1)借助Java.util.Timer来实现
2)OpenSymphony社区提供的Quartz来实现
3.介绍Timer
利用Timer开发定时任务是主要分为两个步骤:
1)创建定时任务类
示例代码:

package org.lzstone.action
import java.util.TimeTask
public class LzstoneTimeTask extends TimeTask{
       public void run(){
              //执行的定时器任务
       }
}

2)运行定时任务,运行定时任务分为两种方式:
2.1)程序直接启动
示例代码:

package org.lzstone.action
public class LzstoneMain{
       .......
       public void run(){
        //执行定时器的任务
        //创建实例
        Timer timer = new Timer();
        参数:
        new LzstoneTimeTask()- 所要安排的任务。
        0- 执行任务前的延迟时间,单位是毫秒。
        1*1000- 执行各后续任务之间的时间间隔,单位是毫秒。
        timer.schedule(new LzstoneTimeTask(),0,1*1000);
       }
}

2.2)web监听方式
示例代码:

package org.lzstone.action
public class LzstoneMain implements ServletContextListener{
       private Timer timer = null;
       //初始化监听器,创建实例,执行任务
       public void contextInitialized(ServletContextEvent event){
               timer = new Timer();
               timer.schedule(new LzstoneTimeTask(),0,1*1000);
       }
       //销毁监听器,停止执行任务
       public void contextDestroyed(ServletContextEvent event){
              //注意,在此计时器调用的计时器任务的 run 方法内调用此方法,就可以绝对确保正在执行的任务是此计时器所执行的最后一个任务。
              timer.cancel();
        }
}

web.xml配置
<listener>
   <listener-class>
        org.lzstone.action.LzstoneMain
   </listener-class>
</listener>

4. 介绍Quartz
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,可以用来创建简单或者复杂的定时任务,利用Quartz开发定时任务的步骤与Timer类

似。

利用Quartz开发定时任务是主要分为两个步骤:
1)创建定时任务类
示例代码:

package org.lzstone.action
public class LzstoneTimeTask implements Job{
       public void execute(JobExecutionContext context) throws JobExecutionException{
              //执行的定时器任务
       }
}

2)运行定时任务,运行定时任务分为两种方式:
2.1)程序直接启动,创建任务调度器及配置相应的任务计划

示例代码:
package org.lzstone.action
public class LzstoneMain{
       private static Scheduler sched;
       public static void run() throws Exception{
              //创建LzstoneTimeTask的定时任务
              JobDetail jobDetail = new JobDetail("lzstoneJob",sched.DEFAULT_GROUP,LzstoneTimeTask.class);
              //目标 创建任务计划
              CronTrigger trigger = new CronTrigger("lzstoneTrigger","lzstone","0 0 12 * * ?");
              //0 0 12 * * ? 代表每天的中午12点触发
              sched = new org.quartz.impl.StdSchedulerFactory().getScheduler();
              sched.scheduleJob(jobDetail,trigger);
              sched.start();
       }
       //停止
       public static void stop() throws Exception{
              sched.shutdown();
        }
}
//执行
public class Main{
       .............
       public void run(){
            LzstoneMain.run();
       }
       ............
}

2.2)web监听方式
示例代码:

package org.lzstone.action
public class LzstoneMainListener implements ServletContextListener{
       private Timer timer = null;
       //初始化监听器,创建实例,执行任务
       public void contextInitialized(ServletContextEvent event){
               LzstoneMain.run();
       }
       //销毁监听器,停止执行任务
       public void contextDestroyed(ServletContextEvent event){
              LzstoneMain.stop();
        }
}

web.xml配置
<listener>
   <listener-class>
        org.lzstone.action.LzstoneMainListener
   </listener-class>
</listener>

5.对比
Timer方式实现定时器,原理简单,实现方便,在执行简单的任务比较方便,不足之处是无法确定执行时间,并且依赖性比较强,必须继承指定的类
Quartz方式实现定时器,方便,清晰指定启动时间,定时参数比较灵活,容易实现比较复杂的定时任务,不足之处是需要实现特定接口,加载其框架
两种方式各有优缺点,在特定场合可以根据其特点选择使用。
6.Spring定时任务
Spring定时任务对Timer与Quartz都提供了支持,并且实现步骤基本一样
首先配置Spring对Timer的支持
1.1 创建定时任务类

package org.lzstone.action
import java.util.TimeTask
public class LzstoneTimeTask extends TimeTask{
       public void run(){
              //执行的定时器任务
       }
}

1.2 注册定时任务类,配置任务计划与任务调度器
    在项目的WEB-INF下面创建TimerConfig.xml文件(一般叫做applicationContext.xml)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean>
<!--注册定时执行任务实体-->
<bean id="lzstoneTimeTask" class="org.lzstone.action.LzstoneTimeTask"/>
<!--注册定时器信息-->
<bean id="taskInfo" class="org.springframework.scheduling.timer.ScheduledTimerTask">
<!--第一次执行任务前需要等待的时间,这里设置为3秒-->
<property name="delay">
<value>3000</value>
</property>
<!--设置任务的执行周期 这里设置为4秒-->
<property name="period">
  <value>4000</value>
</property>
<!--设置具体执行的任务 这里设置为lzstoneTimeTask-->
<property name="timerTask">
<ref local="lzstoneTimeTask"/>
</property>
</bean>
<!--配置定时器任务的调度器-->
<bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">
<!--注册定时器列表-->
<property name="scheduledTimerTasks">
    <list>
        <ref local="taskInfo"/>
        ........
    </list>
</property>
</bean>
</beans>

1.3 web项目中的启动设置
   
<context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/TimerConfig.xml</param-value>
     </context-param>

     <listener>
         <listener-class>
                  org.springframework.web.context.ContextLoaderListener
         </listener-class>
     </listener>

配置Spring对Quartz的支持
2.1 创建定时任务类
package org.lzstone.action
public class LzstoneQuartzTask{
       public void execute(){
              //执行的定时器任务
       }
}

2.2 注册定时任务类,配置任务计划与任务调度器
    在项目的WEB-INF下面创建QuartzConfig.xml文件(一般叫做applicationContext.xml)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean>
<!--注册定时执行任务实体-->
<bean id="lzstoneQuartzTask" class="org.lzstone.action.LzstoneQuartzTask"/>
<!--注册定时器信息-->
<bean id="taskInfo" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<!--指定要执行的定时任务类  这里是LzstoneQuartzTask-->
<property name="targetObject">
<ref local="lzstoneQuartzTask"/>
</property>
<!--指定定时器任务类要执行的方法名称 这里是execute-->
<property name="targetMethod">
<value>execute</value>
</property>
</bean>
<!--配置定时器任务的调度器-->
<bean id="quartzTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
<!--声明要运行的实体-->
<property name="jobDetail">
    <ref local="taskInfo"/>
</property>
<!--设置运行时间-->
<property name="cronExpression">
    <value>0 0 12 * * ?</value>
</property>
</bean>
<!--注册监听器-->
<bean id="registerQuartz" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<!--注册定时器实体 集合-->
<property name="triggers">
    <list>
          <ref local="quartzTrigger"/>
    </list>
</property>
</bean>
</beans>

2.3 web项目中的启动设置
   
<context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/QuartzConfig.xml</param-value>
     </context-param>

     <listener>
         <listener-class>
                  org.springframework.web.context.ContextLoaderListener
         </listener-class>
     </listener>
分享到:
评论

相关推荐

    Spring定时器实例(Java的Timer类和OpenSymphony的Quartz)

    Spring两种定时器实例配置:Java的TimerTask类和OpenSymphony的Quartz。包含5种配置方式:timer普通定时器、timer特定方法定时器、quartz简单定时器、quartz精确定时器、quartz特定方法定时器。简单实用,一看就会。

    spring定时器 Spring定时器的两种实现方式Java的Timer类和OpenSymphony的Quartz。

    Spring框架提供了两种方式来处理定时任务:Java内置的`Timer`类和第三方库OpenSymphony的Quartz。下面将详细介绍这两种实现方式。 ### 1. Java `Timer` 类 Java `java.util.Timer` 类是Java标准库中的一个轻量级...

    Java定时器Timer简述.pdf

    Java定时器Timer是Java编程语言中用于计划执行任务的一种工具类。Timer类主要提供了定时任务的安排执行,对于需要在指定时间后、或者以固定周期重复执行任务的场景非常有用。本文档中介绍的Timer类的实现以及如何...

    Spring 使用Timer quartz区别

    在处理定时任务时,Spring提供了两种常见的解决方案:`java.util.Timer` 和 Quartz。这两个工具各有特点,适用于不同的场景。下面我们将深入探讨它们的区别。 首先,`java.util.Timer` 是Java标准库中的一个简单...

    java Spring OpenSymphony的Quartz定时器的时间设置

    在Java Spring框架中,开发者有多种选择来实现定时任务的功能,其中最为流行的两种方式分别是使用Java自带的`Timer`类以及OpenSymphony的Quartz定时器。本文将重点探讨Quartz定时器的配置与使用,尤其是其时间设置的...

    Java定时器的使用 Java程序

    Java定时器类`Timer`和`TimerTask`是配合使用的。`Timer`用于创建定时器实例并调度任务,而`TimerTask`则是一个抽象类,用于定义要定时执行的任务。创建`TimerTask`子类并重写其`run()`方法,然后将其添加到`Timer`...

    java中Timer定时器的使用

    总的来说,`Timer`和`TimerTask`是Java中实现简单定时任务的便利工具,但在高并发、高性能的场景下,可能需要考虑使用更强大的调度库,如`Quartz`或`Spring Framework`中的`ScheduledExecutorService`。

    spring定时器两种实现方式

    Spring 定时器两种实现方式 Spring 定时器是 Spring 框架中的一种组件,用于实现定时任务的执行。...Spring 定时器提供了两种实现方式,Java Timer 定时和 Quartz 定时器,开发者可以根据实际情况选择合适的实现方式。

    使用java定时器的几种方式

    在Java中实现定时任务有多种方式,其中比较常见的包括Java自带的java.util.Timer类、Quartz和Spring Task。这些方法各有特点,适用于不同的业务场景和技术需求。 首先,Java自带的java.util.Timer类提供了一种简单...

    java web定时器例子

    Java Web定时器主要指的是在Java Web应用程序中实现定时任务的功能,这在许多业务场景中都是必要的,例如数据备份、报表生成、邮件发送等。在Java中,我们可以利用内置的`java.util.Timer`类或者Spring框架的`@...

    spring和java定时器

    Spring框架和Java内置的定时器提供了两种不同的方式来实现这样的功能。 首先,我们来看Spring定时器。Spring使用的是Quartz库来实现定时任务管理。在给出的例子中,可以看到配置文件中定义了几个关键的bean: 1. `...

    java定时器的实现

    本文将详细介绍如何使用`Timer`类结合`ServletContextListener`接口来实现在Web应用中启动并管理一个定时任务。 #### 二、Java定时器的基本概念 1. **`java.util.Timer`类**:`Timer`类是Java中用于执行定时任务的...

    java定时器设置及停止的方法

    本文将深入探讨如何在Java中设置和停止定时任务,主要关注`java.util.Timer`和`java.util.TimerTask`,以及更现代的`ScheduledExecutorService`。 首先,`java.util.Timer`是一个工具类,它允许程序员安排任务在...

    java 定时器任务timer 随tomcat启动而启动 同步启动

    我们通常写的timer都是用main方法写的定时器,但同样我们也需要根据服务器启动后定时器也启动的 定时执行任务。不过有个致命伤就是集群方面跟quartz不能比,此方法代码做参考不错,如果要用,那么这个方法在一台...

    java定时执行多任务和quartz定时执行多任务

    - `java.util.Timer`: 这是一个简单的定时器,可以安排单次或周期性的任务。它通过`TimerTask`类来定义要执行的任务。但是,`Timer`类不是线程安全的,当多个任务并发执行时可能出现问题。 - `java.util....

    spring+jdk定时器

    Spring框架作为Java领域广泛使用的轻量级框架,提供了与JDK定时器结合以及集成第三方库如Quartz的方式,来实现定时任务。本篇文章将详细探讨“spring+jdk定时器”的实现方式。 首先,我们来看JDK自带的定时器——`...

    web定时器的实现思路

    - **Tomcat的Catalina Timer**:Tomcat Web服务器内建了一个定时器服务,可以在Web应用的上下文中创建和管理定时任务。这适用于那些不需要跨应用服务器的简单定时任务。 5. **JavaScript的Web定时器** - 在Web...

Global site tag (gtag.js) - Google Analytics