精华内容
下载资源
问答
  • java 定时器Timer

    2010-06-21 15:54:43
    java 定时器Timerjava 定时器Timerjava 定时器Timer
  • 主要介绍了Java 定时器Timer)及线程池里使用定时器实例代码的相关资料,需要的朋友可以参考下
  • java定时器timer类操作详解 java定时器timer类操作详解
  • 主要介绍了 Java 定时器Timer,TimerTask)详解及实例代码的相关资料,需要的朋友可以参考下
  • java定时器Timer使用与原理分析

    万次阅读 2018-11-07 16:10:15
    Timer是jdk中提供的一个定时器工具,使用的时候会在主线程之外起一个单独的线程执行指定的计划任务,可以指定执行一次或者反复执行多次。 TimerTask是一个实现了Runnable接口的抽象类,代表一个可以被Timer执行的...

    Timer和TimerTask

    Timer是jdk中提供的一个定时器工具,使用的时候会在主线程之外起一个单独的线程执行指定的计划任务,可以指定执行一次或者反复执行多次。

    TimerTask是一个实现了Runnable接口的抽象类,代表一个可以被Timer执行的任务。

    【使用举例】

    【schedule(TimerTask task, long delay) 延迟 delay 毫秒 执行】

    public static void main(String[] args) {
            for (int i = 0; i < 10; ++i) {
                new Timer("timer - " + i).schedule(new TimerTask() {
                    @Override
                    public void run() {
                        println(Thread.currentThread().getName() + " run ");
                    }
                }, 1000);
            }
        }

    【schedule(TimerTask task, Date time) 特定时间执行】

    public static void main(String[] args) {
            for (int i = 0; i < 10; ++i) {
                new Timer("timer - " + i).schedule(new TimerTask() {
                    @Override
                    public void run() {
                        println(Thread.currentThread().getName() + " run ");
                    }
                }, new Date(System.currentTimeMillis() + 2000));
            }
        }

    【schedule(TimerTask task, long delay, long period) 延迟 delay 执行并每隔period 执行一次】

    public static void main(String[] args) {
            for (int i = 0; i < 10; ++i) {
                new Timer("timer - " + i).schedule(new TimerTask() {
                    @Override
                    public void run() {
                        println(Thread.currentThread().getName() + " run ");
                    }
                }, 2000 , 3000);
            }
        }

    【原理分析】

    timer底层是把一个个任务放在一个TaskQueue中,TaskQueue是以平衡二进制堆表示的优先级队列,他是通过nextExecutionTime进行优先级排序的,距离下次执行时间越短优先级越高,通过getMin()获得queue[1]

    并且出队的时候通过synchronized保证线程安全,延迟执行和特定时间执行的底层实现类似,源码如下:

    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;
                    task.period = period;
                    task.state = TimerTask.SCHEDULED;
                }
    
                queue.add(task);
                if (queue.getMin() == task) // 如果当前任务处于队列的第一个说明轮到这个任务执行了
                    queue.notify();
            }
        }

    我们主要来看下周期性调度通过什么方式实现的,我们直接来分析源码如下:

    private void mainLoop() {
      // 首先一直监听队列中有没有任务
            while (true) {
                try {
                    TimerTask task;
                    boolean taskFired;
        // 同步,保证任务执行顺序
                    synchronized(queue) {
                        // Wait for queue to become non-empty
                        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();
                        synchronized(task.lock) {
                            if (task.state == TimerTask.CANCELLED) {
                                queue.removeMin();
                                continue; // No action required, poll queue again
                            }
                            currentTime = System.currentTimeMillis();
          // 获取任务下次执行时间
                            executionTime = task.nextExecutionTime;
                            if (taskFired = (executionTime<=currentTime)) {
           // 到这里是延迟执行和特定时间点执行已经结束了,状态标记为EXECUTED,周期性执行继续往下走
                                if (task.period == 0) { // Non-repeating, remove
                                    queue.removeMin();
                                    task.state = TimerTask.EXECUTED;
                                } else { // Repeating task, reschedule
            // 这里他又重新计算了下下个任务的执行,并且任务还在队列中
                                    queue.rescheduleMin(
                                      task.period<0 ? currentTime - task.period
                                                    : executionTime + task.period);
                                }
                            }
                        }
         // 如果任务执行时间大于当前时间说明任务还没点,继续等,否则执行run代码块
                        if (!taskFired) // Task hasn't yet fired; wait
                            queue.wait(executionTime - currentTime);
                    }
                    if (taskFired) // Task fired; run it, holding no locks
                        task.run();
                } catch(InterruptedException e) {
                }
            }
        }
    }

    这种定时器适合单点或者多台同时执行互不影响的场景

    【缺点】

    1、首先Timer对调度的支持是基于绝对时间的,而不是相对时间,所以它对系统时间的改变非常敏感。

    2、其次Timer线程是不会捕获异常的,如果TimerTask抛出的了未检查异常则会导致Timer线程终止,同时Timer也不会重新恢复线程的执行,他会错误的认为整个Timer线程都会取消。同时,已经被安排单尚未执行的TimerTask也不会再执行了,新的任务也不能被调度。故如果TimerTask抛出未检查的异常,Timer将会产生无法预料的行为

    3、Timer在执行定时任务时只会创建一个线程任务,如果存在多个线程,若其中某个线程因为某种原因而导致线程任务执行时间过长,超过了两个任务的间隔时间,会导致下一个任务执行时间滞后

    这些缺点可以通过ScheduledExecutorService来代替

    展开全文
  • 主要为大家详细介绍了Java定时器Timer使用方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java定时器Timer

    2016-09-07 21:54:00
    项目中往往会遇到需要定时的任务,例如订单,当用户在某个规定时间内没有操作订单时,订单状态将会发生改变。 ... 5 * java定时器 6 * @author Administrator 7 * 8 */ 9 public class...

    项目中往往会遇到需要定时的任务,例如订单,当用户在某个规定时间内没有操作订单时,订单状态将会发生改变。

    那么在这种情况下,我们会用到定时器。

    举例:

     1 import java.util.Timer;
     2 
     3 
     4 /**
     5  * java定时器
     6  * @author Administrator
     7  *
     8  */
     9 public class TimeTaskTest {
    10     public static void main(String[] args) {
    11         Timer timer = new Timer();
    12         System.out.println("开始执行");
    13         timer.schedule(new Test(), 10 * 1000);
    14         System.out.println("呵呵呵");
    15     }
    16     
    17 }

    实例化 Timer 并调用 schedule 方法
    schedule有四个重载方法:

    以第二个举例子 

     timer.schedule(new Test(), 10 * 1000);

     第一个参数是要执行的任务,第二个参数是毫秒数的时间,比如 10秒 就是10*1000;

     【待续】

    转载于:https://www.cnblogs.com/net-safe/p/5702457.html

    展开全文
  • 本文首先设计一个单次定时器Timer+TimerTask,然后再次基础上设计一个循环定时器。
  • Java 定时器Timer

    2019-07-08 14:23:30
    这时候我们就要去设置个定时器Java中最方便、最高效的实现方式是用java.util.Timer工具类,再通过调度java.util.TimerTask任务。 1、简介 Timer是一种工具,线程用其安排以后在后台线程中执行的任务。可安排...

      在开发中,我们经常需要一些周期性的操作,例如每隔几分钟就进行某一项操作。这时候我们就要去设置个定时器,Java中最方便、最高效的实现方式是用java.util.Timer工具类,再通过调度java.util.TimerTask任务。

     

        1、简介

        Timer是一种工具,线程用其安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行。实际上是个线程,定时调度所拥有的TimerTasks。

        TimerTask是一个抽象类,它的子类由 Timer 安排为一次执行或重复执行的任务。实际上就是一个拥有run方法的类,需要定时执行的代码放到run方法体内。

     

        2、调用方法

    Timer timer = Timer(true);   
    // 注意,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   
    // 毫秒执行一次。

      schedule()与scheduleAtFixedRate()的区别?

        首先schedule(TimerTask task,Date time)与schedule(TimerTask task,long delay)都只是单次执行操作,并不存在多次调用任务的情况,所以没有提供scheduleAtFixedRate方法的调用方式。它们实现的功能都一样,那区别在哪里呢?

        (1)schedule()方法更注重保持间隔时间的稳定:保障每隔period时间可调用一次。

        (2)scheduleAtFixedRate()方法更注重保持执行频率的稳定:保障多次调用的频率趋近于period时间,如果某一次调用时间大于period,下一次就会尽量小于period,以保障频率接近于period。

     

        3、示例演示

        定制任务:

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

      调用java.util.Timer:

    import java.util.Timer;  
    /**
    * 安排指定的任务task在指定的时间firstTime开始进行重复的固定速率period执行
    * 每天中午12点都执行一次 
    */ 
      
    public class Test {  
    public static void main(String[] args){  
       Timer timer = new Timer();  
       Calendar calendar = Calendar.getInstance();
       calendar.set(Calendar.HOUR_OF_DAY, 12);//控制小时
       calendar.set(Calendar.MINUTE, 0);//控制分钟
       calendar.set(Calendar.SECOND, 0);//控制秒
       Date time = calendar.getTime();//执行任务时间为12:00:00
            
       Timer timer = new Timer(); 
       //每天定时12:00执行操作,延迟一天后再执行
       timer.schedule(new TimerTaskTest(), time, 1000 * 60 * 60 * 24);  
    }  
    }

     

        结语:文中只是简单的介绍了下java自带的定时器工具类Timer,若有不足之处还望指出。有兴趣者可以去查查看另一个定时器的开源项目:QUARTZ。 分享是一种快乐,坚持是一种精神。

    展开全文
  • 主要介绍了java定时器timer使用方法代码示例,向大家分享了两部分代码,详细内容请参见正文,还是比较不错的,需要的朋友可以参考下。
  • 首先,了解什么是(Timer):Timer,定时器,功能是在指定的时间间隔内反复触发指定窗口的定时器事件。现在用一个案例来具体了解下定时器使用。需求:模拟骑车时间,比如,每骑行一秒就输出一句“骑行第几秒”,直到...

    首先,了解什么是(Timer):Timer,定时器,功能是在指定的时间间隔内反复触发指定窗口的定时器事件。

    现在用一个案例来具体了解下定时器的使用。

    需求:模拟骑车时间,比如,每骑行一秒就输出一句“骑行第几秒”,直到用户输如随意指令就停止输出。

    执行效果如图所示:


    效果分析:首先需要控制台输入一个任意指令,让程序开始跑起来,接着开始每隔一秒钟输出一句话提醒用户。直到用户再次随意输入一个指令,输出停止。

    在开始写代码之前,我们要明确,这肯定不是一个线程就能解决的事情,因为一个线程就只有一条线再跑,而用户输入就需要一个Scanner语句,但凡是Scanner语句,一定会在跑的这个线阻塞在Scanner的输入语句上面,那么这时候,就可以引用定时器这个东西。

    以上的执行效果代码如下:

    
    
    System.out.print("你輸入啥都可以開始使用");
        if (in.next() != null) {
            Timer timer=new Timer();
            timer.schedule(new TimerTask() {
                int i=0;
                @Override
                public void run() {
                    i=i+1;
                    System.out.println("骑行第"+(i)+"秒");
                    times=i;
                }
            },0,1000);
            if(in.next()!=null){
                timer.cancel();
                System.out.println("骑行结束!");
    
            }
      }  

    代码分析

    首先让用户随意输入一个指令,判断当这个输入的指令不为空时,就走进计时器中,此时走入if语句当中。

    接着实例化一个定时器,也就是Timer timer=new Timer;

    调用Timer的schedule(TimerTask task(){},延迟时间,定时时间)方法。这时候调用这个方法需要传三个参数给这个方法,一个是TimerTask的一个抽象类,延迟时间,定时的时间,时间都用毫秒计算。强调一点,TimerTask是一个抽象类,就要继承这个抽象类中的所有方法,发现这个抽象类中有一个run()方法,这个时候,就需要将我们需要的输出“骑行第多少秒”这句话写在run方法中,让这个定时器每次走的时候,都输出,没有给他停止的命令,他就会一直走。

    这个时候,主线程中,有一个一直等待用户输入的语句,这个和计时器的运行不冲突,直到用户输入了任意指令,进入一个if里面,接着执行timer的cancel()方法,将这个计时器停止掉,此时,计时器的功能就停止了,继续开始执行主线程。

    展开全文
  • Java定时器Timer简述

    2020-08-31 16:39:28
    本文主要介绍了Java定时器Timer的相关知识,具有一定的参考价值,下面跟着小编一起来看下吧
  • java定时器Timer详解

    千次阅读 2019-08-27 16:19:31
    java定时器Timer 简单使用
  • 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...
  • 我们通常写的timer都是用main方法写的定时器,但同样我们也需要根据服务器启动后定时器也启动的 定时执行任务。不过有个致命伤就是集群方面跟quartz不能比,此方法代码做参考不错,如果要用,那么这个方法在一台...
  • Java进阶(十八)Java实现定时器(Timer)

    万次阅读 2015-11-24 08:10:43
    Java实现定时器(Timer) 绪 在应用开发中,经常需要一些周期性的操作,比如每5分钟执行某一操作等。对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。java.util这个包中可以找到Timer和TimerTask...
  • java定时器Timer问题汇总

    千次阅读 2017-12-04 13:51:08
    import java.util.Timer; import java.util.TimerTask; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; ...
  • 实现的功能:距离当前系统时间,在指定多少分钟后,执行一件事...java定时器timer执行一次后就停止,我需要达到的要求就是只执行一次,如果不停止jvm虚拟机会一直运行,时间久了势必会消耗CPU资源,占用内容,正如上面
  • java定时器Timer

    2019-11-10 10:55:49
    java定时器Timer
  • Java定时器Timer使用

    2018-06-29 09:06:13
    最近在实现比赛倒计时投票的功能,先后考虑使用session,Cookie 或 WebStorage 来实现,但最终采用Java定时器Timer实现了此功能。 以下是Timer的使用方法 public class TestTimer { public static void main...
  • java5定时器java Timer

    2019-08-02 11:21:24
    NULL 博文链接:https://jiangnanlove.iteye.com/blog/1958648
  • Java定时器Timer

    2020-05-27 13:47:31
    定时器Timer使用 创建Timer对象: Timer timer = new Timer(); 创建TimerTask执行任务: //定义成员变量; int number = 8; boolean isCancelTimer = false; TimerTask timerTask = new TimerTask() { int ...
  • java定时器Timer

    2008-05-27 13:27:13
    java定时器说明与应用
  • timer.schedule(new MyTask(),long time1,long timer2); 今天算是彻底的搞懂了这个曾经让我为之头疼的方法。下面我就重点介绍一下: 第一个参数,是 TimerTask 类,在包:import Java.util.TimerTask .使用者要...
  • java定时器 Timer

    千次阅读 2009-05-12 11:33:00
    java定时器 Timerjava定时器使用Timer)1、在应用开发中,经常需要一些周期性的操作,比如每5分钟执行某一操作等。对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。private java.util....
  • 完成一个java application应用程序,使用定时器编程,在实时显示当前时间,每1秒时钟内容更新一次。 完成一个java application应用程序,在应用程序主进程中新开一个线程,此线程进行死循环,每1秒被激活一次,激活...
  • JAVA定时器Timer使用

    2017-08-08 10:19:09
    java定时器的实现主要是靠Timer来实现的 Timer中的常用的几个方法:  /**  *任务在delay时间后执行且只执行一次  **/  public void schedule(TimerTask task,long delay);  /**  *任务在时间为date...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,406
精华内容 10,162
关键字:

java定时器的使用(timer)

java 订阅