精华内容
下载资源
问答
  • Java Timer TimerTask示例

    万次阅读 2018-11-14 11:09:18
    Java java.util.Timer是一个实用程序类,可用于...java.util.TimerTask是一个实现Runnable接口的抽象类,我们需要扩展这个类来创建我们自己的TimerTask,它可以使用java Timer类进行调度。 Java计时器示例 J...

    Java java.util.Timer是一个实用程序类,可用于调度将来某个时间执行的线程。Java Timer类可用于计划要一次运行的任务或定期运行的任务。

    Java TimerTask

    java.util.TimerTask是一个实现Runnable接口的抽象类,我们需要扩展这个类来创建我们自己的TimerTask,它可以使用java Timer类进行调度。

    Java计时器示例

    java计时器示例,java计时器,java timertask,java timertask示例

    Java Timer类是线程安全的,多个线程可以共享一个Timer对象,而无需外部同步。Timer类使用java.util.TaskQueue以给定的定期间隔添加任务,并且在任何时候只能有一个线程运行TimerTask,例如,如果要创建一个每10秒运行一次的Timer,但单线程执行需要20秒,然后Timer对象将继续向队列添加任务,一旦一个线程完成,它将通知队列,另一个线程将开始执行。

    Java Timer类使用Object wait和notify方法来安排任务。

    这是一个简单的Java Timer和TimerTask示例程序。

    
    package com.journaldev.threads;
    
    import java.util.Date;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class MyTimerTask extends TimerTask {
    
        @Override
        public void run() {
            System.out.println("Timer task started at:"+new Date());
            completeTask();
            System.out.println("Timer task finished at:"+new Date());
        }
    
        private void completeTask() {
            try {
                //assuming it takes 20 secs to complete the task
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        public static void main(String args[]){
            TimerTask timerTask = new MyTimerTask();
            //running timer task as daemon thread
            Timer timer = new Timer(true);
            timer.scheduleAtFixedRate(timerTask, 0, 10*1000);
            System.out.println("TimerTask started");
            //cancel after sometime
            try {
                Thread.sleep(120000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            timer.cancel();
            System.out.println("TimerTask cancelled");
            try {
                Thread.sleep(30000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    }
    

    请注意,一个线程执行将花费20秒,但Java Timer对象被安排为每10秒运行一次任务。这是程序的输出:

    
    TimerTask started
    Timer task started at:Wed Dec 26 19:16:39 PST 2012
    Timer task finished at:Wed Dec 26 19:16:59 PST 2012
    Timer task started at:Wed Dec 26 19:16:59 PST 2012
    Timer task finished at:Wed Dec 26 19:17:19 PST 2012
    Timer task started at:Wed Dec 26 19:17:19 PST 2012
    Timer task finished at:Wed Dec 26 19:17:39 PST 2012
    Timer task started at:Wed Dec 26 19:17:39 PST 2012
    Timer task finished at:Wed Dec 26 19:17:59 PST 2012
    Timer task started at:Wed Dec 26 19:17:59 PST 2012
    Timer task finished at:Wed Dec 26 19:18:19 PST 2012
    Timer task started at:Wed Dec 26 19:18:19 PST 2012
    TimerTask cancelled
    Timer task finished at:Wed Dec 26 19:18:39 PST 2012
    

    输出确认如果任务已在执行,Timer将等待它完成,一旦完成,它将再次从队列中开始下一个任务。

    可以创建Java Timer对象以将相关任务作为守护程序线程运行。Timer cancel()方法用于终止计时器并丢弃任何计划任务,但它不会干扰当前正在执行的任务并让它完成。如果计时器作为守护程序线程运行,无论我们是否取消它,它将在所有用户线程完成执行后立即终止。

    Timer类包含几个schedule()方法,用于安排任务在给定日期或延迟一段时间后运行一次。有几个scheduleAtFixedRate()方法以一定的间隔定期运行任务。

    在使用Timer调度任务时,您应该确保时间间隔超过正常的线程执行,否则任务队列大小将继续增长,最终任务将始终执行。这就是Java Timer和Java TimerTask的快速综述。

    展开全文
  • Java中的Timer和TimerTask的用法

    千次阅读 2018-03-09 10:06:18
    TimerTask则是一个抽象类,其 有一个抽象方法run(),类型线程的run()方法。 我们使用Timer创建一个他的对象,然后使用这对象的schedule方法来完成这种间隔的操作。 schedule方法有三个参数,其中第一个参数...

    Timer是一个普通的类,其中有几个重要的方法;
    而TimerTask则是一个抽象类,其 中有一个抽象方法run(),类型线程中的run()方法。
    我们使用Timer创建一个他的对象,然后使用这对象的schedule方法来完成这种间隔的操作。
    schedule方法有三个参数,其中第一个参数就是TimerTask类型的对象,我们实现TimerTask的run()方法就是要周期执行的一个任务;
    第二个参数有两种类型,第一种是long类型,表示多长时间后开始执行,另一种是Date类型,表示从那个时间后开始执行;
    而第三个参数就是执行的周期,为long类型。
    schedule方法还有一种两个参数的执行重载,第一个参数仍然是TimerTask,第二个表示为long的形式表示多长时间后执行一次,为Date就表示某个时间后执行一次。

    需要注意的是Timer就是一个线程,使用schedule方法完成对TimerTask的调度,多个TimerTask可以共用一个Timer,也就是说Timer对象调用一次schedule方法就是创建了一个线程,并且调用一次schedule后TimerTask是无限制的循环下去的,使用Timer的cancel()停止操作。
    当然同一个Timer执行一次cancel()方法后,所有Timer线程都被终止。

    下面是示列代码:
    java.util.Timer timer = new java.util.Timer(true);
    // true 说明这个timer以daemon方式运行(优先级低,
    // 程序结束timer也自动结束),注意,javax.swing
    // 包中也有一个Timer类,如果import中用到swing包,
    // 要注意名字的冲突。

    TimerTask task = new TimerTask() {  
        @Override
        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
    // 毫秒执行一次。

    完整的示例代码:
    1、定制任务:

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

    2.调用java.util.Timer :

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

    以上代码表示1秒后开始每个2秒钟执行一次TimerTaskTest中的run()方法。

    展开全文
  • java.util.Timer定时器,实际上是个线程,定时调度所拥有的TimerTasks。一个TimerTask实际上就是一个拥有run方法的类,需要定时执行的代码放到run方法体内,TimerTask一般是以匿名类的方式创建,下面的就用示例来学习...
  • 在 TimerManager 这个类里面,大家一定要注意 时间点的问题。如果你设定在凌晨2点执行任务。但你是在2点以后 发布的程序或是重启过服务,那这样的情况下,任务会立即执行,而不是等到第二天的凌晨2点执行。...
  • java定时器-Timer和TimerTask详解

    万次阅读 2018-07-17 17:44:16
    1、例子入手 package pers.growing.test; import java.util.Timer;...import java.util.TimerTask; public class Main { /** * 延迟100ms后,间隔1s打印出:hello world * * @param args * @throws Inte...

    1、例子入手

    package pers.growing.test;
    
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class Main {
    
        /**
         * 延迟100ms后,间隔1s打印出:hello world
         *
         * @param args
         * @throws InterruptedException
         */
        public static void main(String[] args) throws InterruptedException {
            Timer t = new Timer();
            t.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("hello world");
                }
            }, 100, 1000);
    
        }
    
    }

    结果:

    hello world
    hello world
    hello world
    hello world
    hello world
    hello world
    hello world

    2、类讲解

    TimerTask.java:主要为任务的具体内容。

    Timer.java中含有3个类:Timer、TimerThread、TaskQueue。

    三者关系为:TaskQueue中存放一些列将要执行的TimerTask,以数组的形式存放,下标约小(注:下标为0不处理,即使用的最小下标为1),则表明优先级越高。

    TimerThread为Thread的扩展类,会一直从TaskQueue中获取下标为1的TimerTask进行执行。并根据该TimerTask是否需要重复执行来决定是否放回到TaskQueue中。

    Timer用于配置用户期望的任务执行时间、执行次数、执行内容。它内部会配置TimerThread、TaskQueue。

    3、源码解读

    Timer类下的方法如下:

    Timer中涉及到4个成员变量,queue、thread已经在上面介绍过了,对于nextSerialNumber,只是用于命名默认的thread名称使用。threadReaper为了在GC时进行相关处理,后面再介绍。

    Timer的构造函数实现大同小异,以Timer(String,boolean)为例:

      public Timer(String name, boolean isDaemon) {
            thread.setName(name); //设置成员变量的线程名称
            thread.setDaemon(isDaemon); //该线程是否为守护线程
            thread.start();//起线程
        }

    schedule()以schedule(TimerTask,long,long)为例:

     public void schedule(TimerTask task, long delay, long period) {
            if (delay < 0)
                throw new IllegalArgumentException("Negative delay.");
            if (period <= 0)
                throw new IllegalArgumentException("Non-positive period.");
            sched(task, System.currentTimeMillis()+delay, -period); //最后调用了sched方法
        }

    这一块有困惑的可能是为什么period取了负数?而且所有的schedule(...)方法,最后传给sched中的period都是负的。之后再介绍。

    scheduleAtFixedRate()以scheduleAtFixedRate(TimerTask,long,long)为例:

        public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
            if (delay < 0)
                throw new IllegalArgumentException("Negative delay.");
            if (period <= 0)
                throw new IllegalArgumentException("Non-positive period.");
            sched(task, System.currentTimeMillis()+delay, period); //也是调用sched方法
        }

    此时会发现schedule与scheduleAtFixedRate似乎区别不大,唯一有区别的是schedule最后传值给sched的period是负数,而scheduleAtFixedRate传的是正数。

    在schedule方法的注释上,有这段内容:

         * <p>In fixed-delay execution, each execution is scheduled relative to
         * the actual execution time of the previous execution.  If an execution
         * is delayed for any reason (such as garbage collection or other
         * background activity), subsequent executions will be delayed as well.
         * In the long run, the frequency of execution will generally be slightly
         * lower than the reciprocal of the specified period (assuming the system
         * clock underlying <tt>Object.wait(long)</tt> is accurate).

    翻译:如果出现某一次任务的延迟,那么之后的任务都会以period为周期进行延迟。

    而scheduleAtFixedRate方法也有对应注释:

         * <p>In fixed-rate execution, each execution is scheduled relative to the
         * scheduled execution time of the initial execution.  If an execution is
         * delayed for any reason (such as garbage collection or other background
         * activity), two or more executions will occur in rapid succession to
         * "catch up."  In the long run, the frequency of execution will be
         * exactly the reciprocal of the specified period (assuming the system
         * clock underlying <tt>Object.wait(long)</tt> is accurate).

    翻译:每次的执行都是以初始时计算好的时间为准,如果出现某次任务的延迟,则之后的任务会快速执行,即按计划时间执行。

    那么看下Sched()方法实现:

     private void sched(TimerTask task, long time, long period) {//接收具体任务,第一次执行时间,周期
            if (time < 0)
                throw new IllegalArgumentException("Illegal execution time.");
    
            // Constrain value of period sufficiently to prevent numeric
            // overflow while still being effectively infinitely large.
            if (Math.abs(period) > (Long.MAX_VALUE >> 1))
                period >>= 1;
    
            synchronized(queue) {
                if (!thread.newTasksMayBeScheduled)
                    throw new IllegalStateException("Timer already cancelled.");
    
                synchronized(task.lock) {
                    if (task.state != TimerTask.VIRGIN)
                        throw new IllegalStateException(
                            "Task already scheduled or cancelled");
                    task.nextExecutionTime = time; //给TimerTask赋值
                    task.period = period;
                    task.state = TimerTask.SCHEDULED;
                }
    
                queue.add(task);//将TimerTask放到队列中,并进行队列排序
                if (queue.getMin() == task)//如果队列里恰好下标为1的任务为当前的task,则直接唤醒
                    queue.notify();
            }
        }

    queue中的add和getMin操作如下:

        void add(TimerTask task) {
            // Grow backing store if necessary
            if (size + 1 == queue.length)
                queue = Arrays.copyOf(queue, 2*queue.length);
    
            queue[++size] = task;
            fixUp(size);//让task进行排序,排序并不是十分严谨,将nextExecutionTime较小的往前排
        }
    
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
                    break;
                TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
                k = j;
            }
        }
    
       
        TimerTask getMin() { //注意最小的值是从下标为1的获取,queue[0]其实没用到
            return queue[1];
        }

    数据已经放到queue中了,那么看下是什么时候执行的。在之前Timer的构造函数这块,有一句是:thread.start();说明TimerThread在Timer初始化之后就一直启用着,那看下它的处理。

     public void run() {
            try {
                mainLoop(); //主要实现内容
            } finally {
                // Someone killed this Thread, behave as if Timer cancelled
                synchronized(queue) {
                    newTasksMayBeScheduled = false;
                    queue.clear();  // Eliminate obsolete references
                }
            }
        }
    
        /**
         * The main timer loop.  (See class comment.)
         */
        private void mainLoop() {
            while (true) {
                try {
                    TimerTask task;
                    boolean taskFired;
                    synchronized(queue) {
                        // Wait for queue to become non-empty
                       //如果队列为空并且是有标志位,则等待。没有标志位的情况为不在需要执行timer了,比如cancel或被gc的时候
                        while (queue.isEmpty() && newTasksMayBeScheduled) 
                            queue.wait();
                        if (queue.isEmpty())
                            break; // Queue is empty and will forever remain; die
    
                        // Queue nonempty; look at first evt and do the right thing
                        long currentTime, executionTime;//分别是当前时间、理论执行时间
                        task = queue.getMin();//获取就近的task
                        synchronized(task.lock) {
                           //如果该task已经被置为cancelled,则将它从队列里面移出
                            if (task.state == TimerTask.CANCELLED) {
                                queue.removeMin();
                                continue;  // No action required, poll queue again
                            }
                            currentTime = System.currentTimeMillis();
                            executionTime = task.nextExecutionTime;
                            if (taskFired = (executionTime<=currentTime)) {
                                if (task.period == 0) { // period表示该task是一次性的,用完就移出
                                    queue.removeMin();//移出task,这块会有queue的重新排序
                                    task.state = TimerTask.EXECUTED;//更新状态为执行中
                                } else {
                            //可重复执行的task操作,将重新计算下次执行时间,并重新排序    
                    //重点,此处解释为什么period分正负:区别schedule方法和scheduleAtFixedRate
                            //如果是负数,则以当前时间为准,往后计算下次执行时间
                            //如果是正数,则以理论时间为准,往后计算下次执行时间
                                    queue.rescheduleMin(
                                      task.period<0 ? currentTime   - task.period
                                                    : executionTime + task.period);
                                }
                            }
                        }
                        if (!taskFired) // 如果还没到任务执行时间就处于等待
                            queue.wait(executionTime - currentTime);
                    }
                    if (taskFired)  // 到执行时间了
                    //执行task中的run方法,而不是start方法,所以并不是另起一个线程进行操作
                        task.run();
                } catch(InterruptedException e) {//如果是不能捕获的异常,就会有风险了
                }
            }
        }

    关于queue中的removeMin()和rescheduleMin()方法如下:

        void removeMin() {//前两行赋值可能会将queue乱序,所以才会有fixDown重新排序
            queue[1] = queue[size];
            queue[size--] = null;  // Drop extra reference to prevent memory leak
            fixDown(1);
        }
    
        //因为取的时候也是取下标为1的task进行操作,所以此次也是将下标为1的task重新赋时间,并排序
        void rescheduleMin(long newTime) {
            queue[1].nextExecutionTime = newTime;
            fixDown(1);
        }
    
        //和fixUp方法类似,该排序单独看也并非严谨,但由于每次操作都会经历,所以应该是准的吧!
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size && j > 0) {
                if (j < size &&
                    queue[j].nextExecutionTime > queue[j+1].nextExecutionTime)
                    j++; // j indexes smallest kid
                if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)
                    break;
                TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
                k = j;
            }
        }

    当timerTask调用了timerTask.cancel()操作时,也可以人为的将它从Timer队列中清除掉,方法如下:

     public int purge() {
             int result = 0;
    
             synchronized(queue) {
                 for (int i = queue.size(); i > 0; i--) {
                     if (queue.get(i).state == TimerTask.CANCELLED) {
                         queue.quickRemove(i); //由于i取值时必然大于0,所以肯定能够找到正常的数据
                         result++;
                     }
                 }
    
                 if (result != 0)
                     queue.heapify();//重新排序
             }
    
             return result;
         }

    queue中的quickRemove和heapify方法:

        void quickRemove(int i) { //只要简单赋值就行了,最后排序交给heapify()
            assert i <= size;
    
            queue[i] = queue[size];
            queue[size--] = null;  // Drop extra ref to prevent memory leak
        }
    
        void heapify() {
            for (int i = size/2; i >= 1; i--)
                fixDown(i); //在前面的篇幅中介绍过了
        }

    当然如果Timer也可以人为的取消,不在继续定时任务。其方法如下:

       public void cancel() {
            synchronized(queue) {
                thread.newTasksMayBeScheduled = false;
                queue.clear(); //会将队列中的所有的task赋值为null
                queue.notify();  // 通知thread中的mainLoop进行break操作
            }
        }

    综上,其实大部分流程就屡清楚了。顺带介绍下Timer中的threadReaper。代码如下:

       /**
         * This object causes the timer's task execution thread to exit
         * gracefully when there are no live references to the Timer object and no
         * tasks in the timer queue.  It is used in preference to a finalizer on
         * Timer as such a finalizer would be susceptible to a subclass's
         * finalizer forgetting to call it.
         */
        private final Object threadReaper = new Object() {
            protected void finalize() throws Throwable {
                synchronized(queue) {
                    thread.newTasksMayBeScheduled = false;
                    queue.notify(); // In case queue is empty.
                }
            }
        };

    重写了finalize方法,该方法为GC时候调用,主要使Timer中的thread能够优雅退出。

    4、总结

    优势:可以实现比较轻量级的定时任务,而且很方便

    劣势:

    ①由于Timer只是创建了一个thread去执行queue中的task,那么就可能会出现上一个任务执行延迟了,会影响到下一个定时任务。

    ②在TimerThread#mainloop中,也可看到,如果抛出了InterruptedException之外无法捕获到的异常时,mainloop就会中断,Timer也就无法使用了。

     

              

    展开全文
  • Java中TimerTask实现“心跳”线程

    千次阅读 2013-10-24 20:16:25
    最近看到openfire 源码有一段利用JavaTimerTask实现心跳线程的示例,贴出来,大家参考一下 //其实很简单,定义TimerTask实体对象 TimerTask heartbeatTask = new TimerTask() { @Override public void run()...

    最近看到openfire 源码中有一段利用Java的TimerTask实现心跳线程的示例,贴出来,大家参考一下

    //其实很简单,定义TimerTask实体对象
    TimerTask heartbeatTask = new TimerTask() {
    public void run() {
                    try {
                        for (ConnectionMultiplexerSession session : sessionManager.getConnectionMultiplexerSessions()) {
                            session.deliverRawText(" ");
                        }
                    }
                    catch(Exception e) {
                        Log.error(e.getMessage(), e);
                    }
                }
            };
    //这里openfire用封装类TaskEngine启动TimerTask,其实就是下面红色代码启动的
    TaskEngine.getInstance().schedule(heartbeatTask, 30*JiveConstants.SECOND, 30*JiveConstants.SECOND);

    TaskEngine对于schedule的定义如下

     /**
         * Schedules the specified task for repeated <i>fixed-delay execution</i>,
         * beginning after the specified delay.  Subsequent executions take place
         * at approximately regular intervals separated by the specified period.
         *
         * @param task task to be scheduled.
         * @param delay  delay in milliseconds before task is to be executed.
         * @param period time in milliseconds between successive task executions.
         * @throws IllegalArgumentException if <tt>delay</tt> is negative, or
         *         <tt>delay + System.currentTimeMillis()</tt> is negative.
         * @throws IllegalStateException if task was already scheduled or
         *         cancelled, timer was cancelled, or timer thread terminated.
         */
    
    public void schedule(TimerTask task, long delay, long period) {
            TimerTaskWrapper taskWrapper = new TimerTaskWrapper(task);
            wrappedTasks.put(task, taskWrapper);
    	//TimerTaskWrpper采用线程池管理这些心跳线程
            timer.schedule(taskWrapper, delay, period);
        }


    展开全文
  • Timer是一种线程设施,用于安排以后在后台线程执行的任务。可安排任务执行一次,或者定期重复执行,可以看成一个定时器,可以调度... import java.util.TimerTask; public class OneTask extends Tim...
  • Java Timer 和 TimerTask

    2016-11-21 11:54:41
    TimerTask则是一个抽象类,其中有一个抽象方法run(),类型线程的run()方法。我们使用Timer创建一个他的对象,然后使用这对象的schedule方法来完成这种间隔的操作。schedule方法有三个参数,其中第一个参数就是...
  • 本篇文章主要介绍了解析Java中的Timer和TimerTask在Android的用法,主要介绍了Timer和TimerTask的用法,有需要的可以了解一下。
  • 主要介绍了Java Timer和TimerTask 定时器和定时任务使用的例子,非常具有实用价值,需要的朋友可以参考下
  • public class PushMsgAPP extends TimerTask{ @Override public void run() { // TODO Auto-generated method stub System.out.println("---开始推送通知到APP---"); ResupplyPayAccount...
  • 详解JAVA Timer和TimerTask

    2020-08-18 17:07:03
    主要介绍了JAVA Timer和TimerTask的相关资料,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 主要为大家详细介绍了java定时任务Timer和TimerTask使用方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 实现效果: 代码实现: ...import java.util.TimerTask; /** * @author 在下令狐 * @date 2020/10/27 */ public class TimerTaskManager { public static void main(String[] args) { Timer
  • 其实就Timer来讲就是一个调度器,而TimerTask呢只是一个实现了run方法的一个类,而具体的TimerTask需要由你自己来实现 思路 本人的思路是这样的。 创建一个Timer对象,然后通过创建一个MyTask去继承父类TimerTask...
  • Java中的Timer和TimerTask简介(附完整代码实例)。 在Java中,Timer和TimerTask是两个经常用来实现定时器的类。这两个类使用起来非常方便,可以完成我们对定时器的绝大多数需求。 Timer是一种定时器工具,用来在一...
  • package Test;...import java.util.TimerTask; public class Test { static boolean isEnd = false; //控制TimerTask的结束标识 static int count = 1; //循环计数器 static Timer timer = new Ti...
  • java.util提供的一个有趣并且有用的特性就是在将来某些时候安排执行任务的能力。支持这一功能的类是Timer和TimerTask。使用这些类,可以创建在后台运行、等等特定时刻的线程。当时间到达时,执行链接到线程的任务。...
  • 定时配置 ![图片说明](https://img-ask.csdn.net/upload/201710/23/1508728239_250669.png) 定时任务 ![图片说明]...方法调用 !...大家帮忙看一下,问题出在哪里
  •  我们做一个缓存来减少与数据库的交互,而为了使缓存与数据库的数据尽量达到同步,需要每个固定的一段时间去数据库的数据是否有更新以达到与缓存的同步。这样的需求可以做一个线程,线程做一个死循环,循环...
  • 直接上代码 TimerTask的第二个参数delay表示延时多久开始定时任务,第三个参数period表示定时任务的间隔 ...import java.util.TimerTask; public class Main { public static void main(Stri...
  • java中定时器Timer/TimerTask的使用方法

    千次阅读 2016-11-02 11:34:31
    第一种方法:schedule(TimerTask task, long delay) 设定指定任务task在指定延迟delay后执行 第二种方法:schedule(TimerTask task, long delay, long period) 设定指定任务task在指定延迟delay后进行固定频率...
  • java之Timer和TimerTask简单demo 代码:测试类 public class MyTestTimer { public static Timer mTimer; public static void main(String[] args) { mTimer=new Timer(); MyTimerTask testTimer=new ...
  • 1.java.util.TimerTask类 public abstract class TimerTask implements Runnable 可由一个定时器进行一次或多次执行的任务。 scheduledExecutionTime方法返回任务最近执行的时间 cancel方法是停止任务执行 ...
  • Java中Timer和TimerTask使用

    千次阅读 2018-05-29 22:33:13
    Java提供了轻量级的定时任务实现Timer,通过Timer我们可以实现定时执行任务,定时循环执行任务的功能,我们先看JavaDoc关于Timer的说明 一种工具,线程用其安排以后在后台线程执行的任务。可安排任务执行一次...
  • 1:java.util.Timer定时器的常用方法如下: 2:参数含义: 3.暂停任务: 4.例子: 1:java.util.Timer定时器的常用方法如下: schedule(TimerTask task, long delay) // 延迟delay毫秒后,执行一次task。 ...
  • Java定时器(一)Timer和TimerTask

    千次阅读 2017-04-09 22:09:41
    方式一:设定指定任务task在指定时间time执行 schedule(TimerTask task, Date date) public static void main(String[] args) throws Exception { // TODO Auto-generated method stub new Timer()....
  • 下面小编就为大家带来一篇java之Timer和TimerTask简单demo(分享)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,863
精华内容 13,145
关键字:

java中的timertask

java 订阅