精华内容
下载资源
问答
  • 3种定时器: 1. 设置指定任务在多少毫秒之后执行 2. 设置指定任务在多少毫秒之后,以多少毫秒为一周期持续执行 3. 设置指定任务在今天或明天几点开始执行,并且以多少毫秒为一周期持续执行 1. 设置指定任务在多少...

    3种定时器:
    1. 设置指定任务在多少毫秒之后执行
    2. 设置指定任务在多少毫秒之后,以多少毫秒为一周期持续执行
    3. 设置指定任务在今天或明天几点开始执行,并且以多少毫秒为一周期持续执行

    1. 设置指定任务在多少毫秒之后执行
    实现方法:

        private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
        public static void main(String[] args) {
            System.err.println(sdf.format(new Date()));
            timer1();
        }
        
        public static void timer1() {
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                public void run() {
                    System.out.println("-------设定要指定任务-timer1--------" + sdf.format(new Date()));
                }
            }, 5000);	// 5000为延时多少毫秒执行,delay
        }
    

    效果图:
    在这里插入图片描述
    2. 设置指定任务在多少毫秒之后,以多少毫秒为一周期持续执行
    方法一:使用Timer.schedule()

        public static void timer2(){
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("-------设定要指定任务-timer2--------" + sdf.format(new Date()));
                }
            },3000,5000); // 3000为延时多少毫秒delay,5000为多少毫秒为一周期period
        }
    

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

    方法二:使用Timer.scheduleAtFixedRate()
    实现方法:

        public static void timer3(){
            Timer timer = new Timer();
            timer.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("-------设定要指定任务-timer3--------" + sdf.format(new Date()));
                }
            },3000,5000);
        }
    

    效果:
    在这里插入图片描述
    3. 设置指定任务在今天或明天几点开始执行,并且以多少毫秒为一周期持续执行
    实现方法:
    定时今天15:48:00开始执行任务、然后以1000毫秒为周期执行

        public static void timer4(){
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.HOUR_OF_DAY, 15);     //时
            calendar.set(Calendar.MINUTE,48);   //分
            calendar.set(Calendar.SECOND,0);    //秒
            Date time = calendar.getTime(); //得出执行任务的时间,此处为今天的12:00:00
            Timer timer = new Timer();
            timer.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("-------设定要指定任务-timer4--------" + sdf.format(new Date()));
                }
            },time, 1000);   //这里设定将延时每天固定执行
        }
    

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

    定时器工具类
    各类定时器方法,及定时器终止方法
    有多个定时器,终止指定定时器实现方法如下stopTimer()方法

    package com.gaohan.util;
    
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.core.Logger;
    
    import java.text.ParseException;
    import java.util.*;
    
    /**
     * @author gaohan
     * @version 1.0
     * @date 2020/5/8 22:59
     */
    public class TimerUtils {
        private static Logger logger = (Logger) LogManager.getLogger(TimerUtils.class);
    
        private Timer timer = new Timer();
    
        public static Map<String, TimerTask> map = new HashMap<>();    //用来存储所有定时器
    
        /**
         * 延时执行定时任务
         * @param uuid  定时任务id
         * @param delay 延时时间(毫秒)
         */
        public void startTimerDelay(String uuid, long delay) throws Exception {
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    logger.info("-------设定要指定任务--------");
                }
            };
            timer.schedule(task, delay);
    //        TimerController.map.put(uuid, task);
        }
    
        /**
         * 延时并按周期循环执行定时任务
         * @param uuid  定时任务id
         * @param delay 延时时间(毫秒)
         * @param period  循环间隔时间(毫秒)
         * @param str   打印信息
         * @throws InterruptedException
         * @throws ParseException
         */
        public void startTimerDelayPeriod(final String uuid, long delay, long period, final String str) throws InterruptedException, ParseException {
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    logger.info("====>  " + uuid + str);
                }
            };
            timer.scheduleAtFixedRate(task, delay, period);
            map.put(uuid, task);
        }
    
        /**
         * 设置指定任务TimerTask在今天指定时间开始执行,并且以固定的period毫秒为周期执行
         * @param uuid  定时任务id
         * @param period 周期(毫秒)
         * @param hour      几点
         * @param minute    几分
         * @param second    几秒
         */
        public void startTimerDelayPeriodByTime(String uuid, long period, int hour, int minute, int second){
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.HOUR_OF_DAY, hour);     //时
            calendar.set(Calendar.MINUTE, minute);   //分
            calendar.set(Calendar.SECOND, second);    //秒
            Date time = calendar.getTime(); //得出执行任务的时间,此处为今天的12:00:00
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    System.out.println("-------设定要指定任务--------");
                }
            };
            timer.scheduleAtFixedRate(task, time, period);   //这里设定将延时每天固定执行
            map.put(uuid, task);
        }
    
        /**
         * 停止定时任务
         * @param uuid  定时任务id
         */
        public void stopTimer(String uuid) {
            TimerTask task = map.get(uuid);
            if (task != null) {
                task.cancel();
                logger.info("====>  结束定时任务[" + uuid + "]");
                map.remove(uuid);
            }
        }
    }
    
    
    展开全文
  • 本博文只是简单介绍一下Timer的使用方法。适用于初学者进行参考,希望大家多多指点。废话不多说,直接上正题。 1、了解一下Timer类提供的方法 介绍几个常用的方法: cancel()终止此计时器,丢弃所有当前已安排的...

    本博文只是简单介绍一下Timer的使用方法。适用于初学者进行参考,希望大家多多指点。废话不多说,直接上正题。

    1、了解一下Timer类提供的方法

    介绍几个常用的方法:

    cancel() 终止此计时器,丢弃所有当前已安排的任务。

    schedule(TimerTask task, long delay, long period) 安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。

    schedule(TimerTask task, long delay) 安排在指定延迟后执行指定的任务。(这个只执行一次,延时执行后,不再执行)

    scheduleAtFixedRate(TimerTask task, long delay, long period) 安排指定的任务在指定的延迟后开始进行重复的固定速率执行

    2、Timer示例

    本示例使用的是jdk1.6.

    首先我编写了一个定时任务的工具类,提供了开始定时任务和取消定时任务。

    package com.bao.timerUtil;
    
    import java.util.Timer;
    import java.util.TimerTask;
    
    /**
     * 定时任务工具类
     * @author lanJ
     *
     */
    public class TimerUtil {
    	//定时执行时间
    	private static long TIME = 1000*6;
    	private Timer timer = null; //定时类
    
    	/**
    	 * 启动定时任务
    	 * @param timerTask
    	 */
    	public void startTimer(TimerTask timerTask) {
    		if(timer == null) {
    			timer = new Timer();
    		}
    		timer.schedule(timerTask, TIME, TIME);
    	}
    	
    	/**
    	 * 延时20秒启动定时任务
    	 * @param timerTask
    	 */
    	public void startAtFixedTimer(TimerTask timerTask) {
    		if(timer == null) {
    			timer = new Timer();
    		}
    		timer.scheduleAtFixedRate(timerTask,1000*20,TIME);
    	}
    	
    	/**
    	 * 停止定时任务
    	 */
    	public void stopTimer() {
    		timer.cancel();
    	}
    }
    

     然后,编写一个自己的任务类。

    package com.bao.timerTask;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.TimerTask;
    
    /**
     * 我的任务 说明:定时任务需要集成java.util.TimerTask类,并且重写run方法. 把你想要在定时任务中所做的事写在run方法中.
     * @author lanJ
     * 
     */
    public class MyTask extends TimerTask {
    	
    	private String name;
    
    	public MyTask(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public void run() {
    		System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " Hello," + this.name);
    	}
    
    }
    

     最后,有个测试类。

    package com.bao.main;
    
    import com.bao.timerTask.MyTask;
    import com.bao.timerUtil.TimerUtil;
    
    public class TestMain {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		TimerUtil timerUtil = new TimerUtil();
    		timerUtil.startTimer(new MyTask("lanJ"));
    		timerUtil.startAtFixedTimer(new MyTask("bao"));
    	}
    }
    

     运行结果:

    2012-09-10 10:01:24 Hello,lanJ
    2012-09-10 10:01:30 Hello,lanJ
    2012-09-10 10:01:36 Hello,lanJ
    2012-09-10 10:01:38 Hello,bao
    2012-09-10 10:01:42 Hello,lanJ
    2012-09-10 10:01:44 Hello,bao
    2012-09-10 10:01:48 Hello,lanJ
    2012-09-10 10:01:50 Hello,bao
    2012-09-10 10:01:54 Hello,lanJ
     2012-09-10 10:01:56 Hello,bao

    通过结果可以看出bao这个定时任务是延时了20秒才执行的。

    展开全文
  • java自带的Timer定时器

    2018-06-06 15:29:28
    记录学习历程,仅供学习交流用,转载标注!... Timer: 一种定时器工具,用来在一个后台线程计划执行指定任务. TimerTask:一个抽象类,它的子类代表一个可以被Timer计划的任务。1.基础API中是这样定义他们...

    记录学习历程,仅供学习交流用,转载标注!

    Java自带了简单的定时任务功能,通过借助Timer和TimeTask可以时间简单的任务调度功能。

      在java中一个完整定时任务需要由Timer、TimerTask两个类来配合完成。
    Timer: 一种定时器工具,用来在一个后台线程计划执行指定任务.

    TimerTask:一个抽象类,它的子类代表一个可以被Timer计划的任务。

    1.基础

    API中是这样定义他们的,Timer:一种工具,线程用其安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行。由TimerTask:Timer 安排为一次执行或重复执行的任务。

    我们可以这样理解Timer是一种定时器工具,用来在一个后台线程计划执行指定任务,而TimerTask一个抽象类,它的子类代表一个可以被Timer计划的任务。

    Timer的特性

        1、它属于单线程的,每创建个Timer实例,就会创建一个新线程
        2、Timer默认情况下不是守护线程,可以设置为守护线程new Timer(true),守护线程再进程中没有其他线程时,守护线程将销毁
        3、TimerTask是以队列的方式一个个的执行
        4、TimerTask中的cancel()方法将自身中从队列中清除
        5、Timer中的cancel()方法是将任务队列中的全部任务进行取消,有时并不一定停止任务,原因是Timer类中的cancel()方法有时并没有竞争到锁,
        (这个可以从Timer源码中看到,TimerThread和TaskQueue两个内部类)
        6、TimerTask中的run方法无法抛出,所以要进行try catch捕获,如果其中任何一个任务发生异常没有被捕获,则其他任务也将被终止
    方法详解:
    (1)schedule(TimerTask task, Date executeTime)
    当executeTime<=currentTime时,task任务会在currentTimer立即执行
    当executeTime>currentTime时,task会在未来的executeTime执行
    (2)schedule(TimerTask task, Date firstTime, long period)
    当firstTime <=currentTime时,task任务会在currentTimer立即执行,
    当firstTime >currentTime时,task会在未来的executeTime执行,
    执行任务所用的时间taskUsedTime<peroid,则下一个任务执行的时间是上次任务执行完成的时间+peroid,任务按时间间隔peroid周期性执行任务
    执行任务所用的时间taskUsedTime>peroid,则下一个任务执行的时间是上次任务执行完成的时间+taskUsedTime,任务按时间间隔taskUsedTime 周期性执行任务
    (3)schedule(TimerTask task, long delay)
    任务延迟delay毫秒进行执行
    (4)schedule(TimerTask task, long delay, long period)
    A、延迟delay毫秒第一次执行,
    B、执行任务所用的时间taskUsedTime<peroid,则下一个任务执行的时间是上次任务执行完成的时间+peroid, 任务按时间间隔peroid周期性执行任务
    C、执行任务所用的时间taskUsedTime>peroid,则下一个任务执行的时间是上次任务执行完成的时间+taskUsedTime, 任务按时间间隔taskUsedTime 周期性执行任务
    (5)scheduleAtFixedRate(TimerTask task, long delay, long period)
    (6)scheduleAtFixedRate(TimerTask task, Date firstTime,  long period)
             startTime = currentTime
    A、当firstTime>currentTime,任务则在currentTime执行
    B、当firstTime<currentTime,任务会发生追赶执行,追赶执行的次数expectCount=(currentTime-firstTime)/peroid+1;
      第一个peroid属于追赶阶段,如果追赶上则等待执行startTime+peroid时间任务,如果没有追赶上则直接执行startTime+peroid时间的任务

    Timer类
    当程序初始化完成Timer后,定时任务就会按照我们设定的时间去执行,Timer提供了schedule方法,该方法有多中重载方式来适应不同的情况,
    如下:

    schedule(TimerTask task, Date time):安排在指定的时间执行指定的任务。

    schedule(TimerTask task, Date firstTime, long period) :安排指定的任务在指定的时间开始进行重复的固定延迟执行。

    schedule(TimerTask task, long delay) :安排在指定延迟后执行指定的任务。

    schedule(TimerTask task, long delay, long period) :安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。

    同时也重载了scheduleAtFixedRate方法,scheduleAtFixedRate方法与schedule相同,只不过他们的侧重点不同,区别后面分析。

    scheduleAtFixedRate(TimerTask task, Date firstTime, long period):安排指定的任务在指定的时间开始进行重复的固定速率执行。

    scheduleAtFixedRate(TimerTask task, long delay, long period):安排指定的任务在指定的延迟后开始进行重复的固定速率执行。

    TimerTask

    TimerTask类是一个抽象类,由Timer 安排为一次执行或重复执行的任务。它有一个抽象方法run()方法,该方法用于执行相应计时器任务要执行的操作。因此每一个具体的任务类都必须继承TimerTask,然后重写run()方法。

    另外它还有两个非抽象的方法:

        boolean cancel():取消此计时器任务。

        long scheduledExecutionTime():返回此任务最近实际执行的安排执行时间。


    2.实例

    2.1、指定延迟时间执行定时任务

    public class TimerTest03 {
        Timer timer;

        public TimerTest03() {
    timer = new Timer();
    timer.schedule(new TimerTaskTest03(), 1000, 2000);
        }
        public static void main(String[] args) {
    new TimerTest03();
        }
    }

    public class TimerTaskTest03 extends TimerTask {
        @Override
        public void run() {
    Date date = new Date(this.scheduledExecutionTime());
    System.out.println("本次执行该线程的时间为:" + date);
        }
    }
    运行结果:

    首先打印:timer begin....3秒后打印:Time's up!!!!

    2.2、在指定时间执行定时任务

    public class TimerTest02 {
        Timer timer;
        public TimerTest02() {
    Date time = getTime();
    System.out.println("指定时间time=" + time);
    timer = new Timer();
    timer.schedule(new TimerTaskTest02(), time);
        }
        public Date getTime() {
    Calendar calendar = Calendar.getInstance();
    calendar.set(Calendar.HOUR_OF_DAY, 11);
    calendar.set(Calendar.MINUTE, 39);
    calendar.set(Calendar.SECOND, 00);
    Date time = calendar.getTime();
    return time;
        }
        public static void main(String[] args) {
    new TimerTest02();
        }
    }
    public class TimerTaskTest02 extends TimerTask {
        @Override
        public void run() {
    System.out.println("指定时间执行线程任务...");
        }

    }

    当时间到达11:39:00时就会执行该线程任务,当然大于该时间也会执行!!执行结果为:
    指定时间time=Tue Jun 10 11:39:00 CST 2014指定时间执行线程任务...

    2.3、在延迟指定时间后以指定的间隔时间循环执行定时任务

    public class TimerTest03 {
        Timer timer;
        public TimerTest03() {
    timer = new Timer();
    timer.schedule(new TimerTaskTest03(), 1000, 2000);
        }
        public static void main(String[] args) {
    new TimerTest03();
        }
    }
    public class TimerTaskTest03 extends TimerTask {
        @Override
        public void run() {
    Date date = new Date(this.scheduledExecutionTime());
    System.out.println("本次执行该线程的时间为:" + date);
        }

    }

    运行结果:
    本次执行该线程的时间为:Tue Jun 10 21:19:47 CST 2014本次执行该线程的时间为:Tue Jun 10 21:19:49 CST 2014本次执行该线程的时间为:Tue Jun 10 21:19:51 CST 2014本次执行该线程的时间为:Tue Jun 10 21:19:53 CST 2014本次执行该线程的时间为:Tue Jun 10 21:19:55 CST 2014本次执行该线程的时间为:Tue Jun 10 21:19:57 CST 2014.................

    对于这个线程任务,如果我们不将该任务停止,他会一直运行下去。


    对于上面三个实例,LZ只是简单的演示了一下,同时也没有讲解scheduleAtFixedRate方法的例子,其实该方法与schedule方法一样!

    2.4、分析schedule和scheduleAtFixedRate

        1、schedule(TimerTask task, Date time)、schedule(TimerTask task, long delay)
    对于这两个方法而言,如果指定的计划执行时间scheduledExecutionTime<= systemCurrentTime,则task会被立即执行。scheduledExecutionTime不会因为某一个task的过度执行而改变。
        2、schedule(TimerTask task, Date firstTime, long period)、schedule(TimerTask task, long delay, long period)
    这两个方法与上面两个就有点儿不同的,前面提过Timer的计时器任务会因为前一个任务执行时间较长而延时。在这两个方法中,每一次执行的task的计划时间会随着前一个task的实际时间而发生改变,也就是scheduledExecutionTime(n+1)=realExecutionTime(n)+periodTime。也就是说如果第n个task由于某种情况导致这次的执行时间过程,最后导致systemCurrentTime>= scheduledExecutionTime(n+1),这是第n+1个task并不会因为到时了而执行,他会等待第n个task执行完之后再执行,那么这样势必会导致n+2个的执行实现scheduledExecutionTime放生改变即scheduledExecutionTime(n+2) = realExecutionTime(n+1)+periodTime。所以这两个方法更加注重保存间隔时间的稳定。
        3、scheduleAtFixedRate(TimerTask task, Date firstTime, long period)、scheduleAtFixedRate(TimerTask task, long delay, long period)
    在前面也提过scheduleAtFixedRate与schedule方法的侧重点不同,schedule方法侧重保存间隔时间的稳定,而scheduleAtFixedRate方法更加侧重于保持执行频率的稳定。为什么这么说,原因如下。在schedule方法中会因为前一个任务的延迟而导致其后面的定时任务延时,而scheduleAtFixedRate方法则不会,如果第n个task执行时间过长导致systemCurrentTime>= scheduledExecutionTime(n+1),则不会做任何等待他会立即执行第n+1个task,所以scheduleAtFixedRate方法执行时间的计算方法不同于schedule,而是scheduledExecutionTime(n)=firstExecuteTime +n*periodTime,该计算方法永远保持不变。所以scheduleAtFixedRate更加侧重于保持执行频率的稳定。

    三、Timer的缺陷

    3.1、Timer的缺陷

        Timer计时器可以定时(指定时间执行任务)、延迟(延迟5秒执行任务)、周期性地执行任务(每隔个1秒执行任务),但是,Timer存在一些缺陷。首先Timer对调度的支持是基于绝对时间的,而不是相对时间,所以它对系统时间的改变非常敏感。其次Timer线程是不会捕获异常的,如果TimerTask抛出的了未检查异常则会导致Timer线程终止,同时Timer也不会重新恢复线程的执行,他会错误的认为整个Timer线程都会取消。同时,已经被安排单尚未执行的TimerTask也不会再执行了,新的任务也不能被调度。故如果TimerTask抛出未检查的异常,Timer将会产生无法预料的行为。

    1、Timer管理时间延迟缺陷
        前面Timer在执行定时任务时只会创建一个线程任务,如果存在多个线程,若其中某个线程因为某种原因而导致线程任务执行时间过长,超过了两个任务的间隔时间,会发生一些缺陷:

    public class TimerTest04 {
        private Timer timer;
        public long start;
        public TimerTest04(){
    this.timer = new Timer();
    start = System.currentTimeMillis();
        }        
        public void timerOne(){
    timer.schedule(new TimerTask() {
       public void run() {
    System.out.println("timerOne invoked ,the time:" + (System.currentTimeMillis() - start));
    try {
       Thread.sleep(4000);    //线程休眠3000               
    } catch (InterruptedException e) {
       e.printStackTrace();
       }
    }
       }, 1000);
    }
        public void timerTwo(){
    timer.schedule(new TimerTask() {
       public void run() {
    System.out.println("timerOne invoked ,the time:" + (System.currentTimeMillis() - start));
    }
       }, 3000);
    }
        public static void main(String[] args) throws Exception {
    TimerTest04 test = new TimerTest04();
    test.timerOne();
    test.timerTwo();
        }
    }

    按照我们正常思路,timerTwo应该是在3s后执行,其结果应该是:
    timerOne invoked ,the time:1001timerOne invoked ,the time:3001

    但是事与愿违,timerOne由于sleep(4000),休眠了4S,同时Timer内部是一个线程,导致timeOne所需的时间超过了间隔时间,

    结果:

    timerOne invoked ,the time:1000timerOne invoked ,the time:5000

    2、Timer抛出异常缺陷

    如果TimerTask抛出RuntimeException,Timer会终止所有任务的运行。如下:

    public class TimerTest04 {
        private Timer timer;
        public TimerTest04() {
    this.timer = new Timer();
        }
        public void timerOne() {
    timer.schedule(new TimerTask() {
       public void run() {
    throw new RuntimeException();
       }
    }, 1000);
        }
        public void timerTwo() {
    timer.schedule(new TimerTask() {
       public void run() {
    System.out.println("我会不会执行呢??");
       }
    }, 1000);
        }
        public static void main(String[] args) {
    TimerTest04 test = new TimerTest04();
    test.timerOne();
    test.timerTwo();
        }
    }

    运行结果:timerOne抛出异常,导致timerTwo任务终止。

    Exception in thread "Timer-0" java.lang.RuntimeException    at com.chenssy.timer.TimerTest04$1.run(TimerTest04.java:25)    at java.util.TimerThread.mainLoop(Timer.java:555)    at java.util.TimerThread.run(Timer.java:505)
    对于Timer的缺陷,我们可以考虑 ScheduledThreadPoolExecutor 来替代。Timer是基于绝对时间的,对系统时间比较敏感,而ScheduledThreadPoolExecutor 则是基于相对时间;Timer是内部是单一线程,而ScheduledThreadPoolExecutor内部是个线程池,所以可以支持多个任务并发执行。


    3.2、用ScheduledExecutorService替代Timer

    1、解决问题一:

    public class ScheduledExecutorTest {
        private ScheduledExecutorService scheduExec;
        public long start;
        ScheduledExecutorTest() {
    this.scheduExec = Executors.newScheduledThreadPool(2);
    this.start = System.currentTimeMillis();
        }
        public void timerOne() {
    scheduExec.schedule(new Runnable() {
       public void run() {
    System.out.println("timerOne,the time:"
    + (System.currentTimeMillis() - start));
    try {
       Thread.sleep(4000);
    } catch (InterruptedException e) {
       e.printStackTrace();
    }
       }
    }, 1000, TimeUnit.MILLISECONDS);
        }
        public void timerTwo() {
    scheduExec.schedule(new Runnable() {
       public void run() {
    System.out.println("timerTwo,the time:"
    + (System.currentTimeMillis() - start));
       }
    }, 2000, TimeUnit.MILLISECONDS);
        }
        public static void main(String[] args) {
    ScheduledExecutorTest test = new ScheduledExecutorTest();
    test.timerOne();
    test.timerTwo();
        }
    }

    运行结果:

    timerOne,the time:1003timerTwo,the time:2005

    2、解决问题二
    public class ScheduledExecutorTest {
        private ScheduledExecutorService scheduExec;
        public long start;
        ScheduledExecutorTest() {
    this.scheduExec = Executors.newScheduledThreadPool(2);
    this.start = System.currentTimeMillis();
        }
        public void timerOne() {
    scheduExec.schedule(new Runnable() {
       public void run() {
    throw new RuntimeException();
       }
    }, 1000, TimeUnit.MILLISECONDS);
        }
        public void timerTwo() {
    scheduExec.scheduleAtFixedRate(new Runnable() {
       public void run() {
    System.out.println("timerTwo invoked .....");
       }
    }, 2000, 500, TimeUnit.MILLISECONDS);
        }
        public static void main(String[] args) {
    ScheduledExecutorTest test = new ScheduledExecutorTest();
    test.timerOne();
    test.timerTwo();
        }
    }


    运行结果:

    timerTwo invoked .....timerTwo invoked .....timerTwo invoked .....timerTwo invoked .....timerTwo invoked .....timerTwo invoked .....timerTwo invoked .....timerTwo invoked .....timerTwo invoked .............................


    参考博客:https://blog.csdn.net/jihaitaowangyi/article/details/52823270

    参考博客:http://blog.csdn.net/lmj623565791/article/details/27109467

    展开全文
  • java Timer定时器

    2012-06-04 10:25:31
    import java.util.Timer; import java.util.TimerTask; //定时器需要上面两个类、 //要定时执行的类需要继承TimerTask。注意在run方法中不要有while(true),也就是死循环,如果有死循环,定时将不起作用。 ...
    import java.util.Timer;
    import java.util.TimerTask;
    
    //定时器需要上面两个类、
    //要定时执行的类需要继承TimerTask。注意在run方法中不要有while(true),也就是死循环,如果有死循环,定时将不起作用。
    public class TestMain extends TimerTask
    {
    	public void run()
    	{
    System.out.ptintln("定时输出这句话");
    }
    }
    
    
    //定时器
    public class TimeTest{
     private static Timer timer = null;
    	  
    	  public static void main(String[] args) {
    		  timer = new Timer(true);
    		    //设置任务计划,第一个参数是要被定时执行的类;第二个是第一次启动是多少毫秒后和第三个参数是间隔多少毫秒执行一次
    		  timer.schedule(new TestMain(), 1000, 1200000);
        //下面这个是必填的,否则不会执行定时
    		  while(true){//这个是用来停止此任务的,否则就一直循环执行此任务了
    	          try {
    	              int ch = System.in.read();
    	              if(ch-'c'==0){
    	                  timer.cancel();//使用这个方法退出任务
    	                  
    	              }
    	          } catch (IOException e) {
    	              // TODO Auto-generated catch block
    	              e.printStackTrace();
    	          }
    	      }
    	}
    }

     

    展开全文
  • Timer类介绍 Timer类的主要作用是设置计划任务,即在指定时间开始执行某一个任务。...import java.util.TimerTask; public class MyTask extends TimerTask { @Override public void run() { System.ou
  • java--Timer 定时器

    2021-05-24 23:56:56
    https://blog.csdn.net/qq_34291570/article/details/94874074? ...https://blog.csdn.net/hl_java/article/details/79035237? https://blog.csdn.net/xixi_haha123/article/details/81082321? https://blog.csdn.ne
  • Java多线程中Timer定时器执行完任务为什么不停止? ``` public Timer(String name) { thread.setName(name); thread.start(); } ``` 这是Timer类中调用的构造方法,那我自己写一个简单的线程程序时,...
  • //结束Timer定时器任务 //按理说这里应该只做响铃操作,而不是停止闹钟的时间走动,当然这只是为了模拟,也可以注释掉t.cancel(); } private void working() {//工作中 Timer t = new Timer();//创建Timer...
  • Timer定时器

    2021-09-08 20:28:20
    Timer定时器 源码: public class Timer { private final TaskQueue queue = new TaskQueue();//定时器队列 private final TimerThread thread = new TimerThread(queue);//定时器线程 首先看看TaskQueue 和 ...
  • java定时器Timer详解

    千次阅读 2019-08-27 16:19:31
    java定时器Timer 简单使用
  • java定时器timer停止

    千次阅读 2019-08-11 15:42:09
    java定时器停止可以使用timer类的cancel方法,代码如下: finalTimertimer=newTimer(); TimerTasktask=newTimerTask(){ privateintcount; @Override publicvoid...
  • java Timer实现定时器

    2012-05-14 16:16:08
    * 文件名:MyTask.java */ import java.util.Date; import java.util.TimerTask; public class MyTask extends TimerTask { @Override public void run() { System.out.println("call at &...
  • 定时器相信大家都不陌生,平时使用定时器就像使用闹钟一样,我们可以在固定的时间做某件事,也可以在固定的时间段重复做某件事,今天就来分析一下java中自带的定时任务器Timer。一、Timer基本使用在Java中为我们提供...
  • Timer定时器用法详解

    万次阅读 多人点赞 2019-07-06 17:30:20
    先看API和结论: /** timer总结: Timer timer = new Timer(); //其中会调用this(..., 即它以Timer+序列号为该定时器的名字 Timer timer = new Timer(String name); //以name作为该定时器的名字 Timer time...
  • Timer定时器详解

    万次阅读 2016-10-15 15:00:17
    Timer定时器详解
  • 项目中有一个扫描的功能,分即时任务、定时任务、周期任务三种,即时任务已经实现了,现在使用java.util.Timerjava.util.TimerTask类做定时任务,重写TimerTask的run方法,在run方法中调用之前已经没有问题的即时...
  • java之认识定时器Timer

    2017-10-31 21:57:48
    java定时器timer:基于给定的时间点、给点的时间间隔或者给定的执行次数自动执行的任务
  • Timer 定时器java

    2014-04-08 09:36:25
    并非所有的源对象都是GUI组件,定时器Timer
  • 首先来看看此类在JavaSE文档中对Timer类的8点解释: 1.线程的工具,用于在后台线程中安排将来执行的任务。可以将任务安排为一次性执行,或者以固定间隔重复执行。 2.对应于每个Timer对象的是一个...
  • 场景: java timer定时器  定时1分钟时间间隔,定时执行的任务中加了wait(70*1000),结果比如开始执行是在10:10:10,到10:11:20执行结束,10:11:20开始执行下一次定时。10:12:30执行结束,10:12:30开始执行下一...
  • java定时器Timer

    2017-06-11 15:28:38
    Java定时任务调度工具–Timer和QuartTimer是JDK直接提供的,Quart是需要导入jar包的。Timer只有一个后台线程去执行任务,Quart有多个线程执行。Timer工具位于java.util.Timer中,可以上官方文档查看API.TimerThread...
  • 一:用Timer作为定时器,五秒一刷新,关闭窗口,定时器随之关闭。   public TimerTask runTimes() { TimerTask task = new TimerTask() { public synchronized void run() { // TODO Auto-generated ...
  • JavaTimer和TimerTask 定时器使用
  • Java定时器Timer

    2018-03-01 15:53:16
    定时器的实现原理就是新开一个子线程执行定时任务。 一、一次执行定时器。一次执行定时器的时间如果在当前时间以前会立即执行任务,如果在未来时间,则会到指定的未来时间再执行任务。示例代码:public static void ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,905
精华内容 2,762
关键字:

java停止timer定时器

java 订阅