精华内容
下载资源
问答
  • java中制作一个定时器

    2014-10-10 15:45:49
    利用java制作定时器比较简单,有现成的接口帮助实现。

          利用java制作定时器比较简单,有现成的接口帮助实现。java中制作定时器使用的是Timer和TimerTask,是util包的。java.util.Timer定时器,实际上是个线程,定时调度所拥有的TimerTasks。 一个TimerTask实际上就是一个拥有run方法的类,需要定时执行的代码放到run方法体内,TimerTask一般是以匿名类的方式创建。

        java.util.Timer timer = new java.util.Timer(true);   
        // true 说明这个timer以daemon方式运行(优先级低,   
        // 程序结束timer也自动结束),注意,javax.swing   
        // 包中也有一个Timer类,如果import中用到swing包,   
        // 要注意名字的冲突。   
          
        TimerTask task = new TimerTask() {   
        public void run() {   
        ... //每次需要执行的代码放到这里面。   
        }   
        };   
          
        //以下是几种调度task的方法:   
          
        timer.schedule(task, time);   
        // time为Date类型:在指定时间执行一次。   
          
        timer.schedule(task, firstTime, period);   
        // firstTime为Date类型,period为long   
        // 从firstTime时刻开始,每隔period毫秒执行一次。   
          
        timer.schedule(task, delay)   
        // delay 为long类型:从现在起过delay毫秒执行一次   
          
        timer.schedule(task, delay, period)   
        // delay为long,period为long:从现在起过delay毫秒以后,每隔period   
        // 毫秒执行一次。  
    
    

    而我们实际应用中,比较常用的是将TimerTask分离出来,由一个单独的类来组成定制任务

    import java.util.Timer;  
      
    public class TimerTaskTest extends java.util.TimerTask{  
      
    @Override  
    public void run() {  
       // TODO Auto-generated method stub  
       System.out.println("start");  
    }  
    } 

        import java.util.Timer;  
          
        public class Test {  
        public static void main(String[] args){  
           Timer timer = new Timer();  
           timer.schedule(new TimerTaskTest(), 1000, 2000);  
        }  
        }  


    展开全文
  • 当前java程序中能够实现定时的...其实java很早就有解决定时器任务的方法了,java提供了类java.util.TimerTask类基于线程的方式来实现定时任务的操作,然后再提供java.util.Timer类来注册调用,先创建一个类RingTask...

    当前java程序中能够实现定时的主要有三种方式,分别是:java定时器,spring定时器,quartz定时器。

       下面依次讲讲他们的应用!

    java定时器的应用
       其实java很早就有解决定时器任务的方法了,java提供了类java.util.TimerTask类基于线程的方式来实现定时任务的操作,然后再提供java.util.Timer类来注册调用,先创建一个类 RingTask 继承 java.util.TimerTask,实现run方法,相关代码如下:

    package timer;
     
    import java.util.TimerTask;
     
    /**
      * 这是一个打铃的程序,必须隔一段时间打一次
      */
    public class RingTask extends TimerTask{
     
        public RingTask() {
            // TODO Auto-generated constructor stub
        }
     
        public RingTask(int s,int d) {
            // TODO Auto-generated constructor stub
            this.second = s;
            this.delay  = d;
        }
     
        int second = 1;
     
        int delay  = 1;
     
        public void setSecond(int second) {
            this.second = second;
        }
     
        public void setDelay(int delay) {
            this.delay = delay;
        }
     
        @Override
     
        public void run() {
            // TODO Auto-generated method stub
            System.out.println("我是打铃程序!"+"我第一次打铃延迟了"+delay+"秒!");
            System.out.println("打铃了!每过"+second+"秒一次");
        }
     
    }
     
    //定义好后,下面需要注册调用了,注册调用的方法如下:
    public static void main(String[] args) {
        //以 java定时器的模式调用
        Timer timer = new Timer();
        timer.schedule(
                new RingTask(3,3),  //需要注册的定时类
                3000,             //最开始先延迟3秒的时间
                3000);            //每隔3秒的时间调用一次
    }


       一个简单的java定时器就写好了,方便而简介,但是有不好的缺点: 如果需要实现每天早晨7点钟的定时执行一次,且周末的时候早晨7点钟不需要提醒,那这个可就不够用了,并且如果需要服务器一开启就触发这个定时器,则这种注册调用的方法也是不行的。

    Spring定时器的应用
       spring定时器是在spring框架中应用较成熟的一种方式,spring将定时任务的调用部分提到了配置文件当中,使定时器的触发条件变得更加灵活,spring定时器的实现,仍然需要 继承 java.util.TimerTask,实现run方法 ,示例类上面已给出,调用的配置如下: 

    <!-- 定时器的配置 (spring定时器)-->
    <!-- 要调度的bean配置 -->
    <bean id="ringTask" class="timer.RingTask">
        <!-- 给 属性 second 赋值 为 3 -->    
        <property name="second" >    
            <value>3</value>        
        </property>
        <!-- 给 属性 delay 赋值 为 3 -->
        <property name="delay" >
            <value>3</value>    
        </property>
    </bean>
    <!--配置一个触发器 配置触发器的参数-->
    <bean id="scheduleRingTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
        <property name="delay" value="3000"></property>           <!--第一次延迟3秒的时间-->
        <property name="period" value="3000"></property>          <!--每隔3秒的时间执行一次-->
        <property name="timerTask" ref="ringTask"></property>   <!--制定触发的类-->
    </bean>
    <!-- 总调度,用于启动定时器 -->
    <bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">
        <property name="scheduledTimerTasks">
            <list>    
                <ref bean="scheduleRingTask"/>    
            </list>
        </property>
    </bean>


       在调用方面是不是灵活些了,且能够实现服务器已启动,就将定时器的执行纳入的被监控的范围,符合条件马上触发执行。但是还是存在缺点: 对于指定了具体的年月日时分秒而执行的任务还是不能解决。

    Quartz定时器
      Quartz是基于Spring框架之上的更加强大的定时器,它不仅可以轻松的实现前面两种定时器的功能,还实现了非常繁复的时间触发执行的任务,Quartz有两种方式来调度定时任务,一是使用Spring提供的 MethodInvokingJobDetailFactoryBean 代理类,Quartz通过该代理类直接调度任务类的某个函数;二是任务类继承QuartzJobBean类或者实现org.quartz.Job接口,Quartz通过该父类或者接口进行调度。

       先来看看实现前面个两种定时器的功能,现在先来举个例子,比如烧水,每1小时烧开一次,进行定时提醒,然后重新换水,再烧。

       具体的烧水定时类代码如下:

    package timer;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.springframework.scheduling.quartz.QuartzJobBean;
     
    /**
     * 这是一个热水的程序,必要要经过一段时间烧热了,才提醒重新换水
     * 这个类不管是继承 QuartzJobBean还是实现org.quartz.Job都行
     */
    public class HotWaterTask extends QuartzJobBean /*implements Job*/{
        // public void execute(JobExecutionContext arg0) 
        // throws JobExecutionException {
            // // TODO Auto-generated method stub
            // System.out.println("我是热水程序,我第一烧水需要1小时");
            // System.out.println("水现在烧开了,要及时换水哦!");
        // }
        
        @Override
        protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
            // TODO Auto-generated method stub
            System.out.println("我是热水程序, 我第一烧水需要1小时 ");
            System.out.println("水现在烧开了,要及时换水哦!");
        }
    }
    类定义好了,下面需要配置进去,配置的代码如下:
    
    <!-- 配置需要调度的任务类 -->
    <bean id="hotWaterTask" class="org.springframework.scheduling.quartz.JobDetailBean">
        <property name="jobClass" value="timer.HotWaterTask"></property>
    </bean>
    <!-- 配置一个触发器 -->
    <bean id="hotWaterTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
        <property name="jobDetail" ref="hotWaterTask"></property>
        <property name="startDelay" value="3600000"></property>
        <property name="repeatInterval" value=" 3600000"></property>
    </bean>
    <!-- 总调度,用于启动定时器 -->
    <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers" >
            <list>
                <ref bean="hotWaterTrigger"/>
            </list>
        </property>
    </bean>
      看到了吗,在这里我们并没有直接声明一个 HotWaterTask  Bean,而是声明了一个JobDetailBean。这个是Quartz的特点。JobDetailBean是Quartz的org.quartz.JobDetail的子类,它要求通过jobClass属性来设置一个Job对象。
    
      好了,上面的任务已经实现了,下面看看 如何实现 具体的年月日时分秒执行的代码
    
    Quartz在指定的时间执行 (很强大的代理定时执行机制)
    
      (1) 定义上班闹钟定时类代码如下: 
    
    package timer;
     
    /**
     * 开始上班,这个程序要求每天(非周末)早晨八点需要启动一次
     */
    public class StartWorkJob {
        public void startWork(){
            System.out.println("我是上班程序,每天(非周末)早晨八点需要启动一次");
            System.out.println("上班了!~")
        }
    }
      看到了吗,这个类StartWorkJob 并没有继承任何类也没有实现任何接口,且方法 startWork也是自己定义的,原有的业务代码不需要做任何更改。下面就要提到Quartz实现的一种机制,通过Spring提供的代理类(MethodInvokingJobDetailFactoryBean)来实现定时任务,这个类只需要提供它要代理的类以及要代理的方法,就能够很好的就行定时监控了,强大吧,相关的代码如下:
    
    <!-- 配置需要定时的bean类 -->
    <bean id="startWorkJob" class="timer.StartWorkJob"></bean>
    <!-- 配置任务的具体类和方法 -->
    <bean id="startWorkTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!-- 要调用的bean -->
        <property name="targetObject" ref="startWorkJob"></property> 
        <!-- 要调用的Method -->
        <property name="targetMethod" value="startWork"></property>
        <!-- 是否并发,false表示 如果发生错误也不影响下一次的调用 -->
        <property name="concurrent" value="false"></property>
    </bean>
    <!-- 配置一个触发器 -->
    <bean id="startWorkTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail" ref="startWorkTask"></property>
        <property name="cronExpression" value="0 * 13 * * ?"></property> <!--每天的下午1点的每分钟的0秒都执行一次-->
    </bean>
     
    <!-- 总调度,用于启动定时器 -->
    <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers" >
            <list>
                <ref bean="startWorkTrigger"/>
            </list>
        </property>
    </bean>


       好了一个指定了具体时间的定时触发任务也已经实现了,下面来看看cronExpression 有哪些需要知道的配置信息,信息如下:

       一个cron表达式有至少6个(也可能7个)有空格分隔的时间元素。从左到右:

    1.秒2.分3.小时4.月份中的日期(1-31)5.月份(1-12或JAN-DEC)6.星期中的日期(1-7或SUN-SAT)7.年份(1970-2099) 
    每个元素都显示的规定一个值(如6),一个区间(9-12),一个列表(9,11,13)或一个通配符(*)。因为4和6这两个元素是互斥的,因此应该通过设置一个问号(?)来表明不想设置的那个字段,“/”如果值组合就表示重复次数(10/6表示每10秒重复6次)。

    最后提供一个在线cron表达式生成器:http://cron.qqe2.com/

    展开全文
  • java 定时器

    2011-11-22 18:56:02
    java 定时器 java 定时器代码,更全的java 定时器代码
  • 1.1配置定时器的xml配置文件中加入以下代码: <!-- 自定义定时器任务--> <bean id="自定义定时任务id" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean"> <property ...

    1.配置模版

    1.1在配置定时器的xml配置文件中加入以下代码:

    <!-- 自定义定时器任务-->
        <bean id="自定义定时任务id" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    		<property name="jobDetail" ref="自定义jobDetail的id名称" />
    		<property name="cronExpression" value="0 0 12 ? * MON" /><!-- 每周一中午12点更新 -->
    	</bean>
        <bean id="自定义jobDetail的id名称" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">   
            <property name="targetObject"  ref="对应的类名"/>  
            <property name="targetMethod"  value="类中对应的方法名称"/>  
            <property name="concurrent" value="false"/>
            <!-- 是否允许任务并发执行。当值为false时,表示必须等到前一个线程处理完毕后才再启一个新的线程   -->
        </bean> 
        <!-- 自定义定时器任务 end-->

    1.2在第一步中的xml文件中配置触发器

    <!--触发器的管理器(在列表中添加定义的触发器) -->
    	<bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    		<property name="triggers">
                <!-- 定时器任务列表 -->
    			<list>			
    				<ref bean="第一步中的自定义定时任务id" /> <!-- 自定义定时器任务 -->
    			</list>
    		</property>
    	</bean>	

    2.实例说明

    2.1xml配置文件中的配置

    <!-- 自定义定时器任务-->
        <bean id="myTask" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    		<property name="jobDetail" ref="myJobDetail" />
    		<property name="cronExpression" value="0 0 12 ? * MON" /><!-- 每周一中午12点更新 -->
    	</bean>
        <bean id="myJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">   
            <property name="targetObject"  ref="myJob"/>  
            <property name="targetMethod"  value="doSomeWork"/>  
            <property name="concurrent" value="false"/>
            <!-- 是否允许任务并发执行。当值为false时,表示必须等到前一个线程处理完毕后才再启一个新的线程   -->
        </bean> 
        <!-- 自定义定时器任务 end-->

    2.2业务类

    @Repository
    public class MyJob implements ISchedulerJob{
    
        @Override
        public void execute() throws Exception{
            //必须
        }
    
        public void doSomeWork() throws Exception{
            //在这方法中实现自己的业务
        }
    }

     

    展开全文
  • java定时器

    2017-01-19 15:46:55
    java定时器,import java.util.Calendar; import java.util.Date; import java.util.Timer; import java.util.TimerTask; 规定每天几点执行
  • java定时器 spring定时器:包括spring定时器的详细配置以及说明 包含所需的jar包
  • Java定时器

    2018-12-24 22:05:10
    Java多线程中,有的时候,我们需要按照指定间隔时间来执行一些任务,这时,我们就要用到定时器。我们这里以Java中的Timer定时器为例,演示定时器的应用。... * Java定时器 */ public class Test { ...

    在Java多线程中,有的时候,我们需要按照指定间隔时间来执行一些任务,这时,我们就要用到定时器。我们在这里以Java中的Timer定时器为例,演示定时器的应用。

    package com.itszt.test;
    import java.util.Timer;
    import java.util.TimerTask;
    /**
     * Java定时器
     */
    public class Test {
        private static int i=1;
        public static void main(String[] args) {
            //定时器任务
            TimerTask timerTask = new TimerTask(){
                @Override
                public void run() {
                    System.out.println("timerTask--->"+(i++));
                }
            };
            //创建定时器
            Timer timer = new Timer();
            long delay=0;//延迟时间
            long intervalPeriod=1*1000;//间隔时间
            //执行定时器任务
            timer.scheduleAtFixedRate(timerTask,delay,intervalPeriod);
        }
    }
    

      上述代码运行后,这是控制台打印结果:

    timerTask--->1
    timerTask--->2
    timerTask--->3
    timerTask--->4
    timerTask--->5
    timerTask--->6
    timerTask--->7
    timerTask--->8
    

      程序运行后,定时任务会每间隔1秒执行一次,直到程序被人为或意外结束。

    展开全文
  • 现实生活中,会出现这样的例子,比如烧水,一般烧了20分钟后,水开了,会需要及时换水,再烧20分钟,水又开了,继续提醒,比如上班,... 当前java程序中 能够实现定时的 主要有 三种 方式 ,分别是: java定时器 , s
  • java监听器之定时器

    2018-05-22 10:13:14
    监听器之定时器,写一个定时器的监听器,这个监听器每十秒向控制台输出一次时间信息 博客地址:https://blog.csdn.net/qq_36631076/article/details/80401609
  • 我的第一个java定时器

    千次阅读 2015-08-27 10:03:40
    接下来就去开发我的第一个java定时器吧,Java计时器实用程序允许您执行线程或任务在一个预先确定的将来的时间,并根据一组这些任务可以重复频率。 设计和实现一个计时器,会用到model-control-view(MVC)设计模式。 ...
  • 一、首先想有一个定时器需要创建一个Timer类,启动定时器是调用Timer类中的schedule()方法 翻译过来是调度, package cn.itcast.heima2; import java.util.Date; import java.util.Timer; import java.util....
  • 如果需要在定时器里写sql。或者需要依赖注入一些对象时 import javax.servlet.ServletContext; import org.springframework.beans.BeansException; import org.springframework.beans.factory.annotation.Autowired...
  • java的几种定时器

    万次阅读 多人点赞 2018-09-25 17:44:45
    总结一下我使用过的4种...@Scheduled注解是最简单的方式,只需要启用定时器方法上添加注解即可。 spring配置中加入: &lt;!-- 启用注解定时器 --&gt; &lt;task:annotation-driven /&gt; ...
  • java用线程实现定时器

    千次阅读 2017-10-19 21:48:00
    现在的框架的功能很强大,封装好了各种功能,例如用spring框架实现定时功能只需配置文件里配置...实现这样一个定时器的有如下步骤:首先定义一个用来实现你定时要什么事情的类,这个类继承TimerTask类,然后重写
  • Java后台定时器代码

    2018-03-09 12:53:14
    Java后台定时器代码Java后台定时器代码Java后台定时器代码Java后台定时器代码Java后台定时器代码
  • 一个java定时器框架

    2013-10-10 09:54:00
    http://www.cnblogs.com/phinecos/archive/2008/02/25/1081354.html
  • java多线程和定时器学习

    热门讨论 2012-01-11 18:54:39
    java多线程和定时器学习,代码和文档都有,很详细
  • Java定时器的使用 Java程序 Java写的一个定时器
  • 情景:最近公司有个业务,需要通过定时器通过时间判断去对相关业务表的数据进行状态进行变更...好了进入主题:mysql实现定时器任务,需要两步:【1】创建一个存储过程 【2】创建定时器 通过定时器去管理存储过程,...
  • java 写的定时器

    2010-05-12 11:01:38
    java 写的定时器java 写的定时器java 写的定时器java 写的定时器
  • 此为根据时间轮定时器的算法实现的 java时间轮的定时器,多轮和单轮实现
  • 此为根据时间轮定时器的算法实现的 java时间轮的定时器,多轮和单轮实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,412
精华内容 25,364
关键字:

如何在java做一个定时器

java 订阅