精华内容
下载资源
问答
  • 定时任务Timer实现有可能出现异常,因为它是基于...如果在TimerTask里抛出了异常,那么Timer认为定时任务取消并终止执行线程。举例: package com.wlf.concurrent; import java.util.Timer; import java.util

    https://www.cnblogs.com/wuxun1997/p/6822904.html

    定时任务用Timer实现有可能出现异常,因为它是基于绝对时间而不是相对时间进行调度的。当环境的系统时间被修改后,原来的定时任务可能就不跑了。另外需要捕获并处理定时任务抛出的异常。如果在TimerTask里抛出了异常,那么Timer认为定时任务被取消并终止执行线程。举例:

    package com.wlf.concurrent;
    
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class OutOfTime {
    
        public static void main(String[] args) throws InterruptedException {
            Timer timer = new Timer();
    
            // 设置一个一次性的定时任务,1秒后执行
            timer.schedule(new PrintTask(), 1000);
    
            // 休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
            // 设置一个一次性任务,间隔1秒执行
            timer.schedule(new ThrowTask(), 1000);
    
            // 休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
            // 再设置一个周期性任务,可是不会再来了
            timer.schedule(new PrintTask(), 1000, 1000);
        }
    
        static class PrintTask extends TimerTask {
    
            @Override
            public void run() {
                System.out.println("I'm coming...");
            }
    
        }
    
        static class ThrowTask extends TimerTask {
    
            @Override
            public void run() {
                throw new RuntimeException();
            }
    
        }
    }
    

    运行结果:

    I'm coming...
    Exception in thread "Timer-0" java.lang.RuntimeException
        at com.wlf.concurrent.OutOfTime$ThrowTask.run(OutOfTime.java:50)
        at java.util.TimerThread.mainLoop(Timer.java:555)
        at java.util.TimerThread.run(Timer.java:505)
    Exception in thread "main" java.lang.IllegalStateException: Timer already cancelled.
        at java.util.Timer.sched(Timer.java:397)
        at java.util.Timer.schedule(Timer.java:248)
        at com.wlf.concurrent.OutOfTime.main(OutOfTime.java:34)
    

    如果注掉这一行,那么定时任务还是会一直跑下去的

    timer.schedule(new ThrowTask(), 1000);
    

    或者捕获异常并处理:

    static class ThrowTask extends TimerTask {
    
            @Override
            public void run() {
                try {
                    throw new RuntimeException();
                }catch (Exception e){
                    System.out.println("I catch the exception");
                }
            }
    
        }
    

    输出结果:

    在这里插入图片描述

    展开全文
  • 于是乎,网上一通乱搜,可搜到了python中threading库中的Timer类可以实现定时执行程序,完成定时任务;于是又开始了学海无涯之路… 1. Timer介绍 Timer的中文意思是:定时器,顾名思义我们可以通过对Time的调用来...

    前言

    在弄爬虫时有时候需要定时去爬一些东西,而自己又不可能守在那,这可咋整?于是乎,网上一通乱搜,可搜到了python中threading库中的Timer类可以实现定时执行程序,完成定时任务;于是又开始了学海无涯之路…

    1. Timer介绍

    Timer的中文意思是:定时器,顾名思义我们可以通过对Time的调用来完成一些定时任务,比如定时爬虫,定时推送等;Timer是threading库中的一个类,而threading(线程)是python自带的可以进行多线程编程的库,无需安装直接导入就行。

    2. Timer的基本使用

    使用Timer时,Timer有四个参数,如下
    Timer(interval, function, args=[ ], kwargs={ })

    参数介绍:

    • interval:时间间隔,以秒为单位
    • function:调用的函数
    • args/kwargs:函数的参数 ,以元祖形式传递

    2.1 funtion函数无参数

    from threading import Timer
    
    def funtion():
        #一个简单的功能
        
        for i in range(10):
            print(i)
    
    #5秒后执行funtion函数        
    t = Timer(5, funtion)
    
    #执行定时任务
    t.start()
    
    

    运行上面的程序,5秒后输出如下结果
    在这里插入图片描述
    2.2 function函数有传入参数

    from threading import Timer
    
    def funtion(number):
        #一个简单的功能
        
        for i in range(number):
            print(i)
    
    #5秒后执行funtion函数        
    t = Timer(5, funtion, (6,))#funtion的参数以元祖形式传递
    
    #执行定时任务
    
    t.start()
    

    运行上面程序,5秒后输出以下结果
    在这里插入图片描述
    2.3 实现每隔一段时间后,执行funtion函数

    from threading import Timer
    
    def funtion():
        #一个简单的功能
        print("you can!")
    
    def run_task():
        #5秒后执行funtion函数 
        
        funtion()
        t = Timer(5, run_task)
    
        #执行定时任务
        t.start()
     
    run_task()
    

    调用run_task函数后(发现不调用run_task,也会发生下面的结果),结果如下
    在这里插入图片描述
    2.4 用cancel取消Timer的执行

    from threading import Timer
    
    def funtion():
        #一个简单的功能
        print("you can!")
    
    t = Timer(5, funtion)
    t.start()
    #cancel取消线程t的执行
    t.cancel()
    
    

    这里调用了cancel()函数来取消线程t的执行,所以结果不会打印“you can!”
    在这里插入图片描述

    展开全文
  • Java定时任务调度工具详解之Timer 导航 概述 timer定时函数的用法 其他重要函数 schedule和scheduleAtfixedRate的区别 Timer函数的综合应用 Timer的缺陷 一. 概述 1.1 课程介绍 什么是定时任务调度: ...

    Java定时任务调度工具详解之Timer

    一. 概述

    1.1 课程介绍

    • 什么是定时任务调度:

      • 基于给定的时间点,给定的时间间隔或者给定的执行次数自动执行的任务
    • Java中的定时任务调度工具

      • Timer
      • Quartz
    • 不同点:

      • 出身不同,Timer是自带的,Quartz是需要引入的
      • 能力不同,Timer解决不了的,Quartz可以解决
      • 底层机制,Quartz比Timer好,但是Quartz的配置难一点
    • 需要准备的知识:

      • Timer,Quartz的使用 ->Java基础知识
      • Quartz,Spring的合体 ->Spring基础知识

    1.2 Timer简介

    • Timer的定义:

      • 有且仅有一个后台线程对多个业务线程进行定时定频率的调度
    • 主要构件:

      • Timer—>Time Task (定时调度定时任务)
    • 工具类详解
      在这里插入图片描述

    1.3 实战演练

    • MyTimerTask.java
    import java.util.TimerTask
    public class MyTimerTask extends TimerTask{
    	private String name;
    	public MyTimerTask(String inputName){
    		name=inputName;
    	}
    	@Override
    	public void run(){
    		//打印当前name的内容
    		System.out.println("Current exec name is:"+ name);
    	}
    	public String getName(){
    		return name;
    	}
    	public void setName(String name){
    		this.name=name;
    	}
    }
    
    • 创建 MyTimer.java
    import java.util.Timer
    public class MyTimer{
    	public static void main(String[] args){
    		//1. 创建一个Timer实例
    		Timer timer=new Timer();
    		//2. 创建一个MyTimerTask实例
    		MyTimerTask myTimerTask=new MyTimeTask("No.1");
    		//3. 通过Timer定时定频率调用myTimerTask的业务逻辑
    		//即第一次执行是在当前时间的两秒之后,之后每隔一秒钟执行一次
    		timer.schedule(myTimerTask,2000L,1000L);
    	}
    }
    
    

    二. timer定时函数的用法

    2.1 schedule的四种用法

    • schedule(task,time):
      • 参数:
        • task->所要安排的任务
        • time->执行任务的时间
      • 作用:
        • 在时间等于或者超过time的时候执行且仅执行一次task
          在这里插入图片描述

    在具体的时间执行一次;

    • suchedult(task,time,period)
      • 参数:

        • task: 所要安排的任务
        • time: 首次执行任务的时间
        • period: 执行一次task的时间间隔,单位是毫秒
      • 作用:

        • 时间等于或超过time时首次执行task
        • 之后每隔period毫秒重复执行一次task
    • 实战代码:
      在这里插入图片描述

    使用此schedule,就会从calendar.getTime()时间开始起,每隔2000毫秒执行一次;

    • schedule(task,delay)

      • 作用:
        • 等待delay毫秒后执行且执行一次task
      • 效果图:
        在这里插入图片描述
    • schedule(task,delay,period)

      • 作用:
        • 等待delay毫秒后首次执行task
        • 之后每隔period毫秒重复执行一次task
      • 效果图:
        在这里插入图片描述
    • scheduleAtFixedRate(task,time,period)

      • 参数:

        • task: 所要安排的任务
        • time: 首次执行任务的时间
        • period: 执行一次task的时间间隔,单位是毫秒
      • 作用:

        • 时间等于或超过time时首次执行task
        • 之后每隔period毫秒重复执行一次task
      • 效果图:
        在这里插入图片描述

    • scheduleAtFixedRate(task,delay,period)

      • 参数:
        • task: 所要安排的任务
        • delay:执行任务前的延迟时间,单位是毫秒
        • period: 执行一次task的时间间隔,单位是毫秒
      • 作用:
        • 等待delay毫秒后首次执行task
        • 之后每隔period毫秒重复执行一次task
      • 效果图:
        在这里插入图片描述

    三. 其他重要函数

    3.1 本节内容

    • TimerTask的cancel(),scheduledExcetionTime()
    • Timer的cancel(),purge()

    3.2 代码示例:

    在这里插入图片描述

    这里在自定义的Timer代码里面,使用count定义一个计数器,当count到达3的时候,则执行cancel()方法取消定时任务运行;

    3.3 scheduledExecutionTime()

    • 作用:
      • 返回此任务最近实际执行的已安排执行的时间
    • 返回值:
      • 最近发生此任务执行安排的时间,为long型

    在这里插入图片描述

    返回离我们最近的一次任务的执行时间

    • 展示执行后的效果如下:
      在这里插入图片描述

    3.4 Timer的其他函数

    • cancel() ->这个cancel是隶属于Timer之下的,与之前的是有区别的
      • 作用: 终止此计时器,丢弃所有当前已安排的任务
    • 图示如下:
      在这里插入图片描述

    使用timer.cancel则会使得Timer timer=new Timer();中的timer终止它的所有定时任务;

    3.5 purge()

    • 返回值:从队列中移除的任务数,并且将这个任务从当前队列移除
    • 效果图:
      在这里插入图片描述

    使用purge()返回的不是当前任务数,而是返回被取消的任务数有多少个,并且将这个任务从当前队列移除

    四. schedule与scheduleAtFixedRate的区别

    4.1 两种情况看区别

    • 首次计划执行的时间早于当前的时间(比如第一次任务执行时间早于当前时间)
    • 任务执行所需时间超出任务的执行周期间隔(比如我们一个定时任务每隔2秒钟执行一次,但是每次执行需要耗费3秒)

    4.2 具体区别----首次计划执行的时间早于当前的时间

    • schedule方法
      • “fixed-delay”:如果第一次执行时间被delay(提前)了,随后的执行时间按照上一次实际执行完成的时间点进行计算
    • scheduleAtAFixedRate方法
      • “fixed-rate”: 如果第一次执行时间被delay了,随后的执行时间按照上一次开始的时间点进行计算,并且为了赶上进度会多次执行任务,因此TimerTask中的执行体需要考虑同步;

    4.2 具体区别----任务执行所需时间超出任务的执行周期间隔

    • schedule方法

      • 下一次执行时间相对于上一次实际执行完成的时间点,因此执行时间会不断延后
    • scheduleAtFixedRate方法

      • 下一次执行时间相对于上一次开始的时间点,因此执行时间一般不会延后,因此存在并发性;

    scheduleAtFixedRate更加精确,但是如果存在执行任务所需时间大于任务调度间隔时间,则容易两个任务并行进行,即可能存在并发问题;

    • 效果图:
      在这里插入图片描述

    可以看到,scheduleAtFixedRate更加精确,严格按照设置的每2秒钟执行一次,并不会受到任务耗时所影响,而schedule是根据上一次的成功执行时间然后延后2秒,严格上来讲,这两个是有本质区别的;

    五. Timer函数的综合应用

    5.1 主要内容

    • 通过模拟两个机器人的定时行为来把我们前面所学的主要函数结合起来,让大家加深对这些函数的理解;

    5.2 实现两个机器人

    • 第一个机器人会隔2秒打印最近一次计划的时间、执行内容
    • 第二个机器人会模拟往桶里倒水,直到桶里水满为止;

    5.4 灌水机器人的执行流程

    • 图示:
      在这里插入图片描述

    5.5 跳舞机器人的执行流程

    • 图示:
      在这里插入图片描述

    5.6 代码演示:

    • WaterRobot.java:
    public class WaterRobot extends TimerTask{
    	private Timer timer;
    	//最大容量为5L
    	private Integer bucketCapacity=0;
    	public WaterRobot(Timer inputTimer){
    		timer=inputTimer;
    	}
    	@Override
    	public void run(){
    		//灌水直到桶满为止
    		if(bucketCapacity<5){
    			System.out.println("Add 1L water into the bucket!");
    			bucketCapacity++;
    		}else{
    			//水满了之后停止执行
    			cancel();
    			System.out.println("The waterRobot has been aborted");
    			//等待2秒钟,终止timer里面的所有内容
    			try{
    				Thread.sleep(2000);
    			}catch(InterruptedException e){
    				e.printStackTrace();
    			}
    				timer.cancel();
    		}
    	}
    }
    
    • Executor.java [执行定时任务]
    public class Executor{
    	public static void main(String[] args)throws InterruptedException{
    		Timer timer=new Timer();
    		//获取当前时间
    		Calendar calendar=Calendar.getInstance();
    		SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("Current time is:" + sf.format(calendar.getTime()));
    		timer.schedule(dr,calendar.getTime(),2000);
    		timer.scheduleAtFixedRate(wr,calendar.getTime(),1000);
    	}
    }
    

    跳舞机器人可以自己来实现;

    六. Tiemr的缺陷

    6.1 天生的两种缺陷

    • 管理并发任务的缺陷
      • Timer有且仅有一个线程去执行定时任务,如果存在多个任务,且任务时间过长,会导致执行效果与预期不符;
    • 当任务抛出异常时的缺陷
      • 如果TimerTask 抛出RuntimeException,Timer会停止所有任务的运行

    6.2 Timer的使用禁区

    • 对时效性要求较高的多任务并发作业
    • 对复杂的任务的调度

    如果对这两方面有要求的,可以使用quartz或者集成的分布式任务调度框架;

    展开全文
  • 一.Timer简介定时任务的基本概念,Timer的函数,综合运用和缺陷基于给定的时间点,给定的时间间隔或者给定的执行次数自动执行的任务。Timer 和QuartzTimer: 出身:由jdk提供,调用方式简单粗暴; 能力:Timer能...

    一.Timer简介

    定时任务的基本概念,Timer的函数,综合运用和缺陷


    基于给定的时间点,给定的时间间隔或者给定的执行次数自动执行的任务。

    Timer 和Quartz

    Timer:
    出身:由jdk提供,调用方式简单粗暴;
    能力:Timer能完成一些简单的定时任务,如需要指定某个具体时间执行任务的话,Timer就能轻松实现。

    Quartz
    出身:需要引入架包
    能力:能完成比较复杂的功能需求
    底层机制:能够实现多个执行线程


    定义:有且仅有一个后台线程对多个业务线程进行定时定频率的调度

    Timer(后台执行线程)对TimerTask(业务线程)的定时调用

    这里写图片描述


    通过程序来讲解Timer,打开Eclipse

    创建java工程MyTimerProject

    创建包和class文件

    这里写图片描述

    这里写图片描述

    MyTimerTask.java

    package com.vishuo.timer;
    
    import java.util.TimerTask;
    
    public class MyTimerTask extends TimerTask{
        private String name;
        public MyTimerTask(String inputName){
            name=inputName;
        }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            //打印当前name的内容
            System.out.println("Current exec name is:"+name);
        }
        /**
         * @return the name
         */
        public String getName() {
            return name;
        }
        /**
         * @param name the name to set
         */
        public void setName(String name) {
            this.name = name;
        }
    
    }
    
    

    创建MyTimer类

    package com.vishuo.timer;
    
    import java.util.Timer;
    
    public class MyTimer {
      public static void main(String[] args) {
        //1.创建一个timer实例
          Timer timer = new Timer();
        //2.创建一个MyTimerTask实例
          MyTimerTask myTimerTask = new MyTimerTask("No.1");
        //3.通过timer定时定频率调用myTimerTask的业务逻辑
          //即第一次执行是在当前时间的两秒之后,之后每隔一秒钟执行一次
          timer.schedule(myTimerTask, 2000L,1000L);
    }
    }
    

    二.timer定时函数的用法

    schedule的四种用法

    第一种用法:

    schedule(task,time)
    参数:task-所要安排的任务
    time-执行任务的时间
    作用:在时间等于或超过time的时候执行且仅执行一次task

    第二种用法

    schedule(task,time,period)
    参数
    task—所要安排的任务
    time—首次执行任务的时间
    period—执行一次task的时间间隔,单位是毫秒

    作用
    时间等于或超过time时首次执行task
    之后每隔period毫秒重复执行一次task

    第三种用法

    schedule(task,delay)

    参数
    task—所要安排的任务
    delay—执行任务前的延迟时间,单位是毫秒

    作用:等待delay毫秒后执行且仅执行一次task

    第四种用法

    schedule(task,delay,period)

    参数
    task—所要安排的任务
    delay—执行任务前的延迟时间,单位是毫秒
    period—执行一次task的时间间隔,单位是毫秒

    作用:等待delay毫秒后首次执行task
    之后没隔period毫秒重复执行一次task

    scheduleAtFixedRate的两种用法

    第一种用法:

    scheduleAtFixedRate(task,time,period)
    参数
    task—所要安排的任务
    time—首次执行任务前的时间
    period—执行一次task的时间间隔,单位是毫秒

    作用:时间等于或超过time时首次执行task
    之后每隔period毫秒重复执行一次task

    scheduleAtFixedRate(task,delay,period)
    参数
    task—所要安排的任务
    delay—执行任务前的延迟时间,单位是毫秒
    period—执行一次task的时间间隔,单位是毫秒

    作用:等待delay毫秒后首次执行task
    之后没隔period毫秒重复执行一次task

    全部方法代码示例:

    MyTimerTask类

    package com.vishuo.timer;
    
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.TimerTask;
    
    public class MyTimerTask extends TimerTask{
        private String name;
        public MyTimerTask(String inputName){
            name=inputName;
        }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            //以yyyy-MM-dd HH:mm:ss的格式打印当前执行时间
            //如2016-11-11 00:00:00
            Calendar calendar = Calendar.getInstance();
            SimpleDateFormat sf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println("Curren exec time is:"+sf.format(calendar.getTime()));
            //打印当前name的内容
            System.out.println("Current exec name is:"+name);
        }
        /**
         * @return the name
         */
        public String getName() {
            return name;
        }
        /**
         * @param name the name to set
         */
        public void setName(String name) {
            this.name = name;
        }
    
    }
    

    MyTimer类

    package com.vishuo.timer;
    
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Timer;
    
    public class MyTimer {
      public static void main(String[] args) {
    //  1.创建一个timer实例
          Timer timer = new Timer();
    //  2.创建一个MyTimerTask实例
          MyTimerTask myTimerTask = new MyTimerTask("No.1");
    //  3.通过timer定时定频率调用myTimerTask的业务逻辑
          //即第一次执行是在当前时间的两秒之后,之后每隔一秒钟执行一次
    //    timer.schedule(myTimerTask, 2000L,1000L);
    
          /*
           * 获取当前时间,并设置成距离当前时间三秒之后的时间
           * 如当前时间是2016-11-10 23:59:57
           * 则设置后的时间则为2016-11-11 00:00:00
           */
          Calendar calendar = Calendar.getInstance();
          SimpleDateFormat sf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
          System.out.println(sf.format(calendar.getTime()));//获取当前时间
          calendar.add(Calendar.SECOND, 3);//获取当前时间后三秒的时间
    
    //    ______schedule的用法______
          /*
           * 1.在时间等于或超过time的时候执行且仅执行一次task
           * 如在2016-11-11 00:00:00执行一次task:打印任务的名字
           */
    //    myTimerTask.setName("schedule1");
    //    timer.schedule(myTimerTask, calendar.getTime());
    
          /*
           * 2.时间等于或超过time时首次执行task
           * 之后每隔period毫秒重复执行一次task
           * 如在2016-11-11 00:00:00第一次执行task:打印任务的名字
           * 之后每隔两秒执行一次task
           */
    //    myTimerTask.setName("schedule2");
    //    timer.schedule(myTimerTask, calendar.getTime(),2000);
    
          /*
           * 3.等待delay毫秒后执行且仅执行一次task
           * 如现在是2016-11-11 00:00:00
           * 则在2016-11-11 00:00:00执行一次task:打印任务的名字
           */
    //    myTimerTask.setName("schedule3");
    //    timer.schedule(myTimerTask, 1000);
    
          /*
           * 4.等待delay毫秒后首次执行task
           * 之后每隔period毫秒重复执行一次task
           * 如现在是2016-11-11 00:00:00
           * 则在2016-11-11 00:00:00第一次执行task:打印任务的名字
           * 之后每隔两秒执行一次task
           */
    //    myTimerTask.setName("schedule4");
    //    timer.schedule(myTimerTask, 3000,2000);
    
    //    —————————— scheduleAtFixedRate的用法   ——————————
          /*
           * 1.时间等于或超过time时首次执行task
           * 之后没隔period毫秒重复执行一次task
           * 如在2016-11-11 00:00:00第一次执行task:打印任务名字
           * 之后每隔两秒执行一次task
           */
    //    myTimerTask.setName("scheduleAtFixedRate1");
    //    timer.scheduleAtFixedRate(myTimerTask, calendar.getTime(), 2000);
    
          /*
           * 2.等待delay毫秒首次执行task
           * 之后没隔period毫秒重复执行一次task
           * 如在2016-11-11 00:00:00
           * 则在2016-11-11 00:00:01第一次执行task:打印任务名字
           * 之后每隔两秒执行一次task
           */
          myTimerTask.setName("scheduleAtFixedRate2");
          timer.scheduleAtFixedRate(myTimerTask,3000, 2000);
    }
    }
    

    三.其他重要函数

    TimerTask的cancel(),scheduledExecutionTime()

    cancel()

    作用:取消当前TimerTask里的任务

    代码示例
    修改MyTimerTask类,使程序执行三次后,结束任务。上面的MyTimer保持不变,依旧让其运行

    myTimerTask.setName("scheduleAtFixedRate2");
    timer.scheduleAtFixedRate(myTimerTask,3000, 2000);

    MyTimerTask类修改如下:

    package com.vishuo.timer;
    
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.TimerTask;
    
    public class MyTimerTask extends TimerTask{
        private String name;
        private Integer count = 0;
        public MyTimerTask(String inputName){
            name=inputName;
        }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            if(count < 3){
                //以yyyy-MM-dd HH:mm:ss的格式打印当前执行时间
                //如2016-11-11 00:00:00
                Calendar calendar = Calendar.getInstance();
                SimpleDateFormat sf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                System.out.println("Curren exec time is:"+sf.format(calendar.getTime()));
                //打印当前name的内容
                System.out.println("Current exec name is:"+name);
                count ++;
            }else{
                cancel();
                System.out.println("Task cancel!");
            }
        }
        /**
         * @return the name
         */
        public String getName() {
            return name;
        }
        /**
         * @param name the name to set
         */
        public void setName(String name) {
            this.name = name;
        }
    
    }
    

    scheduledExecutionTime()

    作用:返回次任务最近实际执行的已安排执行的时间
    返回值:最近发生此任务执行安排的时间,为long型

    package com.vishuo.timer;
    
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Timer;
    
    public class MyTimer {
      public static void main(String[] args) {
    //  1.创建一个timer实例
          Timer timer = new Timer();
    //  2.创建一个MyTimerTask实例
          MyTimerTask myTimerTask = new MyTimerTask("No.1");
    //  3.通过timer定时定频率调用myTimerTask的业务逻辑
          //即第一次执行是在当前时间的两秒之后,之后每隔一秒钟执行一次
    //    timer.schedule(myTimerTask, 2000L,1000L);
    
          /*
           * 获取当前时间,并设置成距离当前时间三秒之后的时间
           * 如当前时间是2016-11-10 23:59:57
           * 则设置后的时间则为2016-11-11 00:00:00
           */
          Calendar calendar = Calendar.getInstance();
          SimpleDateFormat sf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
          System.out.println(sf.format(calendar.getTime()));//获取当前时间
          calendar.add(Calendar.SECOND, 3);//获取当前时间后三秒的时间
    
          /*
           * scheduledExecutionTime代码示例
           */
          myTimerTask.setName("schedule4");
          timer.schedule(myTimerTask, 3000);
          System.out.println("scheduled time is"+ sf.format(myTimerTask.scheduledExecutionTime()));
    }
    }
    

    Timer的cancel(),purge()

    cancel()

    作用:终止此计时器,丢弃所有当前已安排的任务

    代码示例:

    这里写图片描述

    新增CancelTest类

    package com.vishuo.timer;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Timer;
    
    public class CancelTest {
        public static void main(String[] args) throws InterruptedException {
            // 创建Timer实例
            Timer timer = new Timer();
            // 创建TimerTask实例
            MyTimerTask task1 = new MyTimerTask("task1");
            MyTimerTask task2 = new MyTimerTask("task2");
            //获取当前的执行时间并打印
            Date startTime = new Date();
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println("start time is:"+sf.format(startTime));
            //task1首次执行是距离现在时间3秒后执行,之后每隔2秒执行一次;
            //task2首次执行是距离现在时间1秒后执行,之后每隔2秒执行一次;
            timer.schedule(task1, 3000,2000);
            timer.schedule(task2, 1000,2000);
            //休眠5秒
            Thread.sleep(5000);
            //获取当前的执行时间并打印
            Date cancelTime = new Date();
            System.out.println("cancel time is :"+sf.format(cancelTime));
    
            //取消所有任务
            timer.cancel();
            System.out.println("Tasks all canceled!");
        }
    }
    

    purge()

    作用:从此计时器的任务队列中移除所有已取消的任务
    返回值:从队列中移除的任务数

    演示代码:修改CancelTest类

    package com.vishuo.timer;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Timer;
    
    public class CancelTest {
        public static void main(String[] args) throws InterruptedException {
            // 创建Timer实例
            Timer timer = new Timer();
            // 创建TimerTask实例
            MyTimerTask task1 = new MyTimerTask("task1");
            MyTimerTask task2 = new MyTimerTask("task2");
            // 获取当前的执行时间并打印
            Date startTime = new Date();
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println("start time is:" + sf.format(startTime));
            // task1首次执行是距离现在时间3秒后执行,之后每隔2秒执行一次;
            // task2首次执行是距离现在时间1秒后执行,之后每隔2秒执行一次;
            timer.schedule(task1, 3000, 2000);
            timer.schedule(task2, 1000, 2000);
            System.out.println("current canceled task number is:"+timer.purge());
            // 休眠5秒
    //      Thread.sleep(5000);
            //休眠2秒
            Thread.sleep(2000);
            // 获取当前的执行时间并打印
            Date cancelTime = new Date();
            System.out.println("cancel time is :" + sf.format(cancelTime));
    
            // 取消所有任务
            // timer.cancel();
            // System.out.println("Tasks all canceled!");
    
            //取消task2
            task2.cancel();
            System.out.println("current canceled task number is:"+timer.purge());
        }
    }
    

    四.schedule和scheduleAtFixedRate的区别

    两种情况看区别
    1.首次计划执行的时间早于当前的时间
    schedule方法:“fixed-delay”;如果第一次执行时间被delay了,随后的执行时间按照上一次实际执行完成的时间点进行计算。

    示例代码:

    新建DifferenceTest类

    package com.vishuo.timer;
    
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class DifferenceTest {
        public static void main(String[] args) {
            // 规定时间格式
            final SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            // 获取当前的具体时间
            Calendar calendar = Calendar.getInstance();
            System.out.println("Current time is :" + sf.format(calendar.getTime()));
            // 设置成6秒前的时间,若当前时间为2016-12-28 00:00:06
            // 那么设置之后时间变成2016-12-28 00:00:00
            calendar.add(Calendar.SECOND, -6);
            Timer timer = new Timer();
            // 第一次执行时间为6秒前,之后每隔两秒钟执行一次
            timer.schedule(new TimerTask() {
    
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    // 打印当前的计划执行时间
                    System.out.println("Scheduled exec time is :" + sf.format(scheduledExecutionTime()));
                    System.out.println("Task is being executed!");
                }
            }, calendar.getTime(), 2000);
        }
    }
    

    scheduleAtFiexedRate方法
    “fixed-rate”:如果第一次执行时间被delay了,随后的执行时间按照上一次开始的时间点进行计算,并且为了赶上进度会多次执行任务,因此TimerTask中的执行体需要考虑同步

    代码示例:

    修改DifferenceTest类

    // 第一次执行时间为6秒前,之后每隔两秒钟执行一次
            timer.scheduleAtFixedRate(new TimerTask() {
    
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    // 打印当前的计划执行时间
                    System.out.println("Scheduled exec time is :" + sf.format(scheduledExecutionTime()));
                    System.out.println("Task is being executed!");
                }
            }, calendar.getTime(), 2000);

    2.任务执行所需时间超出任务的执行周期间隔

    schedule方法
    下一次执行时间相对于上一次实际执行完成的时间点,因此执行时间会不断延后
    代码示例:
    修改DifferenceTest类

    package com.vishuo.timer;
    
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class DifferenceTest {
        public static void main(String[] args) {
            // 规定时间格式
            final SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            // 获取当前的具体时间
            Calendar calendar = Calendar.getInstance();
            System.out.println("Current time is :" + sf.format(calendar.getTime()));
            // 设置成6秒前的时间,若当前时间为2016-12-28 00:00:06
            // 那么设置之后时间变成2016-12-28 00:00:00
    //      calendar.add(Calendar.SECOND, -6);
            Timer timer = new Timer();
    
            timer.schedule(new TimerTask() {
    
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // TODO Auto-generated method stub
                    // 打印当前的计划执行时间
                    System.out.println("Scheduled exec time is :" + sf.format(scheduledExecutionTime()));
                    System.out.println("Task is being executed!");
                }
            }, calendar.getTime(), 2000);
        }
    }
    

    scheduleAtFixedRate方法
    下一次执行时间相对于上一次开始的时间点,因此执行时间一般不会延后,因此存在并发性
    代码示例:修改DifferenceTest类

    timer.scheduleAtFixedRate(new TimerTask() {
    
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // TODO Auto-generated method stub
                    // 打印当前的计划执行时间
                    System.out.println("Scheduled exec time is :" + sf.format(scheduledExecutionTime()));
                    System.out.println("Task is being executed!");
                }
            }, calendar.getTime(), 2000);
    展开全文
  • Java 定时器 Timer定时任务 TimeTask

    千次阅读 2018-06-23 17:57:08
    目录 Timer 概述 TimerTask 概述 编码示例 鼠标自动单击桌面 Timer 概述 ...1、java.util.Timer 是一个工具类计时器,线程用其安排以后在后台线程...3、Timer 计时器任务应该迅速完成,如果完成某个计时器任务的时...
  • 基本信息1.Timer是一种定时器工具,用来在一个后台线程计划执行指定任务。它可以计划执行一个任务一次或反复多次。 2.TimerTask一个抽象类,它的子类代表一个可以被Timer计划的任务。 3.Timer.schedule的意思是时
  • Timer定时任务调度Api及优缺点

    千次阅读 2018-01-03 11:00:59
    Timer是java.util自带的类,该类可以完成定时任务调度功能,但是只有一个后台线程,所以不支持并发,而且当遇到运行时错误的时候会停止所有正在执行的任务。Quartz可以说是大哥,改善了这两大缺陷。Timer Api接口...
  • 我用timer写了一个定时任务能停止和重新启动的,使用@Autowired来注入CusTask timer使用end方法销毁后重启不了,但是如果去掉@Autowired注入 改成new CusTask();就可以实现停止与重新启动了,但是new CusTask();里面的@...
  • Timer任务定时器如何终止

    千次阅读 2019-10-15 19:42:30
    在计时器结束后,我们需要通过public void cancel()来取消这个线程,不然它会一直挂起。如果需要在外面终止计时器,也可以schedule()方法外面调用这个方法。
  • 使用 Java 来调度定时任务时,我们经常会使用 Timer 类搞定。Timer 简单易用,其源码阅读起来也非常清晰,本节我们来仔细分析一下 Timer 类,来看看 JD...
  • 转自----------------------- Page 1... 深入 Java Timer 定时任务调度器实现原理   原创:老钱 码洞 前天   使用 Java 来调度定时任务时,我们经常会使用 Timer 类搞定。Timer 简单易用,其源   ...
  • java Timer定时任务调度原理记综述类关系图总体时序图模块详解TimerTimerThreadTaskQueue总结 记 最近看了一下java定时调度Timer的源码,源码简单、清晰,结构清除,对于了解任务调度入门有帮助,因此在此对源码阅读...
  • Java定时任务 - Timer 原理 概要 Jdk库自带有两种实现定时任务的技术。一种是通过Timer,另外一个是通过ScheduledThreadPoolExecutor。下面为大家分析Timer实现的原理。 一、Timer 1、Timer使用 public class ...
  • *************************... Timer有且仅有一个线程去执行定时任务,如果存在多个任务,且任务时间过长,会导致执行效果与预期不符 2、当任务抛出异常时的缺陷  如果TimerTask抛出RuntimeException,Timer会停...
  • Java定时任务(一) Timer及TimerTask的案例解析及源码分析 一、概述: 定时任务这个概念在Java的学习以及项目的开发中并不陌生,应用场景也是多种多样。比如我们会注意到12306网站在锁定车票的30分钟以内要进行...
  • Java定时任务Timer和Quartz

    千次阅读 2018-09-12 10:13:23
    定时任务调度 ... 基于给定的时间点,给定的时间间隔或者给定的执行次数自动执行的任务 ... Timer能完成一些简单的定时任务,能实现具体某个时间执行任务。只有一个后台执行定时任务。 Quartz能实现更复杂...
  • java Timer 定时任务

    2017-06-11 18:22:11
    schedule的四种用法 schedule(task,time) ...time 首次执行任务的时间 period 执行一次task的时间间隔 schedule(task,delay) 等待delay毫秒之后,执行并且执行一次task scheduleAtFixedRate
  • 虽然一个Timer可以运行多个定时任务,但是一个Timer是串行运行 Timer的使用禁区:1、对时效性要求比较较高的多任务并发作业 2、对复杂任务的调度 Timer的缺陷:1、管理并发的缺陷以及任务之间的协同缺陷(因为...
  • 利用Timer写一个最简单的定时任务

    千次阅读 2018-03-01 14:17:17
    首先创建一个MyTimerTask类,让他继承...而这一整个类就是作为定时任务中的任务。package com.csyd.timer; import java.util.TimerTask; /** * Created by ChengShanyunduo * 2018/3/1 */ public class ...
  • 是什么是定时任务调度? 基于给定的时间点、给定的时间间隔或者给定的执行次数自动执行任务。 Timer 由JDK自带提供! Timer的定义 有且仅有一个后台线程对多个业务线程进行定时定频率的调度 Timer定时调度任务的...
  • java.util.TimerTask:表示一个定时任务 基本使用: TimerTask task1=new TimerTask() { @Override public void run() { String name = Thread.currentThread().getName(); System.out.println("[当前线程是:"+...
  • 最近做了下异步定时异常补偿任务,对定时任务用法做以下总结及比较,详细见注释。 import java.util.Timer; import java.util.TimerTask; import java.util.concurrent.ExecutorService; import java.util....
  • 定时任务就是在指定时间执行程序,或周期性执行计划任务。Java中实现定时任务的方法有很多,本文从从JDK自带的一些方法来实现定时任务的需求。 Timer和TimerTask 本文先介绍Java最原始的解决方案:Timer和TimerTask ...
  • //登陆操作时显示等待加载框...final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1); executorService.scheduleAtFixedRate(new Runnable() { @Override public void ru...
  • 使用Timer实现定时启动 并定时停止

    千次阅读 2018-08-03 10:13:33
    timer取消任务方法 只会对未运行的任务取消 不会影响到正在运行的任务,而我们需要的是将正在运行的timer线程停止 故在运行方法时声明变量 重写取消任务方法 对变量 变化 ,运行方法判断到变量 变化 停止。...
  • //取消当前任务 } } public class TestSchedule { public static void main(String[] args){ Timer timer = new Timer(); timer.schedule(new MyTimerTask("sth"),2000,1000); //TimerTask....
  • Timer定时任务

    2015-10-16 16:48:37
    当程序初始化完成Timer后,定时任务就会按照我们设定的时间去执行,Timer提供了schedule方法,该方法有多中重载方式来适应不同的情况,如下: schedule(TimerTask task, Date time):安排在指定的时间执行指定...
  • 一、任务精确性 通过前两节的分析,大概知道了Timer的运行原理,下面说说使用Timer需要注意的一些事项。下面是Timer简单原理图 从上图可以看到,真正运行闹钟的是一个单线程。也就是说队列中的闹钟,只能依次...
  • 详解java定时任务Timer

    2018-06-13 10:42:45
    在我们编程过程中如果需要执行一些简单的定时任务,无须做复杂的控制,我们可以考虑使用JDK中的Timer定时任务来实现。下面LZ就其原理、实例以及Timer缺陷三个方面来解析java Timer定时器。一、简介 在java中一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,846
精华内容 3,938
关键字:

timer取消定时任务