您的位置：360文档中心› Java里timer执行定时任务

Java里timer执行定时任务

合集下载

java的timer用法

java的timer用法

java的timer用法Java的Timer用法Java的Timer类是用于调度任务的工具，可以在指定时间后执行任务，也可以在指定时间间隔内重复执行任务。

在本文中，我们将介绍Java的Timer类的详细用法。

一、Timer类的基本概念1. Timer类的作用Java中的Timer类是一个工具类，它允许您安排指定时间后或以固定时间间隔重复执行任务。

您可以使用它来实现各种计划任务，例如：自动备份数据库、发送电子邮件等。

2. Timer类的构造方法Timer类有两个构造方法：（1）public Timer()：创建一个新计时器。

（2）public Timer(boolean isDaemon)：创建一个新计时器，并指定该计时器是否为守护线程。

3. TimerTask类在使用Timer类之前，您需要先了解一下TimerTask类。

TimerTask 是一个抽象类，它表示要执行的任务。

您需要创建一个继承自TimerTask的子类，并覆盖run()方法来定义要执行的任务。

二、使用示例下面我们将通过几个示例来介绍如何使用Java的Timer类。

1. 在指定时间执行任务以下示例演示了如何使用Java的Timer类，在指定时间后执行一次任务：```javaimport java.util.Timer;import java.util.TimerTask;public class ScheduledTask {public static void main(String[] args) {Timer timer = new Timer();timer.schedule(new MyTask(), 5000);}}class MyTask extends TimerTask {public void run() {System.out.println("任务执行了");}}```在上面的示例中，我们创建了一个Timer对象，并使用schedule()方法来安排任务。

java 定时器用法

java 定时器用法

java 定时器用法全文共四篇示例，供读者参考第一篇示例：Java中的定时器是一种功能强大的工具，可以帮助我们实现定时执行任务的功能，例如定时发送邮件、定时备份数据等。

在本文中，我们将详细介绍Java定时器的用法，包括如何使用Java提供的Timer 类、ScheduledExecutorService接口等来创建定时器。

一、使用Timer类创建定时器Java提供了Timer类来实现定时器的功能。

Timer类可以在指定时间间隔内执行指定的任务。

下面是一个使用Timer类创建定时器的简单示例：```javaimport java.util.Timer;import java.util.TimerTask;在上面的示例中，我们首先创建了一个Timer实例，然后创建了一个TimerTask对象，并实现了其中的run方法，该方法中编写了定时执行的任务。

最后调用Timer的schedule方法来设置定时任务的执行时间和间隔。

二、使用ScheduledExecutorService接口创建定时器除了Timer类外，Java还提供了ScheduledExecutorService接口来创建定时器。

ScheduledExecutorService是ExecutorService的子接口，支持延迟执行、周期性执行等功能。

下面是一个使用ScheduledExecutorService接口创建定时器的示例：```javaimport java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;三、定时器的取消和异常处理在实际开发中，我们可能需要在一定条件下取消定时器的执行，或者处理定时任务中可能出现的异常。

下面是一个示例，演示了如何取消定时器的执行，并如何处理任务中可能出现的异常：在上面的示例中，我们在任务的run方法中使用try-catch语句来捕获可能出现的异常，并在另一个任务中取消了定时器的执行。

定时调用程序（java中的定时器Timer）

定时调用程序（java中的定时器Timer）

定时调用程序（java中的定时器Timer）定时调用程序：1.首先编写一个方法，定时器要定时执行的方法。

比如：public class UpdateLucene {public void runUpdateLucene(){System.out.println("你好");}}2.定义一个类要继承TimerTask，即为：定时器要执行的任务。

例如：public class RunUpdateLucene extends TimerTask{private ServletContext context = null;public RunUpdateLucene(ServletContext context) {this.context=context;}@Overridepublic void run() {//调用上面我们定义的那个类的方法。

new UpdateLucene().runUpdateLucene();}}3.定义一个类实现ServletContextListener接口，然后实现里面的两个方法：初始化和销毁的方法。

public class LuceneImpl implements ServletContextListener { private Timer timer = null;public void contextInitialized(ServletContextEvent event){timer = new java.util.Timer(true);event.getServletContext().log("定时器已启动");//每隔30分钟执行一次。

（里面有三个参数：1.执行的任务对象，2.延迟的时间，3，相隔的时间）timer.schedule(newRunUpdateLucene(event.getServletContext()), 0, 30*1000);event.getServletContext().log("已经添加任务调度表");}public void contextDestroyed(ServletContextEvent event){timer.cancel();event.getServletContext().log("定时器销毁");}}4.在配置文件中，配置我们的定时器。

javaTimer定时每天凌晨1点执行任务

javaTimer定时每天凌晨1点执行任务

javaTimer定时每天凌晨1点执⾏任务下⾯给⼤家介绍java Timer 定时每天凌晨1点执⾏任务，具体代码如下所⽰：import java.util.TimerTask;/*** 执⾏内容* @author admin_Hzw**/public class Task extends TimerTask {public void run() {System.out.println("我有⼀头⼩⽑驴!");}}import java.util.Calendar;import java.util.Date;import java.util.Timer;/*** 任务管理* @author admin_Hzw**/public class TimerManager {/*** @param args*/public static void main(String[] args) {new TimerManager();}//时间间隔(⼀天)private static final long PERIOD_DAY = 24 * 60 * 60 * 1000;public TimerManager() {Calendar calendar = Calendar.getInstance();calendar.set(Calendar.HOUR_OF_DAY, 1); //凌晨1点calendar.set(Calendar.MINUTE, 0);calendar.set(Calendar.SECOND, 0);Date date=calendar.getTime(); //第⼀次执⾏定时任务的时间//如果第⼀次执⾏定时任务的时间⼩于当前的时间//此时要在第⼀次执⾏定时任务的时间加⼀天，以便此任务在下个时间点执⾏。

如果不加⼀天，任务会⽴即执⾏。

if (date.before(new Date())) {date = this.addDay(date, 1);}Timer timer = new Timer();Task task = new Task();//安排指定的任务在指定的时间开始进⾏重复的固定延迟执⾏。

JAVA定时器的三种方法(详细注解)

JAVA定时器的三种方法(详细注解)

JAVA定时器的三种方法（详细注解）在Java中，有三种主要的定时器方法可以实现任务的定时执行。

这些方法包括Timer类、ScheduledThreadPoolExecutor类和TimerTask类。

下面将详细介绍这三种定时器方法的使用。

1. Timer类：Timer类是Java提供的一个基本的定时器类，可以用于在指定的时间间隔内执行指定的任务。

Timer类提供了schedule(和scheduleAtFixedRate(两个方法，用于按照指定的时间间隔执行任务。

（1）schedule(方法：该方法用于在指定的时间间隔后执行任务。

它的语法如下：public void schedule(TimerTask task, long delay)参数task表示要执行的任务，它是一个实现了TimerTask接口的类的实例。

参数delay表示延迟的时间，以毫秒为单位。

例如，下面的代码使用Timer类的schedule(方法，在延迟2秒后执行一个任务：```public void ruSystem.out.println("任务执行了");}},2000);```当运行上述代码后，程序将会输出"任务执行了"。

（2）scheduleAtFixedRate(方法：该方法用于以固定的时间间隔执行任务。

它的语法如下：public void scheduleAtFixedRate(TimerTask task, long delay, long period)参数task表示要执行的任务，它是一个实现了TimerTask接口的类的实例。

参数delay表示延迟的时间，以毫秒为单位。

参数period表示每次任务执行间隔的时间，也是以毫秒为单位。

例如，下面的代码使用Timer类的scheduleAtFixedRate(方法，延迟2秒后开始执行一个任务，并且每隔1秒执行一次：```public void ruSystem.out.println("任务执行了");}},2000,1000);```当运行上述代码后，程序将会输出"任务执行了"，并且每隔1秒输出一次。

java中定时任务的写法

java中定时任务的写法

java中定时任务的写法在Java中，可以使用以下几种方法来实现定时任务：1.使用Timer类Timer类提供了一种简单的方法来创建定时任务。

Timer类的构造方法有两个参数：一个是时钟源，另一个是任务执行器。

时钟源用于指定任务执行的时间，任务执行器用于执行任务。

以下是使用Timer类创建定时任务的示例：import java.util.Timer;import java.util.TimerTask;public class TimerExample{public static void main(String[]args){创建一个定时器Timer timer=new Timer();创建一个任务TimerTask task=new TimerTask(){Overridepublic void run(){System.out.println("Hello,world!");}};安排任务在5秒后执行timer.schedule(task,5000);}}输出结果：Hello,world!2.使用ScheduledExecutorService类ScheduledExecutorService类提供了一种更灵活的方法来创建定时任务。

ScheduledExecutorService类的构造方法有两个参数：一个是核心线程数，另一个是最大线程数。

核心线程数是指在空闲时不被回收的线程数，最大线程数是指允许创建的最大线程数。

以下是使用ScheduledExecutorService类创建定时任务的示例：import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;public class ScheduledExecutorServiceExample{public static void main(String[]args){创建一个定时执行器ScheduledExecutorServiceexecutorService=Executors.newScheduledThreadPool(1);创建一个任务Runnable task=()->System.out.println("Hello,world!");安排任务在5秒后执行executorService.schedule(task,5,TimeUnit.SECONDS);}}输出结果：Hello,world!3.使用cron表达式使用cron表达式可以指定任务的执行时间。

java定时任务实现原理及扩展思路-----Timer

java定时任务实现原理及扩展思路-----Timer

java定时任务实现原理及扩展思路-----Timer java定时任务实现原理-----Timer近期在项⽬中使⽤到了java的定时任务, 但是是⾮固定周期的重复性定时任务, 于是想对最基础的Timer实现原理探究⼀下.定时任务需要哪些组件?⼤致我们能够想到, ⼀个定时任务⾄少需要三个组件:1. 承载业务的对象 ----- 被调度对象2. 存储容器 ----- 暂时存储被调度对象, 这个容器内的元素应该是有顺序的,3. 调度器 ------ 管理存储容器, 通过限时进⼊等待与被唤醒实现定时在java中, 最简单的定时任务实现就是Timer.简单Demo如下:public static void main(String[] args) {TimerTask task1 = new TimerTask() {@Overridepublic void run() {System.out.println("延迟10s");System.out.println(System.currentTimeMillis());//结束定时器throw new RuntimeException();}};Timer timer = new Timer();timer.schedule(task1, 10000);System.out.println(System.currentTimeMillis());}TimerTask 承载业务, 其中定义了⼏个状态,防⽌但实例被多线程调度Timer中聚合了 TaskQueue和TimerThread.TaskQueue 储存TimerTask, 内部存储的元素具有有序, 通过TaskQueue#getMin获取延迟时间最⼩的任务TimerThread 主要完成调度⼯作, 主要代码如下:private void mainLoop() {while (true) {try {TimerTask task;boolean taskFired;//1. 因为TaskQueue内部没有实现线程安全, 所以对queue的修改以及查询都需要加锁//2. 当TimerThread在queue实例上等待的时候, 调⽤queue对象的的notify可以唤醒// TimerTasksynchronized(queue) {// Wait for queue to become non-emptywhile (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 thinglong 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)) {//如果是⾮重复性任务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);}}}//如果任务的预执⾏时刻还未到, 则当前线程进⼊限时等待.if (!taskFired) // Task hasn't yet fired; waitqueue.wait(executionTime - currentTime);}if (taskFired) // Task fired; run it, holding no lockstask.run();} catch(InterruptedException e) {}}}1. TimerTask 启动之后就会进⼊等待, 直到有其他线程唤醒为⽌.2. TimerTask 被唤醒之后, 拿到任务, 如果是周期性任务, 就调整任务的下⼀次执⾏时间,如果是⾮周期性任务, 直接删除即可(这样也就是延时任务与周期性任务的实现)3. 如果还没到任务预定的执⾏时刻, TimerThread 会进⼊限时等待状态, 后续有其他线程调⽤schedul()这类⽅法,有机会使TimerTask提前被唤醒, 如果被唤醒, 那么将进⼊下⼀次循环.(这个使得先提交延时长的任务, 后提交延时短的任务, 但是依然能按照预定延时实现)Timer的弊端:1. 单线程不可靠2. 对于重复执⾏的任务, 周期只能固定3. 重复执⾏的任务, 重复的次数不好控制, 不好实现有条件的重复扩展思路:1. 单线程不可靠如何扩展?可以使⽤线程池来完成调度2. 重复性任务周期固定?⾸先需要扩展TimerTask, 增加⼀个getPeriod()⽅法, 这个⽅法的返回值可以随着当前实例被调⽤次数⽽改变,这样即可实现⾃定义周期扩展如上代码, 使得重复性任务只能以固定周期执⾏. 如果将 task.period 调⽤该为 task.getPeriod(),我们就可以通过扩展Timer实现getPeriod()⽅法使得:不固定周期的重复性任务可控制重复次数的重复任务有条件的重复任务完全⽆规律就按照给的时间执⾏的重复任务...。

java定时任务实现的4种方式小结

java定时任务实现的4种方式小结

java定时任务实现的4种⽅式⼩结1. java⾃带的TimerTimer timer = new Timer();timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("Time's up!");}},3*1000,1000);2.ScheduledThreadPool-线程池ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);scheduledThreadPool.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("=========================");}}, 1000, 2000, LISECONDS);scheduledThreadPool.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println(System.currentTimeMillis()+"<><>"+System.nanoTime());}}, 1000, 2000, LISECONDS);3.使⽤注解的形式：@Scheduled@Componentpublic class SpringScheduled {@Scheduled(initialDelay = 2000,fixedDelay = 5000)public void doSomething() {System.out.println("Spring⾃带的Scheduled执⾏了=======================");}}//下⾯是开启@SpringBootApplication@EnableSchedulingpublic class DemoApplication {public static void main(String[] args) throws InterruptedException {SpringApplication application = new SpringApplication(DemoApplication.class);application.addListeners(new ContextRefreshedEventListener());application.run(args);}}4.使⽤Quartz定时任务调度器配置@Configurationpublic class QuartzConfig {@Resourceprivate ScheduleTask scheduleTask;/*** 配置定时任务1* @return*/@Bean(name="firstJobDetail")public MethodInvokingJobDetailFactoryBean firstJobDetail(){MethodInvokingJobDetailFactoryBean method = new MethodInvokingJobDetailFactoryBean();// 为需要执⾏的实体类对应的对象method.setTargetObject(scheduleTask);// 需要执⾏的⽅法method.setTargetMethod("test");// 是否并发执⾏method.setConcurrent(false);return method;}/*** 配置触发器1* @param firstJobDetail* @return*/@Bean(name="firstTrigger")public SimpleTriggerFactoryBean firstTrigger(JobDetail firstJobDetail){SimpleTriggerFactoryBean simpleBean = new SimpleTriggerFactoryBean();simpleBean.setJobDetail(firstJobDetail);// 设置任务启动延迟simpleBean.setStartDelay(1000);// 每1秒执⾏⼀次simpleBean.setRepeatInterval(1000);//设置重复计数//simpleBean.setRepeatCount(0);return simpleBean;}/*** 配置Scheduler*/@Bean(name = "scheduler")public SchedulerFactoryBean schedulerFactoryBean(Trigger firstTrigger){SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();factoryBean.setTriggers(firstTrigger);return factoryBean;}}要执⾏的任务@Componentpublic class ScheduleTask {public void test() {System.out.println("====================================");}}总结：还有其他⽅式可以实现定时任务的⽅式，可以贴出来，讨论讨补充知识：SpringBoot定时任务简单使⽤和⾃定义开启关闭修改周期⼀、简单使⽤1.pom加⼊基本springboot基本的starter即可<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><optional>true</optional></dependency>2.@Scheduled 参数可以接受两种定时的设置，⼀种是我们常⽤的cron="*/6 * * * * ?",⼀种是 fixedRate = 6000，两种都表⽰每隔六秒打印⼀下内容。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

java定时任务Timer 关于定时任务，似乎跟时间操作的联系并不是很大，但是前面既然提到了定时任务，索性在这里一起解决了。

设置定时任务很简单，用Timer类就搞定了。

一、延时执行首先，我们定义一个类，给它取个名字叫TimeTask，我们的定时任务，就在这个类的main函数里执行。

代码如下：
解释一下上面的代码。

上面的代码实现了这样一个功能，当TimeTask程序启动以后，过一分钟后执行某项任务。

很简单吧：先new一个Timer对象，然后调用它的schedule方法，这个方法有四个重载的方法，这里我们用其中一个，
首先，第一个参数第一个参数就是我们要执行的任务。

这是一个TimerTask对象，确切点说是一个实现TimerTask的类的对象，因为TimerTask是个抽象类。

上面的代码里面，Task就是我们自己定义的实现了TimerTask的类，因为是在同一个包里面，所以没有显性的import进来。

Task类的代码如下
我们的Task必须实现TimerTask的方法run，要执行的任务就在这个run方法里面，这里，我们只让它往控制台打一行字。

第二个参数第二个参数是一个long型的值。

这是延迟的时间，就是从程序开始以后，再过多少时间来执行定时任务。

这个long型的值是毫秒数，所以前面我们的程序里面，过一分钟后执行用的参数值就是60 * 1000。

二、循环执行设置定时任务的时候，往往我们需要重复的执行这样任务，每隔一段时间执行一次，而上面的方法是只执行一次的，这样就用到了schedule方法的是另一个重载函数
前两个参数就不用说什么了，最后一个参数就是间隔的时间，又是个long型的毫秒数（看来java里涉及到时间的，跟这个long是脱不了干系了），比如我们希望上面的任务从第一次执行后，每个一分钟执行一次，第三个参数值赋60 * 1000就ok了。

三、指定执行时间既然号称是定时任务，我们肯定希望由我们来指定任务指定的时间，显然上面的方法就不中用了，因为我们不知道程序什么时间开始运行，就没办法确定需要延时多少。

没关系，schedule 四个重载的方法还没用完呢。

用下面这个就OK了：
比如，我们希望定时任务2006年7月2日0时0分执行，只要给第二个参数传一个时间设置为2006年7月2日0时0分的Date对象就可以了。

有一种情况是，可能我们的程序启动的时候，已经是2006
年7月3日了，这样的话，程序一启动，定时任务就开始执行了。

schedule最后一个重载的方法是
没必要说什么了吧:)
四、j2ee中的定时任务在实际的项目中，往往定时任务需要对web工程中的资源进行操作，这样一来，用上面的单个程序的方式可能就有点力不从心了，因为很多web工程的资源它操作不到。

解决的办法是，使用Servlet，把执行定时任务的那些代码放到Servlet的init()函数里就可以了，这个easy，就没有必要再写示例代码了吧。

相关文档
最新文档